wicked-garden 12.27.0 → 12.28.1

package/.claude-plugin/components.json

@@ -1,46 +1,59 @@
 {
-  "_comment": "Issue #328: Component declarations for wicked-garden plugin. Claude Code plugin.json does not yet support inline component declarations beyond path overrides. This manifest documents all components for tooling, validation, and future schema support. When plugin.json gains a 'components' field, merge this data into plugin.json.",
+  "_comment": "Issue #328: Component declarations for wicked-garden plugin. Claude Code plugin.json does not yet support inline component declarations beyond path overrides. This manifest documents all components for tooling, validation, and future schema support. When plugin.json gains a 'components' field, merge this data into plugin.json. The plugin is skills-only: former commands/ became actions of consolidated per-domain skills, and former agents/ became standalone context:fork worker skills (enumerated under fork_skills). Regenerate derived blocks with scripts/ci/sync_components.py.",
   "domains": ["agentic", "crew", "data", "engineering", "jam", "mem", "persona", "platform", "product", "qe", "search", "smaht"],
   "summary": {
-    "commands": 77,
-    "agents": 23,
-    "skills": 67,
+    "skills": 94,
+    "fork_skills": 34,
     "hooks": 13,
     "specialists": 7
   },
-  "agents_by_domain": {
-    "agentic": ["architect", "performance-analyst", "safety-reviewer"],
-    "crew": ["implementer", "researcher", "reviewer"],
-    "data": ["data-engineer"],
-    "engineering": ["api-documentarian", "migration-engineer", "solution-architect"],
-    "jam": ["brainstorm-facilitator", "council", "quick-facilitator"],
-    "persona": ["persona-agent"],
-    "platform": ["compliance-officer", "privacy-expert", "security-engineer"],
-    "product": ["a11y-expert", "requirements-analyst", "ui-reviewer", "ux-designer", "value-strategist"],
-    "qe": ["semantic-reviewer"]
-  },
   "skills_by_domain": {
-    "agentic": ["agentic-patterns", "context-engineering", "frameworks", "review-methodology", "trust-and-safety"],
+    "agentic": ["agentic", "agentic-patterns", "context-engineering", "frameworks", "review-methodology", "trust-and-safety"],
+    "agentic-architect": ["agentic-architect"],
+    "agentic-performance-analyst": ["agentic-performance-analyst"],
+    "agentic-safety-reviewer": ["agentic-safety-reviewer"],
     "archetype": ["archetype"],
     "classify": ["classify"],
-    "data": ["analysis", "data", "ml", "pipeline"],
+    "core": ["core"],
+    "crew-implementer": ["crew-implementer"],
+    "crew-researcher": ["crew-researcher"],
+    "crew-reviewer": ["crew-reviewer"],
+    "data": ["data"],
+    "data-engineer": ["data-engineer"],
     "deliberate": ["deliberate"],
     "engineering": ["architecture", "backend", "debugging", "docs", "engineering", "frontend", "integration", "large-scale-migration", "patch", "system-design", "unit-test-quality"],
+    "engineering-api-documentarian": ["engineering-api-documentarian"],
+    "engineering-migration-engineer": ["engineering-migration-engineer"],
+    "engineering-solution-architect": ["engineering-solution-architect"],
     "ground": ["ground"],
     "integration-discovery": ["integration-discovery"],
     "jam": ["jam"],
+    "jam-brainstorm-facilitator": ["jam-brainstorm-facilitator"],
+    "jam-council": ["jam-council"],
     "multi-model": ["multi-model"],
     "persona": ["persona"],
-    "platform": ["audit", "compliance", "errors", "gate-benchmark-rebaseline", "gh-cli", "github-actions", "gitlab-ci", "glab-cli", "health", "observability", "prereq-doctor"],
-    "product": ["acceptance-criteria", "accessibility", "analyze", "imagery", "listen", "mockup", "requirements-analysis", "requirements-graph", "requirements-migrate", "requirements-navigate", "screenshot", "strategy", "synthesize", "ux-review", "visual-review"],
+    "persona-agent": ["persona-agent"],
+    "platform": ["audit", "compliance", "errors", "gate-benchmark-rebaseline", "gh-cli", "github-actions", "gitlab-ci", "glab-cli", "health", "observability", "peer-health", "platform", "prereq-doctor"],
+    "platform-compliance-officer": ["platform-compliance-officer"],
+    "platform-privacy-expert": ["platform-privacy-expert"],
+    "platform-security-engineer": ["platform-security-engineer"],
+    "product": ["acceptance-criteria", "accessibility", "analyze", "imagery", "listen", "mockup", "product", "requirements-analysis", "requirements-graph", "requirements-migrate", "requirements-navigate", "screenshot", "strategy", "synthesize", "ux-review", "visual-direction", "visual-review"],
+    "product-a11y-expert": ["product-a11y-expert"],
+    "product-requirements-analyst": ["product-requirements-analyst"],
+    "product-ui-reviewer": ["product-ui-reviewer"],
+    "product-ux-designer": ["product-ux-designer"],
+    "product-value-strategist": ["product-value-strategist"],
+    "prove": ["prove"],
+    "qe-semantic-reviewer": ["qe-semantic-reviewer"],
     "runtime-exec": ["runtime-exec"],
-    "search": ["codebase-narrator"],
+    "search": ["codebase-narrator", "search"],
     "smaht": ["discovery", "intent", "propose-skills", "smaht"],
     "swarm": ["swarm"],
     "wickedizer": ["wickedizer"],
     "workflow": ["workflow"],
     "worktrees": ["worktrees"]
   },
+  "fork_skills": ["wicked-garden-agentic-architect", "wicked-garden-agentic-performance-analyst", "wicked-garden-agentic-safety-reviewer", "wicked-garden-archetype", "wicked-garden-classify", "wicked-garden-crew-implementer", "wicked-garden-crew-researcher", "wicked-garden-crew-reviewer", "wicked-garden-data-engineer", "wicked-garden-engineering-api-documentarian", "wicked-garden-engineering-debugging", "wicked-garden-engineering-migration-engineer", "wicked-garden-engineering-solution-architect", "wicked-garden-ground", "wicked-garden-integration-discovery", "wicked-garden-jam-brainstorm-facilitator", "wicked-garden-jam-council", "wicked-garden-multi-model", "wicked-garden-persona-agent", "wicked-garden-platform-compliance-officer", "wicked-garden-platform-privacy-expert", "wicked-garden-platform-security-engineer", "wicked-garden-product-a11y-expert", "wicked-garden-product-requirements-analyst", "wicked-garden-product-ui-reviewer", "wicked-garden-product-ux-designer", "wicked-garden-product-value-strategist", "wicked-garden-qe-semantic-reviewer", "wicked-garden-runtime-exec", "wicked-garden-smaht", "wicked-garden-swarm", "wicked-garden-wickedizer", "wicked-garden-workflow", "wicked-garden-worktrees"],
   "hooks": ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PostToolUseFailure", "TaskCompleted", "SubagentStart", "SubagentStop", "PermissionRequest", "Notification", "PreCompact", "Stop", "SessionEnd"],
   "specialists": [
     {

package/.claude-plugin/marketplace.json

@@ -7,9 +7,9 @@
     {
       "name": "wicked-garden",
       "source": "./",
-      "description": "Your coding agent already plans and swarms \u2014 Wicked Garden is the curated toolkit for what it can't: proof-not-claims gates, code links grep can't see, deterministic refactor, cross-session memory, real multi-model second opinions. Don't fight the harness; fill its gaps. The gate needs wicked-vault + wicked-loom; testing/brain/bus are opt-in layers.",
-      "version": "12.27.0"
+      "description": "Your coding agent already plans and swarms \u2014 Wicked Garden is the curated toolkit for what it can't: proof-not-claims gates, code links grep can't see, deterministic refactor, cross-session memory, real multi-model second opinions. Don't fight the harness; fill its gaps. The gate needs wicked-vault (auto-installed via wicked-testing) and re-derives through garden's built-in engine; testing/brain/bus are opt-in layers.",
+      "version": "12.28.1"
     }
   ],
-  "version": "12.27.0"
+  "version": "12.28.1"
 }

package/.claude-plugin/plugin.json

@@ -1,13 +1,14 @@
 {
   "name": "wicked-garden",
-  "version": "12.27.0",
-  "description": "Your coding agent's harness already plans and swarms; Wicked Garden is the curated toolkit for what it can't do alone. Proof, not claims \u2014 gates re-derive 'done' through the internal loom engine (fail-closed, independently attested via wicked-vault), so a self-asserted pass can't lie its way green. Relationships grep can't see \u2014 codegraph + injected bus/dispatch/capability edges power blast-radius & lineage. Plus deterministic multi-file refactor (wicked-patch), cross-session memory (wicked-brain), real multi-model second opinions (jam:council), portable expertise as on-demand skill-refs, and evidence-gated testing (wicked-testing). It reads the shape of your work to apply the right rigor \u2014 steering, not a pipeline \u2014 then gets out of the way. The compiler stamps a self-contained evidence gate into any repo that runs with no wicked-garden installed. Don't fight the harness; fill its gaps. The evidence gate requires wicked-vault (installed automatically via wicked-testing); wicked-testing, wicked-brain, wicked-understanding, and wicked-bus are opt-in layers \u2014 install what you'll use, the toolkit works without the rest.",
-  "wicked_testing_version": "^0.7.0",
+  "version": "12.28.1",
+  "description": "Your coding agent's harness already plans and swarms; Wicked Garden is the curated toolkit for what it can't do alone. Proof, not claims \u2014 gates re-derive 'done' through the internal loom engine (fail-closed, independently attested via wicked-vault), so a self-asserted pass can't lie its way green. Relationships grep can't see \u2014 codegraph + injected bus/dispatch/capability edges power blast-radius & lineage. Plus deterministic multi-file refactor (wicked-patch), cross-session memory (wicked-brain), real multi-model second opinions (jam:council), portable expertise as on-demand skill-refs, and evidence-gated testing (wicked-testing). It reads the shape of your work to apply the right rigor \u2014 steering, not a pipeline \u2014 then gets out of the way. The compiler stamps a self-contained evidence gate into any repo that runs with no wicked-garden installed. Don't fight the harness; fill its gaps. The evidence gate requires wicked-vault (installed automatically via wicked-testing); wicked-testing, wicked-brain, and wicked-bus are opt-in layers \u2014 install what you'll use, the toolkit works without the rest.",
+  "wicked_testing_version": "^0.8.0",
   "wicked_vault_version": "^0.4.0",
-  "wicked_brain_version": "^0.15.0",
+  "wicked_brain_version": "^0.18.0",
   "wicked_bus_version": "^2.0.0",
   "author": {
-    "name": "Mike Parcewski"
+    "name": "Mike Parcewski",
+    "email": "mike.parcewski@gmail.com"
   },
   "repository": "https://github.com/mikeparcewski/wicked-garden",
   "license": "MIT",
@@ -24,7 +25,7 @@
     "agentic"
   ],
   "_future_userConfig": {
-    "_comment": "Issue #335, #346: userConfig is not yet supported in plugin.json schema. When Claude Code adds userConfig support, move these fields out of _future_userConfig and into a top-level userConfig block. This would replace the manual /wicked-garden:setup flow.",
+    "_comment": "Issue #335, #346: userConfig is not yet supported in plugin.json schema. When Claude Code adds userConfig support, move these fields out of _future_userConfig and into a top-level userConfig block. This would replace the manual setup flow (the wicked-garden-core skill's setup action).",
     "storage_mode": {
       "type": "string",
       "default": "local",

package/.claude-plugin/specialist.json

@@ -1,6 +1,6 @@
 {
   "plugin": "wicked-garden",
-  "_comment": "Specialist roles listed here are user-facing disciplines surfaced by crew for phase routing. Internal infrastructure domains (crew, mem, persona, smaht, search, jam) are NOT listed as specialists — they are invoked directly via their commands, not routed through the specialist dispatch system.",
+  "_comment": "Specialist roles listed here are user-facing disciplines surfaced by crew for phase routing. Internal infrastructure domains (crew, mem, persona, smaht, search, jam) are NOT listed as specialists — they are invoked directly via their consolidated domain skills, not routed through the specialist dispatch system. Specialist roles resolve to context:fork worker skills (skills/<domain>-<role>/SKILL.md) via scripts/crew/specialist_resolver.py.",
   "specialists": [
     {
       "name": "engineering",

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [12.28.1] — 2026-07-12
+
+### Fixed
+- **Peer version floors unblocked (P0).** `wicked_testing_version` `^0.7.0`→`^0.8.0` and `wicked_brain_version` `^0.15.0`→`^0.18.0`. The testing floor is *enforced fail-closed* and its caret excluded the published wicked-testing 0.8.0, hard-blocking garden's produces-gate for anyone on testing 0.8.0.
+- Dropped the dead `npx wicked-vault-install` command from user docs (vault installs automatically via wicked-testing) and stale standalone references to absorbed/archived products (wicked-loom is now internal to garden; wicked-understanding is archived) from the plugin description + docs.
+
+## [12.28.0] — 2026-07-12
+
+### Changed
+- **Skills-only plugin.** The former `agents/` and `commands/` are now skills — 94 skills across 12 domains (34 `context: fork` workers). Former commands became actions of consolidated domain router skills; former agents became `context: fork` worker skills (with `subagent_type` back-compat aliases). The `agents/` directory is removed from the distributed plugin.
+- **jam-council `allowed-tools: ["*"]`** — council members get full garden-tool access for additional processing (the multi-model council is the router; `classify` remains the one-member-deep fast path).
+
 ## [12.27.0] — 2026-07-07
 
 ### Added

package/CONTRIBUTING.md

@@ -48,7 +48,7 @@ setup wizard output, or the README. It is not a supported production configurati
 
 **For offline CI and dev environments without the wicked-vault peer only.**
 
-wicked-vault (npm, ≥0.3, install `npx wicked-vault-install`) is a required peer
+wicked-vault (npm, ≥0.3, install `npx wicked-testing install`) is a required peer
 alongside wicked-loom/bus/brain/testing. The garden's produces-gates re-derive
 evidence through **wicked-loom** — `scripts/qe/vault_gate.py` shells `wicked-loom
 gate`, which in turn shells `wicked-vault cross-check`, so the vault is the backend

package/ETHOS.md

@@ -20,9 +20,9 @@
 
 **Knowledge compounds across sessions or it isn't knowledge.** If a decision, gotcha, or pattern lives only in the current chat, it dies with the chat. Every memorable thing belongs in a tier-appropriate memory store with confidence and decay rules. wicked-brain is the difference between learning once and learning every time.
 
-**Native primitives over bespoke abstractions.** Claude Code's `TaskCreate`, `Skill`, `Agent`, hooks, and slash commands are the surface. We extend them — we don't replace them. A task with metadata is more durable than a custom kanban; an agent with a frontmatter description is more discoverable than a registry call.
+**Native primitives over bespoke abstractions.** Claude Code's `TaskCreate`, `Skill`, `Agent`, and hooks are the surface. We extend them — we don't replace them. A task with metadata is more durable than a custom kanban; a skill with a frontmatter description is more discoverable than a registry call. The plugin is **skills-only**: user entry points are consolidated per-domain skills, and the former agents are fork-context worker skills — one surface, not three.
 
-**The gate is required; the rest is a toolkit.** wicked-garden's one non-negotiable is the evidence gate, so it stands on two required peers: **wicked-vault** (the backend that makes "done" re-derivable) and **wicked-loom** (the engine that re-runs the verifier). `/wicked-garden:setup` blocks without them — a gate you can fake is worse than no gate. The other siblings are **opt-in layers**, not prerequisites: **wicked-testing** (acceptance testing), **wicked-brain** (cross-session memory — the *what*), **wicked-understanding** (repo playbooks — the *how*), **wicked-bus** (the audit trail). Install the ones you'll use; the toolkit works without the others — breadth you adopt incrementally, not a five-thing prerequisite wall. And required-at-install is not brittle-at-runtime: a transient outage degrades gracefully and never bricks a session — but a gate never pretends missing evidence is a pass; that path **fails closed**. We depend on the gate; we don't crash with the layers.
+**The gate is required; the rest is a toolkit.** wicked-garden's one non-negotiable is the evidence gate, so it stands on two required peers: **wicked-vault** (the backend that makes "done" re-derivable) and **wicked-loom** (the engine that re-runs the verifier). The core skill's `setup` action (`/wicked-garden-core setup`) blocks without them — a gate you can fake is worse than no gate. The other siblings are **opt-in layers**, not prerequisites: **wicked-testing** (acceptance testing), **wicked-brain** (cross-session memory — the *what*), **wicked-understanding** (repo playbooks — the *how*), **wicked-bus** (the audit trail). Install the ones you'll use; the toolkit works without the others — breadth you adopt incrementally, not a five-thing prerequisite wall. And required-at-install is not brittle-at-runtime: a transient outage degrades gracefully and never bricks a session — but a gate never pretends missing evidence is a pass; that path **fails closed**. We depend on the gate; we don't crash with the layers.
 
 **Cross-platform is non-negotiable.** macOS, Linux, Windows (Git Bash, WSL, native). Bare `python3` doesn't exist on Windows; bare `/tmp` doesn't exist on Windows; the shim and `${TMPDIR:-/tmp}` exist for a reason. If a contributor adds shell that breaks on Windows, the contribution is incomplete.
 
@@ -50,7 +50,7 @@
 
 **Archetype-shaped rigor.** The detector classifies *work shape*, and rigor follows the shape — not a global dial that defaults to maximum. A `triage` is negligible; a `migrate` cutover is a hard gate with a rollback proof. The output is rigor that fits the work, applied where it matters.
 
-**Enforcement that travels.** `/wicked-garden:compile` emits a self-contained, vault-backed gate into any repo — one that re-derives the build's claims with **no wicked-garden runtime present**. We compile the *trigger* and the *enforcement*; we never compile the *tool*. The guarantee outlives the session that created it.
+**Enforcement that travels.** The prove skill's `compile` action (`/wicked-garden-prove compile`) emits a self-contained, vault-backed gate into any repo — one that re-derives the build's claims with **no wicked-garden runtime present**. We compile the *trigger* and the *enforcement*; we never compile the *tool*. The guarantee outlives the session that created it.
 
 **Append-only audit trails that survive context resets.** Decisions, gate verdicts, and evidence all land on disk in append-only form. A new session resumes work without losing the chain of reasoning. State that lives only in chat history is state that doesn't exist.
 
@@ -60,7 +60,7 @@
 
 ## What this is not
 
-**Not a prompt library.** Skills, agents, and commands are executable surfaces with frontmatter contracts and runtime enforcement — not text snippets to copy.
+**Not a prompt library.** Skills — the routing domain skills and the fork-context workers alike — are executable surfaces with frontmatter contracts and runtime enforcement, not text snippets to copy.
 
 **Not a fixed-sequence pipeline.** No two prompts run the same phase chain. Work shape is detected per prompt, not configured once per repo.
 

package/README.md

@@ -7,9 +7,9 @@
                                        |___/                             
 ```
 
-# Wicked Garden
+# wicked-garden
 
-**Your coding agent already plans and swarms. Wicked Garden is the curated toolkit for what it can't do alone.**
+**Your coding agent already plans and swarms. wicked-garden is the curated toolkit for what it can't do alone.**
 
 > 📖 Docs → [mikeparcewski.github.io/wicked-garden](https://mikeparcewski.github.io/wicked-garden/). Identity & beliefs → [`ETHOS.md`](ETHOS.md). How it works → [`CLAUDE.md`](.claude/CLAUDE.md).
 
@@ -21,18 +21,18 @@ Coding agents grew up. Claude Code, Codex, Cursor, Antigravity, Aider, OpenCode,
 
 Most plugins try to boss them around — re-implement planning, impose a workflow, make the agent dance. You end up fighting your own tools.
 
-**Wicked Garden refuses to wrestle the harness.** It assumes your agent is good at the things it's good at, and fills the gaps it *can't* fill on its own.
+**wicked-garden refuses to wrestle the harness.** It assumes your agent is good at the things it's good at, and fills the gaps it *can't* fill on its own.
 
 ## The gaps it fills
 
-| Your harness… | Wicked Garden… |
+| Your harness… | wicked-garden… |
 |---|---|
 | says *"tests pass"* (sometimes it's lying) | re-runs the proof. False "done" → **rejected.** Missing backend → **fails closed.** Never a vacuous green. |
 | greps and reads — blind to string-wired links | sees the **injected edges** (event→consumer, command→agent, agent→capability) grep never will → `blast-radius`, `lineage` |
 | refactors on a hope and a prayer | renames across files as a **graph operation**, not find-replace roulette → wicked-patch |
 | forgets everything at `exit` | remembers what session 1 decided when you're in session 47 → wicked-brain |
 | re-derives *how to work in this repo* every task — which file owns the bug, the wiring step, the test command | loads the repo's own playbooks (`fix-bug`/`add-feature`/`verify`…), generated from HEAD → wicked-understanding |
-| asks *itself* for a second opinion | convenes a **real multi-model panel** (Gemini / Codex / …) → `jam:council` |
+| asks *itself* for a second opinion | convenes a **real multi-model panel** (Gemini / Codex / …) → the jam skill's `council` action |
 | re-derives WCAG/CWE/SOC2 from memory every time | loads the rubric on demand, ships it to any repo |
 | grades its own homework | author ≠ executor ≠ reviewer → evidence-gated testing |
 
@@ -40,13 +40,13 @@ The throughline: **done is re-derived, not asserted.** Verdicts you can trust on
 
 ## What it's *not*
 
-- **Not a workflow it forces on you.** Your harness still drives. Wicked Garden reads the *shape* of the work, applies the right amount of rigor, and steps back.
+- **Not a workflow it forces on you.** Your harness still drives. wicked-garden reads the *shape* of the work, applies the right amount of rigor, and steps back.
 - **Not a reinvention** of the planning and swarm your agent already nails.
-- **Not Claude-only under the hood.** Ships as a Claude Code plugin, but the engine is CLI/npm peers — and the gate **compiles into any repo and runs with no wicked-garden installed** (`/wicked-garden:compile`). Stand on the harness, fill its gaps, hand off. Never absorb.
+- **Not Claude-only under the hood.** Ships as a Claude Code plugin, but the engine is CLI/npm peers — and the gate **compiles into any repo and runs with no wicked-garden installed** (`/wicked-garden-prove compile`). Stand on the harness, fill its gaps, hand off. Never absorb.
 
 <details><summary><b>How it stays out of the way: work-shape, not pipeline</b></summary>
 
-No universal pipeline to obey. A hook reads each prompt's *shape* and that decides one thing: **how much rigor this work earns.** A typo (`triage`) gets none; a migration cutover (`migrate`) gets a hard, independently-attested gate with a rollback proof. Nine shapes — `triage · explore · specify · decide · build · review · ship · incident · migrate` — steering, not blocking. Why shapes and not one pipeline → [`docs/v11/archetypes.md`](docs/v11/archetypes.md).
+No universal pipeline to obey. A hook reads each prompt's *shape* and that decides one thing: **how much rigor this work earns.** A typo (`triage`) gets none; a migration cutover (`migrate`) gets a hard, independently-attested gate with a rollback proof. Ten shapes — `triage · explore · specify · decide · build · review · ship · incident · migrate · modernize` — steering, not blocking. Why shapes and not one pipeline → [`docs/v11/archetypes.md`](docs/v11/archetypes.md).
 </details>
 
 ---
@@ -55,22 +55,22 @@ No universal pipeline to obey. A hook reads each prompt's *shape* and that decid
 
 ```bash
 /plugin install wicked-garden      # in Claude Code
-/wicked-garden:setup               # verifies peers; blocks only on the two the gate needs
+/wicked-garden-core setup          # verifies peers; blocks only on the one the gate needs
 ```
 
-**Two required, three opt-in.** The evidence gate is the floor we won't fake, so it needs two peers — setup blocks without them:
+**One required peer, the rest opt-in.** The evidence gate is the floor we won't fake, so it needs one external peer — setup blocks without it:
 
 ```bash
-npx wicked-vault-install       # the honest-evidence backend the gate re-derives against (≥ 0.3)
-npm i -g wicked-loom           # the gate engine that re-runs the verifier (or via npx)
+npx wicked-testing install     # installs wicked-vault (≥ 0.4.0), the honest-evidence backend the gate re-derives against
 ```
 
+> The gate/resolve engine (formerly the separate `wicked-loom` package) is now **absorbed in-package** as of v12.27.0 (`scripts/loom/`) — nothing extra to install. The gate re-hashes recorded evidence and re-runs its verifier through that engine; a false "tests pass" is **rejected**, a missing backend **fails closed**.
+
 The rest of the kit is **opt-in layers** — add what you want, skip the rest and the toolkit still works:
 
 ```bash
 npx wicked-testing install     # the acceptance-testing layer (author ≠ executor ≠ reviewer)
 /plugin install wicked-brain   # the memory layer — cross-session recall + cited search (the "what")
-npx skills add mikeparcewski/wicked-understanding --all   # the repo-playbooks layer — "how to work in THIS repo" (the "how"; pairs with brain)
 /plugin install wicked-bus     # the audit-trail layer (fire-and-forget; fail-open without it)
 ```
 
@@ -82,14 +82,14 @@ Optional, lights up the code graph: `npx @colbymchenry/codegraph` (Node ≥ 22.5
 # Just work — the hook applies the right rigor underneath, quietly
 "implement caching for the dashboard"
 
-# Or reach for a gap-filler on purpose
-/wicked-garden:prove                              # re-derive "done" from evidence (fail-closed)
-/wicked-garden:search:blast-radius emit_event     # impact, incl. edges grep can't see
-/wicked-garden:engineering:rename oldField newField   # deterministic, graph-driven
-/wicked-garden:jam:council "redis or memcached?"  # a panel that isn't just you
+# Or reach for a gap-filler on purpose — everything is a skill now
+/wicked-garden-prove                              # re-derive "done" from evidence (fail-closed)
+/wicked-garden-search blast-radius emit_event     # impact, incl. edges grep can't see
+/wicked-garden-engineering-patch rename oldField newField  # deterministic, graph-driven
+/wicked-garden-jam council "redis or memcached?"  # a panel that isn't just you
 
 # Stamp the evidence gate into ANY repo (runs with no wicked-garden installed)
-/wicked-garden:compile ~/path/to/repo --trigger ci
+/wicked-garden-prove compile ~/path/to/repo --trigger ci
 ```
 
 ---
@@ -108,7 +108,7 @@ Optional, lights up the code graph: `npx @colbymchenry/codegraph` (Node ≥ 22.5
 
 ## Requirements
 
-A coding-agent harness ([Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) ≥ 1.0 for the plugin surface; the peers + compiled gate are harness-agnostic) · Python 3.9+ (stdlib-only hooks) · Node + `npx` · the gate's two required peers (`wicked-vault` + `wicked-loom`) plus opt-in layers (`wicked-testing` · `wicked-brain` · `wicked-bus`).
+A coding-agent harness ([Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) ≥ 1.0 for the plugin surface; the peers + compiled gate are harness-agnostic) · Python 3.9+ (stdlib-only hooks) · Node + `npx` · the gate's one required peer (`wicked-vault` ≥ 0.4.0) plus opt-in layers (`wicked-testing` · `wicked-brain` · `wicked-bus`).
 
 ## License
 

package/docs/README.md

@@ -10,23 +10,23 @@ Work in wicked-garden is organized around **9 work-shape archetypes** — not a
 |-------|-------------|
 | [Getting Started](getting-started.md) | Installation, required peers, first session, common workflows |
 | [Archetypes](v11/archetypes.md) | The 9 work-shape archetypes — why the universal pipeline went away |
-| [Domains](domains.md) | The 10 domain skill/agent families archetypes invoke for expertise |
+| [Domains](domains.md) | The 10 domain skills archetypes invoke for expertise |
 | [Required Peers](required-peers.md) | The five required peer plugins and the install/runtime stance |
-| [The Compiler](compiler.md) | `/wicked-garden:compile` — emit a self-contained vault-backed gate into any repo |
+| [The Compiler](compiler.md) | `/wicked-garden-prove compile` — emit a self-contained vault-backed gate into any repo |
 | [Brain Chunk Format](brain-chunk-format.md) | How wicked-garden content is chunked for the brain index |
 
 ## Quick Links
 
 - **New to wicked-garden?** Start with [Getting Started](getting-started.md).
 - **Want to understand how work is shaped?** Read [Archetypes](v11/archetypes.md).
-- **Setting up?** The [Required Peers](required-peers.md) — wicked-testing, wicked-vault, wicked-brain, wicked-bus, wicked-loom — are verified by `/wicked-garden:setup`.
-- **Looking for domain expertise or a specific command?** Browse [Domains](domains.md).
+- **Setting up?** The [Required Peers](required-peers.md) — wicked-testing, wicked-vault, wicked-brain, wicked-bus, wicked-loom — are verified by `/wicked-garden-core setup`.
+- **Looking for domain expertise or a specific action?** Browse [Domains](domains.md).
 - **Want a build gate that runs without wicked-garden present?** See [The Compiler](compiler.md).
 
 ## Need Help?
 
 ```bash
-/wicked-garden:setup                   # verify required peers + onboard
-/wicked-garden:help                    # list all commands
-/wicked-garden:where-am-i              # show current session state
+/wicked-garden-core setup              # verify required peers + onboard
+/wicked-garden-core help               # list all skills
+/wicked-garden-core where-am-i         # show current session state
 ```

package/docs/compiler.md

@@ -1,8 +1,9 @@
 # The Compiler
 
-`/wicked-garden:compile` takes any repo and emits a **self-contained,
-vault-backed build gate** into `<repo>/.wicked/` — a gate that proves the
-build's claims and runs with **no wicked-garden runtime present**.
+The prove skill's `compile` action (`/wicked-garden-prove compile`) takes any
+repo and emits a **self-contained, vault-backed build gate** into
+`<repo>/.wicked/` — a gate that proves the build's claims and runs with **no
+wicked-garden runtime present**.
 
 The compiler is in `scripts/compiler/compile.py`. The detection pass is
 `scripts/compiler/phase0/detect.py`.
@@ -77,11 +78,11 @@ Pass `--trigger hook,ci` (or `all`) to install them.
 
 ```bash
 # Detect + emit the harness into the repo's .wicked/
-/wicked-garden:compile ~/path/to/repo
+/wicked-garden-prove compile ~/path/to/repo
 
 # Also install the triggers that fire the gate
-/wicked-garden:compile ~/path/to/repo --trigger hook,ci
-/wicked-garden:compile ~/path/to/repo --trigger all
+/wicked-garden-prove compile ~/path/to/repo --trigger hook,ci
+/wicked-garden-prove compile ~/path/to/repo --trigger all
 
 # Run the emitted gate (exit 0 = PASS)
 python3 .wicked/gate.py