wicked-garden 12.27.0

package/commands/smaht/briefing.md

@@ -0,0 +1,200 @@
+---
+description: |
+  Use when starting a new session and you want to know what happened since the last one — recent events,
+  active crew projects, and memory updates. NOT for live session state inspection (use smaht:state).
+argument-hint: "[--days N] [--project name]"
+phase_relevance: ["*"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:smaht:briefing
+
+Generate a "what happened since last session" briefing. Primary source: unified event log. Fallback: individual domain queries.
+
+## Instructions
+
+### 0. Post-Compaction Recovery
+
+If this briefing is requested after a context compaction event, check for WIP state first and present it prominently at the top of the briefing:
+
+1. Check for WIP snapshot file at the session's history condenser directory (`wip_snapshot.json`)
+2. If no snapshot, query `HistoryCondenser(session_id).get_session_state()` for live working state
+3. Read native tasks for in-progress items: list task JSON under `${CLAUDE_CONFIG_DIR}/tasks/{session_id}/` and filter by `status == "in_progress"`.
+4. Present recovered WIP state at the top of the briefing output:
+   - **Current task**: what the user was working on
+   - **Recent decisions**: choices already made (do NOT re-ask)
+   - **Active files**: files in scope for the current work
+   - **Open questions**: unresolved items that still need answers
+   - **In-progress tasks**: native tasks currently being worked (filter `metadata.event_type=="task"` for human-visible items)
+5. Add: "Context was compacted. Review this state before proceeding. Do NOT repeat completed work."
+
+If no compaction occurred (normal briefing request), skip this step entirely.
+
+### 1. Determine Time Window
+
+Default: last 24 hours. Override with `--days N`. If `--project` specified, filter to that project.
+
+### 2. Query the Event Log (primary)
+
+Single query replaces 4 separate domain calls:
+
+```bash
+sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" "${CLAUDE_PLUGIN_ROOT}/scripts/_run.py" scripts/_event_store.py query \
+  --since "${days:-1}d" \
+  ${project:+--project "$project"} \
+  --limit 100 \
+  --json
+```
+
+This returns events from ALL domains in one timeline — mem decisions, crew phase transitions, native task changes, jam outcomes.
+
+### 2b. Fallback (if event log is empty or unavailable)
+
+If the event log returns no results (new install, events.db not yet populated), fall back to individual queries:
+
+**Memory:** `wicked-brain:memory "recent decisions and learnings" --limit 10`
+
+**Native tasks:** read task JSON under `${CLAUDE_CONFIG_DIR}/tasks/{session_id}/` and summarize counts by `status` and `metadata.event_type`.
+
+**Crew:** in v11, look up archetype-mode projects explicitly via
+`phase_manager <name> status --json`. The v6-era find-active auto-resolver
+was deleted with the universal pipeline.
+
+### 2c. Git Activity (always supplement)
+
+Git history is not in the event log — always query directly:
+
+```bash
+git log --oneline --since="${days:-1} days ago" --no-merges 2>/dev/null | head -15
+```
+
+### 2d. Repo method — wicked-understanding (advisory, fail-open)
+
+Surface whether this repo's **how-to-work-here playbooks** exist (the opt-in
+wicked-understanding layer — the *how*, complementing brain's *what*). Prints
+nothing if absent or unavailable:
+
+```bash
+sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" - <<'PY' 2>/dev/null || true
+import os
+from pathlib import Path
+roots = [Path.home()/".claude"/"skills"]
+cfg = os.environ.get("CLAUDE_CONFIG_DIR")
+if cfg: roots.append(Path(cfg)/"skills")
+names = set()
+for r in roots:
+    try:
+        if r.exists():
+            names |= {e.name for e in r.iterdir()
+                      if e.is_dir() and e.name.startswith(("repo-", "fix-bug", "add-feature"))}
+    except OSError:
+        pass
+if names:
+    print("Repo playbooks available (wicked-understanding): " + ", ".join(sorted(names)[:8]))
+PY
+```
+
+If present, add a **Repo method:** line to the briefing and tell the agent to load
+the matching playbook for build / fix / migrate work instead of rediscovering the
+method. If absent, you may note that `npx skills add mikeparcewski/wicked-understanding --all`
+would generate them.
+
+### 3. Categorize Events
+
+Group events from the timeline by type:
+
+| Event action pattern | Briefing section |
+|---------------------|-----------------|
+| `memories.created`, `memories.updated` | Recent Decisions |
+| `projects.created`, `phases.*` | Active Work (crew) |
+| `tasks.created`, `tasks.updated` | Active Work (tasks) |
+| `sessions.created`, `*.migrated` | Brainstorm Outcomes |
+| Everything else | Other Activity |
+
+### 4. Synthesize Briefing
+
+Before composing the briefing, name the **detected stack** back to the user
+so it is obvious wicked-garden has read the project shape (#723 — stack
+identity is a projection of the repo, never a hand-edited preset).
+
+**Project scope:** if `--project` was supplied, scan `${PWD}` (the project
+source-dir lookup was a v6 helper tied to `crew.py::list_projects`,
+deleted in v11). The fallback when `--project` is absent is also
+`${PWD}`. Briefings now always read from cwd.
+
+_Stack signal extraction was removed in v11; the v6 helpers were
+target-kind classifiers tied to the old gate-policy. v11 work-shape
+archetypes are emitted by the prompt-submit hook, not derived from
+filesystem traversal. Skip this section in v11 briefings._
+
+If `language` is not `unknown`, include this single line at the top of the
+briefing (omit entirely when language is `unknown`):
+
+```
+Detected stack: {language} ({package_manager}, frameworks: {frameworks}). Archetype: {archetype}.
+```
+
+In JSON-mode briefings, surface the same projection under a top-level
+`detected_stack` field; do not invent a parallel state file.
+
+**Affected repos (#722, advisory):** when the active project (or the one
+named via `--project`) carries an optional `affected_repos` list in its
+`process-plan.json`, surface it as a single advisory line directly under
+the `Detected stack:` line. The helper script below is fail-open: it
+prints NOTHING when the field is missing, empty, or malformed, so this
+block stays silent on every legacy project. The full DAG / worktrees /
+cross-repo evidence workflow lives in the `wicked-garden-monorepo`
+sibling plugin (see `docs/v9/sibling-plugin-monorepo.md`).
+
+_The `affected_repos` helper was removed in v11. Multi-repo coordination
+was tied to the v6 universal pipeline's process-plan.json schema, which
+the v11 archetype catalog superseded. Future cross-repo orchestration
+work belongs in the `wicked-garden-monorepo` sibling plugin._
+
+Format (when non-empty):
+
+```
+Affected repos: foo, bar (advisory — see docs/v9/sibling-plugin-monorepo.md)
+```
+
+```markdown
+## Session Briefing ({days}d window)
+
+Detected stack: python (uv, frameworks: click). Archetype: code-repo.
+
+### Recent Decisions
+{events from mem domain — decisions stored, patterns learned}
+- "Chose JWT over sessions" (2 days ago)
+- "Rate limiting goes after gateway" (yesterday)
+
+### Active Work
+**Crew**: {project name} — phase: {current}, next: {next step}
+**Tasks**: {N in progress}, {M completed since last session}
+
+### Brainstorm Outcomes
+{jam session decisions made in the window}
+
+### Code Changes
+{git commits grouped by area}
+
+### Suggested Next Steps
+{based on the event timeline:}
+- Continue: {most recent active crew phase}
+- Review: {files changed since last session}
+- Decide: {any open questions from jam sessions}
+```
+
+### 5. Contextual Discovery
+
+Suggest ONE related command based on the briefing content:
+
+- If active crew project → suggest `crew:execute` or `crew:status`
+- If recent mem decisions but no crew project → suggest `crew:start`
+- If code changes but no review → suggest `engineering:review`
+- If brainstorm outcomes with no follow-up → suggest `jam:revisit`
+
+Keep it to ONE suggestion. Frame as: "You might find X useful because..."
+
+### When context is thin
+
+If the briefing doesn't give you enough to orient — no active project, sparse events, or missing decisions — invoke `wicked-garden:ground` to pull richer brain + bus context before proceeding.

package/commands/smaht/events-import.md

@@ -0,0 +1,95 @@
+---
+description: "Import existing domain JSON records into the unified event log"
+argument-hint: "[--domain D] [--dry-run]"
+phase_relevance: ["*"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:smaht:events-import
+
+Import existing DomainStore JSON records into the unified event log as historical events.
+
+## Instructions
+
+### 1. Discover Existing Records
+
+Scan the DomainStore local root for all domain directories:
+
+```bash
+sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" -c "
+from _domain_store import _LOCAL_ROOT
+from pathlib import Path
+import json
+
+root = Path(_LOCAL_ROOT) if isinstance(_LOCAL_ROOT, str) else _LOCAL_ROOT
+domains = sorted(d.name for d in root.iterdir() if d.is_dir()) if root.exists() else []
+print(json.dumps(domains))
+"
+```
+
+### 2. For Each Domain
+
+Read all JSON files and synthesize events with `action: "{source}.migrated"`:
+
+```python
+from _event_store import EventStore
+from _domain_store import _LOCAL_ROOT
+from pathlib import Path
+import json
+
+EventStore.ensure_schema()
+
+domain_dir = Path(_LOCAL_ROOT) / domain_name
+imported = 0
+skipped = 0
+
+for source_dir in domain_dir.iterdir():
+    if not source_dir.is_dir():
+        continue
+    source = source_dir.name
+    for json_file in source_dir.glob("*.json"):
+        record = json.loads(json_file.read_text())
+        record_id = record.get("id", json_file.stem)
+
+        # Idempotent: skip if already imported
+        existing = EventStore.query(
+            domain=domain_name,
+            action=f"{source}.migrated",
+            limit=1,
+        )
+        # Check by record_id to avoid duplicates
+        if any(e.get("record_id") == record_id for e in existing):
+            skipped += 1
+            continue
+
+        EventStore.append(
+            domain=domain_name,
+            action=f"{source}.migrated",
+            source=source,
+            record_id=record_id,
+            payload=record,
+            tags=["migrated"],
+        )
+        imported += 1
+```
+
+### 3. Report Results
+
+```markdown
+## Import Complete
+
+| Domain | Imported | Skipped (already exists) |
+|--------|----------|--------------------------|
+| crew | 45 | 0 |
+| mem | 23 | 0 |
+| jam | 12 | 0 |
+| **Total** | **80** | **0** |
+
+Events are tagged with `migrated` for easy filtering.
+Query with: `/wicked-garden:crew:activity --fts migrated`
+```
+
+### Flags
+
+- `--domain D`: Import only one domain (default: all)
+- `--dry-run`: Show what would be imported without writing

package/commands/smaht/state.md

@@ -0,0 +1,19 @@
+---
+description: |
+  Use when you need to inspect live SessionState, adapter outputs, or smaht directive settings.
+  NOT for what-happened-since-last-session (use smaht:briefing).
+argument-hint: "[--state] [--events N] [--project <name>] [--json]"
+phase_relevance: ["*"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:smaht:state
+
+Snapshot and report current session state and recent events.
+
+## Run it inline (no dispatch)
+
+1. `Read("${CLAUDE_PLUGIN_ROOT}/skills/smaht/refs/state.md")` — the rubric:
+   SessionState script, display format, wicked-bus events tail, and v11
+   project context lookup (when `--project <name>` is given).
+2. Apply the rubric directly using `$ARGUMENTS`.

package/commands/where-am-i.md

@@ -0,0 +1,58 @@
+---
+allowed-tools: ["Bash"]
+description: "Emit a compact path manifest (plugin, source, project, brain, bus) for the current session"
+argument-hint: "[--fence] [--env]"
+phase_relevance: ["*"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:where-am-i
+
+Read-only query that prints a single compact manifest of the five storage
+roots used by wicked-garden dispatches. Subagents should include
+"run /wicked-garden:where-am-i first" as a directive instead of
+hand-enumerating paths — it costs fewer tokens and closes a class of
+path-mismatch bugs.
+
+Provenance: Issue #576.
+
+## Arguments
+
+- `--json` — Emit JSON manifest (default).
+- `--fence` — Wrap the JSON manifest in a ```json fence for paste.
+- `--env` — Substitute env-var forms (e.g. `$CLAUDE_PLUGIN_ROOT`) where
+  the corresponding environment variable is present.
+
+## Output shape
+
+```json
+{
+  "plugin_root": "/abs/path",
+  "source_cwd": "/abs/path",
+  "active_project_id": "string-or-null",
+  "project_artifacts": "/abs/path/to/projects-or-specific-project",
+  "brain": {"path": "/abs/path", "port": 4243},
+  "bus_db": "/abs/path"
+}
+```
+
+Any field that cannot be resolved emits `null` and logs a one-line note
+to stderr. The command never raises and is safe to invoke from any cwd.
+
+## Instructions
+
+Invoke the helper script and stream its stdout to the user verbatim.
+This command is a thin wrapper — do not re-interpret the manifest.
+
+```bash
+sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" "${CLAUDE_PLUGIN_ROOT}/scripts/where_am_i.py" "$@"
+```
+
+## Graceful Degradation
+
+- Missing `CLAUDE_PLUGIN_ROOT`: falls back to the checkout inferred from
+  the script location.
+- Missing brain config: emits `"brain": null` and continues.
+- Missing bus DB: emits `"bus_db": null` and continues.
+- No active crew project: emits `"active_project_id": null` and points
+  `project_artifacts` at the crew projects domain root.

package/docs/README.md

@@ -0,0 +1,32 @@
+# Wicked Garden Documentation
+
+Detailed guides for getting the most out of wicked-garden.
+
+Work in wicked-garden is organized around **9 work-shape archetypes** — not a fixed pipeline. Each prompt classifies into one or more archetypes (triage, explore, specify, decide, ship, review, incident, build, migrate); each owns its own phase shape, produces contract, and HITL discipline.
+
+## Guides
+
+| Guide | Description |
+|-------|-------------|
+| [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 |
+| [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 |
+| [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).
+- **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
+```

package/docs/adr/0001-code-relationship-graph-engine.md

@@ -0,0 +1,116 @@
+# ADR 0001 — Code-relationship graph: adopt codegraph as the engine, add injected-edge extractors
+
+- **Status:** Superseded by [ADR 0004](0004-code-graph-moves-to-wicked-brain.md) (2026-06-10) — the engine choice (codegraph) + injected-edge concept stand, but the graph's **home moved to wicked-brain** (garden no longer hosts the shim/extractors). Originally: Accepted (prototype validated).
+- **Date:** 2026-06-09
+- **Context owners:** wicked-garden
+
+## Context
+
+Three features need a real code-relationship graph, and none works today:
+
+- **`search:blast-radius`** — "what breaks if I change X" — currently runs a brain
+  search (hardcoded to the wrong port, 4242; the brain is on 4243) + `grep`. It is
+  effectively grep-with-extra-steps.
+- **`search:lineage`** — data flow — same shape.
+- **wicked-patch** (`engineering:rename`/`add-field`/`remove`) — deterministic
+  multi-file refactor — requires a symbol `--db` that **nothing in the ecosystem
+  produces**, so the whole family is dead-on-arrival.
+
+The decisive requirement is **injected relationships**: this plugin's load-bearing
+edges are wired by a shared *string* through a registry, never by a literal symbol
+reference, so neither `grep` nor a static call-graph can see them:
+
+| Injected edge (grep-/static-invisible) | Wired by (deterministically extractable) |
+|---|---|
+| event producer → consumer | `emit_event("wicked.x")` + `_bus_consumers.json` `event_filter` |
+| command/Task → agent | `subagent_type:` frontmatter |
+| agent → tool | `tool-capabilities` + `_capability_registry` |
+| hook event → script | `hooks.json` |
+| archetype → playbook/gate | `archetypes.json` + `refs/` |
+
+## Decision
+
+**Adopt [codegraph](https://github.com/colbymchenry/codegraph) (`@colbymchenry/codegraph`, MIT,
+TypeScript/web-tree-sitter) as the static code-graph engine, consumed as a
+runtime-resolved peer** (the same model as wicked-loom/vault/testing/bus), and
+**add wicked-garden-specific injected-edge extractors on top.** Do not build a
+graph engine from scratch — re-implementing multi-language tree-sitter resolution
+to codegraph's fidelity is months of work it already does.
+
+### Why codegraph (vs roam-code, vs build)
+Both codegraph and [roam-code](https://github.com/Cranot/roam-code) (Apache-2.0,
+Python) are credible "adopt-as-engine" candidates. codegraph wins for us on two
+decisive axes:
+
+1. **Architecture fit** — it ships a CLI + MCP server + a plain SQLite contract and
+   is npm/node, exactly how we already consume our peers (a `_codegraph.py` shim
+   mirrors `_loom.py`). roam-code is a Python library — a different integration shape.
+2. **Patch precision** — codegraph is **column-precise** (`file:line:col` on nodes
+   *and* reference sites) with real import/alias/workspace/re-export/JVM-FQN
+   resolution and confidence/provenance per edge. roam-code is line-granular +
+   heuristic name resolution (false-positive risk) — riskier to refactor against.
+
+**Borrow, don't adopt, from roam-code:** its Code-Graph Attestation (re-derive
+Merkle/edge digests from the live DB, fail-closed) is a genuine twin of our vault
+gate, operating on a layer the vault doesn't cover; and its `oracle_*` deterministic
+fact tools are clean gate inputs. We keep it at arm's length because it is a
+*competing change-governance framework* (constitution/permits/leases) that overlaps
+wicked-garden's entire premise — we want a code-graph *component*, not to outsource
+our governance.
+
+## Validation (prototype, this ADR)
+
+Run on this repo, Node 26:
+
+- `codegraph index` → **4,179 nodes / 7,733 edges** across 196 Python files in ~1s;
+  plain SQLite at `.codegraph/codegraph.db` (auto-gitignored). `codegraph impact <symbol>`
+  (blast-radius) and `query`/`callers` work out of the box.
+- `scripts/codegraph/inject_edges.py` (the first injected-edge extractor) reads
+  `_bus_consumers.json` + emit sites and materializes producer→consumer edges:
+  `file:scripts/_bus.py --[wicked.persona.contributed]--> file:scripts/jam/_bus_consumers.py`.
+  codegraph's static graph had **0** such edges; `grep` finds **no** link between
+  producer and consumer (they share only the event string). Blast-radius now
+  traverses them.
+- Bonus finding: a consumer in `_bus_consumers.json` (`crew:auto-advance`) points at
+  `scripts/crew/_bus_consumers.py`, which **does not exist** — a stale registry entry
+  the graph build surfaced.
+
+## Architecture
+
+```
+codegraph (static: symbols + imports/calls/refs, column-precise, SQLite)
+        +  injected-edge extractors (deterministic, per wiring mechanism)
+             bus emit↔_bus_consumers.json   [prototype: scripts/codegraph/inject_edges.py]
+             command→agent (subagent_type)  [next]
+             agent→tool (capabilities)       [next]
+        +  data-flow lineage layer           [build: neither engine provides general lineage]
+        =  the relationship graph
+        →  consumers: blast-radius, lineage, wicked-patch (--db)
+```
+
+- **Peer shim** `scripts/_codegraph.py` — resolves + runs the codegraph CLI/MCP
+  exactly like `_loom.py` does for loom (env `WICKED_CODEGRAPH_BIN` → config → PATH →
+  npx). Pin Node ≥ 22.5 (codegraph uses `node:sqlite`); we run 26.
+- **Injected edges** carry their semantics in the edge `metadata` (codegraph's
+  node/edge `kind` are closed unions; `references` + `provenance='injected:<mechanism>'`
+  is the no-fork convention). Coverage caveat: if a wired file isn't a codegraph
+  node, the extractor skips it (and that itself flags stale wiring, as above).
+
+## Consequences
+
+- blast-radius/lineage flip from **redundant** (grep+broken) → **genuinely
+  differentiated** (they answer injected-relationship questions grep cannot).
+- wicked-patch flips from **broken** (no `--db`) → **working** (consumes the
+  codegraph SQLite as its symbol DB).
+- **Risk:** codegraph bus-factor = 1. Mitigated by MIT license + the SQLite schema
+  being a stable, self-describing contract we can read even if upstream stalls.
+- **Lock-in:** low — we depend on a documented SQLite shape, not an opaque service.
+
+## Roadmap
+
+1. ✅ Prototype: peer shim + bus injected-edge extractor + blast-radius proof (this ADR).
+2. command→agent and agent→tool extractors (same pattern as the bus extractor).
+3. Rewire `search:blast-radius`/`lineage` to query the graph (and fix the 4242→4243 port).
+4. Wire wicked-patch to consume the codegraph SQLite as its `--db` (revives the patch family).
+5. Build the data-flow lineage layer on top.
+6. Evaluate borrowing roam-code's Code-Graph Attestation as a complement to the vault gate.

package/docs/adr/0002-major-cleanup-keep-cut.md

@@ -0,0 +1,91 @@
+# ADR 0002 — Major cleanup: collapse rubric-wrappers to skills; keep only what the agent actually uses
+
+- **Status:** Accepted — **fully executed**. All domains collapsed (product #910; engineering #911; platform #912; data+delivery #913; agentic+jam+persona+smaht #914), orphan agents purged via `scripts/ci/find_orphan_agents.py`, and `components.json` re-derived via `scripts/ci/sync_components.py`. End state: 90 commands, 40 agents (from 56), 71 skills.
+- **Date:** 2026-06-09
+
+## The test
+
+The customer is the AI coding agent (and, downstream, the human reading its output and *other-repo* agents that load these skills). A feature **earns its current shape only if it does at least one of:**
+1. **makes the agent's life easier** (a capability/ergonomic the agent lacks natively), or
+2. **greatly reduces tokens** (vs. the agent's native Read/Grep/Bash/subagent path), or
+3. **improves the quality of the final output** (catches errors, enforces evidence, adds a perspective the agent can't produce alone).
+
+Most "commands" in the garden are a checklist the agent already applies, wrapped in a `Task(subagent)` hop that costs *more* tokens and latency for the *same* output. The hop fails all three — but **the rubric inside it usually doesn't.** The knowledge is the asset; the dispatch is the tax.
+
+So the default disposition is **COLLAPSE-TO-SKILL, not DELETE.** The rubric/knowledge moves to an on-demand `skills/*/refs/<name>.md` file (progressive disclosure → near-zero idle context cost — it loads only when the command runs), and the command becomes a **slim body that loads the ref and does the work INLINE** (a `Read` of the ref, then apply directly — no `Task`/subagent dispatch).
+
+This is grounded in a full hands-on pass: every domain was invoked and judged against native tools.
+
+## Dispositions
+
+- **COLLAPSE (default)** — rubric → `skills/*/refs/`; command → slim inline body, no dispatch. The functionality survives; only the hop is removed.
+- **KEEP DISPATCH** — only where dispatch genuinely earns it: **real parallelism** (3-4 lenses running at once), **context isolation** for a huge payload, a **real external tool**, or an **independent gate** (an evaluator that must not be the agent that did the work).
+- **DELETE** — only the truly-dead: already-removed `crew:archive` / `delivery:process-health`, plus `smaht:propose-skills`, the dead half of `smaht:state`, and `persona:submit`. These have no rubric worth rescuing.
+
+## KEEP (earns its place)
+
+| Feature | Why (criterion) |
+|---|---|
+| `prove` + the produces-gate (vault/loom, outputs + attestation + semantic) | **output** — stops false "done"; no native equivalent |
+| `/compile` | **easier** — emits a self-contained gate into any repo |
+| code-graph (codegraph + injected-edge extractors) → `search:blast-radius`, `search:lineage` | **output + tokens** — finds injected relationships grep can't; impact in one query vs. reading many files |
+| wicked-patch (`rename`/`add-field`/`remove`/`apply`) — once wired to the graph DB | **easier + output** — deterministic multi-file refactor |
+| `jam:council` / multi-model | **output** — real external-model perspective the agent can't produce alone |
+| `jam:brainstorm` / `revisit` (the wicked-brain decision-memory loop) | **output** — longitudinal decision/outcome memory |
+| `smaht:briefing` | **tokens** — one event-store query replaces stitching git+memory+tasks |
+| `data:ontology` | **output** — real RDF-vocabulary engine (beats free-recall) |
+| `persona:as` (built-in personas) + `persona:list` | **output** — hand-authored constraints/memories measurably steer; cheap discovery |
+| `platform:security` (now drives real `gitleaks`/`semgrep`) | **output** — real SAST/secrets, not grep-guessing |
+| `platform:toolchain` | **tokens/easier** — fast deterministic CLI inventory |
+| wicked-testing integration (`acceptance`/`run`/`plan`/`review`) | **output** — evidence-gated testing backbone |
+| archetype **gate** + actionable steering (emits the `prove` one-liner) | **output** — turns the principle into a reflex |
+| Core plumbing: `setup`, `where-am-i`, `help`, `intent`, `reset`, `classify`, hooks | load-bearing |
+
+## COLLAPSE (default — fails the hop test, but the rubric is worth keeping)
+
+These are `Task(subagent)` rubric-wrappers: a checklist the agent already applies, behind a hop that costs more tokens for the same result. **The hop goes; the rubric becomes an on-demand `skills/*/refs/<name>.md`; the command runs it inline.** Roughly ~42 commands, plus the agents that exist *only* as their dispatch targets (those go; agents still referenced by a surviving command/skill stay).
+
+| Domain | Collapse | Note |
+|---|---|---|
+| product | ✅ **EXECUTED — all 12** (`a11y`,`ux`,`ux-review`,`elicit`,`strategy`,`mockup`,`screenshot`,`analyze`,`synthesize`,`listen`,`align`,`acceptance`) | The pattern. Each rubric is now `skills/product/refs/<name>.md`, loaded inline. **Kept dispatch** only for the genuine multi-lens cases: `ux-review --focus all` (4 lenses) and `strategy --focus all` (2 lenses). Removed the dispatch-only agents `ux-analyst`, `user-voice`, `mockup-generator`; kept the rest (still referenced). `acceptance --scenarios` wicked-testing tie-in preserved in the ref. |
+| engineering | `debug`, `plan`, `arch`, `review`, `docs` | `debug` duplicates `superpowers:systematic-debugging` (collapse to a pointer); rest collapse with R1–R6 preserved as a ref. |
+| platform | `compliance`, `audit`, `incident`, `health`, `traces`, `actions`, `gh`, `infra` | keep `security` + `toolchain`. Collapse the SOC2/HIPAA audit checklist into a ref. |
+| data | `analyze`, `data`, `pipeline`, `ml` | keep `ontology`. |
+| delivery | `experiment`, `report`, `rollout`, `setup` | document templates → refs; `process-health` already deleted. Domain effectively retired. |
+| agentic | `review`, `audit`, `design`, `frameworks` | scripts emit false signals (drop those); collapse the T&S 8-layer rubric into a ref. |
+| jam | `quick`, `perspectives` (single-model role-play); `thinking`/`transcript`/`persona` (retrieval utils) | keep `council`/`brainstorm`/`revisit`. |
+| persona | `define` | thin (define can't set the rich fields) — collapse. Keep `as`/`list`. |
+| smaht | `state` (half-dead — collapse the live half) | keep `briefing`; `events-import` is a one-time util (keep or archive). |
+
+## DELETE (truly-dead — no rubric to rescue)
+
+`crew:archive` + `delivery:process-health` (already removed), `smaht:propose-skills` (weak signal), the dead half of `smaht:state`, `persona:submit` (no-op stub). Nothing of value is lost.
+
+## What we lose
+
+**With collapse, functionality lost ≈ 0.** The rubric, checklist, and capability survive verbatim as a `refs/` file — still discoverable (it's in the skill tree), still loadable on demand, still valid on **other repos and other toolchains** (a ref is portable knowledge; a dispatch hop is not). What's removed is *only the token-burning dispatch hop* — the parent no longer pays subagent spin-up + round-trip for a checklist it can apply itself.
+
+The win is **dual-customer**:
+- **the AI agent** — fewer tokens, lower latency, the rubric inlined exactly when it's needed (progressive disclosure keeps idle context near zero);
+- **the human** — a smaller, legible surface; the rubric reads as documentation;
+- **other-repo agents** — `skills/*/refs/` ships as portable knowledge they can load without the garden's dispatch machinery.
+
+Only the genuinely-dead DELETE rows lose anything, and those had no rubric worth keeping.
+
+## Estimated impact
+
+- Commands: stay numerically similar (collapsed, not deleted) but each is **slim** — the parent-context cost per command drops to a few lines; the rubric body moves to on-demand `refs/`.
+- Agents: **down sharply** (~56 → ~20) — the dispatch-only targets go; the rubric-bearing ones survive as refs.
+- Net: idle parent-context shrinks (slim bodies); per-invocation tokens drop (no hop); **zero capability lost**. The surface finally matches the "thin, high-value toolkit" the agent actually reaches for.
+
+## Phased execution (each phase = one worktree PR, parallelizable, suite-gated)
+
+0. ✅ Remove dead commands (`crew:archive`, `delivery:process-health`).
+1. ✅ **product** domain collapse (#910) — the executed pattern the rest followed.
+2. ✅ **engineering** collapse (#911) — arch/debug/docs/plan/review; patch family kept.
+3. ✅ **platform** collapse (#912) — 8 wrappers; security/toolchain/assert/plugin-health kept.
+4. ✅ **data + delivery** collapse (#913) — keep ontology + setup.
+5. ✅ **agentic + jam + persona + smaht** collapse (#914) — keep council/brainstorm/revisit/briefing; delete persona:submit + smaht:propose-skills.
+6. ✅ **Agent-orphan purge + registry sync** — `find_orphan_agents.py` did a reachability analysis (roots = commands/skills/scenarios/registries, **not** the generated `components.json`); removed 3 truly-orphaned delivery agents (cloud-cost-intelligence, delivery-manager, progress-tracker) while correctly keeping the 4 that live scenarios still dispatch to. `sync_components.py` re-derived the manifest; `docs/domains.md` updated.
+
+Each phase was reversible (git), suite-gated, and PR'd. Two reusable anti-drift tools fell out of phase 6: `find_orphan_agents.py` (dead-agent detection) and `sync_components.py` (manifest never silently drifts again).

package/docs/adr/0003-peers-gate-required-layers-optin.md

@@ -0,0 +1,41 @@
+# ADR 0003 — Two required peers (the gate), three opt-in layers
+
+- **Status:** Accepted — executed.
+- **Date:** 2026-06-09
+- **Supersedes:** the v12 stance in `docs/required-peers.md` ("five peers are required infrastructure").
+
+## Context
+
+v12 made all five peers (`wicked-testing`, `wicked-vault`, `wicked-brain`, `wicked-bus`, `wicked-loom`) **required** — `/wicked-garden:setup` blocked without any one, and the SessionStart bootstrap nagged "REQUIRED but not installed" for each.
+
+A third-party review pass (a skeptic persona + a `jam:council` panel of external models — codex/gpt-5.5 and opencode/claude-haiku) converged, independently, on one verdict: **the all-or-nothing five-peer requirement contradicts the "gap-filler that gets out of the way" pitch and is the single biggest adoption blocker.** "A gap-filler should feel additive; this sounds like infrastructure." "A single required peer would unlock solo adoption; bundle the other four as opt-in layers and you'd see 10× more install attempts."
+
+The author's counter-point matters too: **garden's goal is a curated toolkit**, and stripping to one tool deletes the concept. So the resolution is not "cut to one tool" — it's "keep the breadth, fix the coupling."
+
+## Decision
+
+Split the peers by what actually needs them:
+
+- **Required — the evidence gate:** `wicked-vault` + `wicked-loom`. The toolkit's central promise is *re-derived, fail-closed "done."* A gate that can't re-derive evidence is the one thing we refuse to fake, so setup **blocks** without these two. Trading adoption for honesty here is deliberate.
+- **Opt-in layers:** `wicked-testing` (acceptance-testing tool), `wicked-brain` (memory + search — the *what*), `wicked-understanding` (repo playbooks — the *how*; `skills`-standard, added in v12.16), `wicked-bus` (audit trail). Each unlocks one capability; none is a prerequisite for the others or for the gate. Setup **recommends** them and continues; bootstrap surfaces them informationally.
+
+This is the toolkit stance: **breadth you adopt incrementally**, not a five-thing prerequisite wall.
+
+## Why this is safe
+
+- The produces-gate already routes only through vault+loom; it never needed testing/brain/bus.
+- `wicked-bus` emission was already fire-and-forget / fail-open.
+- `wicked-brain` absence already degrades (structural search falls back to codegraph; memory features simply go dark).
+- Runtime resilience + the kill-switches (`WICKED_VAULT_BIN=""`, `WICKED_LOOM_CUTOVER=off`) are unchanged — they still fail closed, never vacuous-pass.
+
+## Changes
+
+- `commands/setup.md` — testing/brain/bus sections → "Recommended (opt-in layer)", non-blocking (Skip & continue); vault/loom → "Required — the evidence gate", still blocking. Added a "two required, three opt-in" framing note.
+- `hooks/scripts/bootstrap.py` — brain/bus notes reworded "REQUIRED but not installed" → "optional layer not installed"; removed the brain "[Action Required] … cannot function … do NOT proceed" escalation. vault/loom notes unchanged.
+- `docs/required-peers.md` rewritten to the 2-required/3-opt-in model; README/ETHOS/plugin.json/marketplace.json/repo description reframed; positioning shifted from "minimal gap-filler" to **"curated toolkit"** (breadth is the point; the coupling was the problem).
+
+## Consequences
+
+- Solo developers can install garden + the gate (two `npx`/`npm` steps) and get value immediately, adding layers as needed.
+- The honesty guarantee is preserved exactly where it's load-bearing (the gate).
+- Honest cost: a user who skips brain/bus/testing gets a smaller toolkit — which is the point of opt-in. Docs say so plainly rather than pretending everything is mandatory.