English | 中文

pluginhub

qxbyte's plugin marketplace for CLI coding agents (Claude Code / CodeBuddy).

pluginhub is a small plugin marketplace: add it once, then install any plugin it hosts. More plugins will land here over time.

Plugins

Plugin	Version	What it does
specode	6.1.4	Lightweight spec-driven workflow orchestration shell — walks a host agent through requirements → design → tasks → execute → acceptance, delegating each phase to superpowers skills with a first-class specode-native fallback, and landing 4 fixed docs per spec (requirements / design / tasks / implementation-log). Bundles a dedicated intake skill, a zero-import task-swarm handoff for parallel execution, and optional locate-oriented experience retrieval. Version history is in the CHANGELOG.
task-swarm	0.10.3	Standalone multi-agent orchestration driven by a pipeline.yml — semantic task groups with cross-group concurrency, forked coders, and per-group reviewer + validator loops (state.json is the single source of truth). specode delegates its execution phase here; also runnable directly via /task-swarm:swarm. See plugins/task-swarm/ + its CHANGELOG.
obsidian-wiki	2.0.3	Maintain an Obsidian LLM-Wiki via three skills — a deterministic structure layer (wiki-struct), content curation (wiki-curate), and a unified orchestrator (wiki-orchestrate). Generic code + per-vault config in the home-dir registry ~/.config/obsidian-wiki/ (fallback: <vault>/.wiki/config.json), zero hardcoded structure. See plugins/obsidian-wiki/.
ragkit	0.1.1	Standalone knowledge-base RAG — vector + lexical + metadata three-channel recall, RRF-fused, returns pointer cards. Optional downstream consumer of specode distill output; zero heavy deps (stdlib + numpy for lexical mode). See plugins/ragkit/.

## Installation covers the whole marketplace; the other sections (Highlights, Usage, Architecture) document specode, the flagship plugin. For task-swarm, see its sources and CHANGELOG under plugins/task-swarm/; for obsidian-wiki, see its own README.md / AGENTS.md under plugins/obsidian-wiki/.

Highlights

• Orchestration shell, not a state machine. specode delegates each phase to a mature superpowers skill (brainstorming → writing-plans → subagent-driven-development / executing-plans → verification-before-completion). It owns only what's uniquely its own: the spec lifecycle, fixed-doc landing, and the task-swarm bridge.
• Works standalone (native fallback). No superpowers? specode runs the clarify / plan / execute / verify loop itself with AskUserQuestion wizards and sequential TDD. The native path is a first-class peer, not an afterthought.
• 4 fixed documents, fixed names, fixed location. Every spec produces requirements.md / design.md (传统设计文档: architecture / modules / interfaces / data flow) / tasks.md (the executable plan, engine-neutral) / implementation-log.md under <specsRoot>/<slug>/ — whatever engine generated the content. Bug fixes use prose in requirements.md (no bugfix.md).
• Documents are the state. No persistent session files, no locks, no status footer, no logging. "Which phase am I in?" is inferred from which fixed docs exist plus the - [ ] checkbox progress in tasks.md (5.x legacy specs: design.md).
• One adaptive selector. After tasks.md is confirmed, an AskUserQuestion selector offers up to 4 execution paths — only the ones whose engine is installed: 委托 task-swarm / superpowers subagent-driven / superpowers executing-plans / specode 自执行.
• First-run specsRoot setup. On first use specode asks once for your document directory and uses it verbatim as the specs root, then persists it to ~/.config/specode/config.json.specsRoot and never asks again.
• One lightweight hook. A single advisory SessionStart hook reminds the agent specode is available. No blocking, no per-turn machinery.
• Parallel execution is a separate plugin. Pick "委托 task-swarm" and specode reads tasks.md, derives a pipeline.yml, and hands off to the standalone task-swarm plugin (zero import).
• Project-level constraints follow the chain. specode + task-swarm (AI-EDS v0.9 痛点 #14 方案 D, preserved into v4.0.0 / v0.10.0) scan CLAUDE.md / AGENT.md / AGENTS.md / CODEBUDDY.md at <project_root>, its parent directory, and any subdir touched by @writes, and surface the matched absolute paths (not content) into both requirements.md (## 项目级约束) and every coder / reviewer / validator task.md (## 项目级约束（必读）). _PROJECT_AGENT_DOCS.md inbox sentinel reinforces the hard constraint. Fixes the silent drop where independent subagent processes never see the host agent's auto-loaded instruction files.
• Autonomous mode / CI friendly (opt-in). Set SPECODE_INTERACTIVE=false plus relevant SPECODE_PROJECT_ROOT / SPECODE_EXECUTION_MODE / SPECODE_AUTO_DISTILL / SPECODE_SPECS_ROOT_DEFAULT env vars (or persist via resolve_root.py write-default --key X --value Y), and every AskUserQuestion gate that would normally block in CI / long-running sessions skips silently with the configured default. Schema default is interactive=true so existing installs see zero behaviour change — only opt-in users get the autonomous path.
• Location-oriented knowledge, not memory injection. The old AI-EDS memory-injection pipeline (specode P3-1 codemap recall + P3-2 rule-check + acceptance auto-distill, plus task-swarm cmd_resolve auto-ingest writing .ai-memory/knowledge/*.yml) was removed in v4.0.0 / v0.10.0 after baseline experiments (3 cases) showed the recall round-trip did not net save token; neither plugin reads / writes .ai-memory/knowledge/. v5.1.0 reintroduced retrieval on a deliberately different, pointers-not-facts footing: run /specode:distill <slug> manually to sediment atomic case / navigation knowledge points into the project's own <project_root>/knowledge-base/ (gitignored; optional copy to an Obsidian dir you specify), and the requirements / design phases run a two-tier gated retrieval over its small MEMORY.md index to locate real code faster — real code stays the sole source of truth, and execution / task-swarm receive zero injection. To restore v3.4.0 / v0.9.2 behaviour: git checkout backup/specode-v3.4.0-task-swarm-v0.9.2.

Installation

📌 Marketplace name is pluginhub (the repo name), not qxbyte (the owner name). All install / uninstall commands use <plugin>@pluginhub, e.g. specode@pluginhub and task-swarm@pluginhub. Using @qxbyte will fail with Marketplace "qxbyte" not found. Cached plugins are also stored under ~/.claude/plugins/cache/pluginhub/<plugin>/<version>/ — useful when troubleshooting which version is actually loaded.

From GitHub (recommended)

Works with either CLI; the plugin manifest is shared. CodeBuddy verified on 2.97.1.

# CodeBuddy
codebuddy plugin marketplace add https://github.com/qxbyte/pluginhub
codebuddy plugin install specode@pluginhub

# Claude Code
claude plugin marketplace add https://github.com/qxbyte/pluginhub
claude plugin install specode@pluginhub

For the full superpowers-backed experience, also install the superpowers plugin. For multi-agent parallel execution, also install task-swarm from this same marketplace (no second marketplace add needed) — specode delegates the execution phase to it when installed, and self-executes sequentially otherwise:

# Claude Code
claude plugin install task-swarm@pluginhub
# CodeBuddy
codebuddy plugin install task-swarm@pluginhub

specode runs fine without either via its native fallbacks.

One-shot (Claude Code only)

claude --plugin-url https://github.com/qxbyte/pluginhub/archive/refs/heads/main.zip

Local development

git clone https://github.com/qxbyte/pluginhub.git
claude    --plugin-dir ./pluginhub/plugins/specode
codebuddy --plugin-dir ./pluginhub/plugins/specode

# add task-swarm too if you want delegated multi-agent execution
claude --plugin-dir ./pluginhub/plugins/specode --plugin-dir ./pluginhub/plugins/task-swarm

Uninstall

claude plugin uninstall specode@pluginhub
claude plugin uninstall task-swarm@pluginhub   # if installed
claude plugin marketplace remove pluginhub
# optional: wipe user-level config (and legacy ~/.specode state)
rm -rf ~/.specode ~/.config/specode

Update

# Claude Code
claude plugin update specode@pluginhub
claude plugin marketplace update pluginhub

# CodeBuddy
codebuddy plugin update specode@pluginhub
codebuddy plugin marketplace update pluginhub

Usage

specode has exactly four commands.

1. Start a spec

/specode:spec <requirement>

cd to your project directory first — specode derives the default project root from the cwd (git rev-parse --show-toplevel, falling back to cwd) and asks you to confirm it once per spec. On the first ever run it also asks once for your document management directory and remembers it. The agent then walks the pipeline:

1. requirements — the specode:intake skill (specode's own, always) runs project analysis (agent-docs scan + experience retrieval + reading the located real code) → analysis-driven clarification → writes requirements.md with the frontmatter contract (spec_id / created_at / project_root). This is also the primary node for ragkit/experience retrieval.
2. design — produce a traditional design doc design.md (architecture / modules / interfaces / data flow / error handling / test strategy) via superpowers:brainstorming (design only) or native authoring.
3. tasks — produce the executable plan tasks.md (via superpowers:writing-plans, or native Task breakdown). Engine-neutral: every execution path consumes this one file.
4. 执行方式 selector — pick how to execute (adaptive 4 options; see Highlights).
5. execute — run the plan with TDD, appending to implementation-log.md.
6. verify — check against the requirements.md AC-N items, the design's 测试策略, and the tasks.md checkboxes, then ask you to accept.

All output lands under <specsRoot>/<slug>/ as the 4 fixed documents.

2. Resume a spec

/specode:continue <slug>

<slug> is required. specode locates <specsRoot>/<slug>/, infers the phase from the documents present (and the - [ ] progress in tasks.md; 5.x legacy specs: design.md), reports a progress brief, then stops and waits — say "继续" to resume, or supply requirement changes first. It never auto-resumes. Use /specode:list to find a slug.

3. List specs

/specode:list

Lists every spec under <specsRoot> with its inferred phase. Overview only — it does not resume.

4. Distill knowledge (off-pipeline)

/specode:distill <slug> [--target-dir <abs-path>]

Manually sediments a finished spec (plus the current agent context) into atomic case / navigation knowledge points under the project's own <project_root>/knowledge-base/ (cases/ + navigation/ + a MEMORY.md index, gitignored), optionally copying them to an Obsidian directory. The requirements / design phases later retrieve these as location pointers, never facts — real code stays the sole source of truth. Never auto-run; the acceptance phase only offers it.

Architecture

.claude-plugin/marketplace.json   marketplace manifest (specode + task-swarm + obsidian-wiki)
plugins/specode/
  .claude-plugin/plugin.json      plugin manifest
  hooks/hooks.json                1 advisory SessionStart hook
  commands/spec.md        /specode:spec (new spec)
  commands/continue.md    /specode:continue <slug>
  commands/list.md        /specode:list
  commands/distill.md     /specode:distill <slug> (off-pipeline sedimenter)
  scripts/
    resolve_root.py               specsRoot / project_root / defaults CLI
    knowledge.py                  knowledge-base index CLI (MEMORY rebuild/validate/copy-to)
    spec_hooks.py                 SessionStart discipline injection
    run.sh / run.cmd              python3 → python → py interpreter probe
  skills/specode/
    SKILL.md                      the orchestration shell (all behavior)
    references/
      selectors.md                执行方式 selector verbatim examples
      obsidian.md                 specsRoot path resolution + conventions
      superpowers-wiring.md       phase ↔ superpowers skill mapping
      retrieval.md                experience retrieval spec (intake primary node)
      autonomous-mode.md          non-interactive / CI defaults rule
      knowledge-flow.md           one-page knowledge-loop mental model
  skills/intake/
    SKILL.md                      requirements phase engine (analysis + clarify + write)
  skills/distill/
    SKILL.md                      /specode:distill behavior (case/navigation points)
    references/                   breakdown heuristics + doc templates
  assets/templates/               requirements.md / design.md / tasks.md /
                                  implementation-log.md seed templates
  tests/                          hermetic pytest suite (resolve_root.py + knowledge.py)

The companion task-swarm plugin (plugins/task-swarm/) is a standalone multi-agent orchestrator that specode optionally hands off to; see its own skills/task-swarm/SKILL.md and CHANGELOG.md. The obsidian-wiki plugin (plugins/obsidian-wiki/) is self-contained and documented by its own README.md / AGENTS.md.

Contributing

See CONTRIBUTING.md for the stdlib-only runtime rule, the run.sh CLI invocation contract, the advisory-hook rule, hermetic test conventions, and the release procedure.

License

MIT