wicked-garden 12.27.0

package/commands/product/screenshot.md

@@ -0,0 +1,19 @@
+---
+description: Screenshot-based UI review using Claude's multimodal vision — analyze layout, color, typography, and consistency from image files
+argument-hint: "<image-path> [<reference-path>]"
+phase_relevance: ["clarify", "design", "review"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:product:screenshot
+
+Review UI design from screenshot images using Claude's multimodal vision — layout,
+spacing, color, typography, visual consistency — without source code. Formats: PNG,
+JPG, JPEG, WEBP, GIF.
+
+## Run it inline (no dispatch)
+
+1. Parse `<image-path>` (required) and optional `<reference-path>`.
+2. `Read(file_path="{image-path}")` (and the reference if provided) — the Read tool renders images visually.
+3. `Read("${CLAUDE_PLUGIN_ROOT}/skills/product/refs/screenshot.md")` — the evaluation rubric (layout/color/typography/components), comparison mode, and output format.
+4. Apply the rubric directly to the rendered image(s) and emit the review. Flag contrast issues for `product:a11y`; compare against a `product:mockup` spec when relevant.

package/commands/product/strategy.md

@@ -0,0 +1,40 @@
+---
+description: Strategic analysis - ROI, value proposition, market, competitive
+argument-hint: "<target> [--focus roi|value|market|competitive|all] [--quick]"
+phase_relevance: ["clarify", "design", "review"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:product:strategy
+
+Strategic business analysis: ROI, value proposition, market sizing/timing,
+competitive landscape. `--quick` = go/no-go signal only. Use `product:strategy` to
+evaluate an idea; `product:elicit` to convert a chosen direction into requirements.
+
+## 1. Read target + parse focus
+
+Read `<target>` (proposal/feature doc). Determine focus(es) from `--focus` (default `all`).
+
+## 2. Single focus -> inline
+
+For one lens, `Read("${CLAUDE_PLUGIN_ROOT}/skills/product/refs/strategy.md")` and apply
+that lens's rubric directly — market lens for `roi|market|competitive`, value lens for
+`value`. No dispatch.
+
+## 3. `--focus all` -> dispatch value lens; run market lens inline
+
+```
+Task(subagent_type="wicked-garden:product:value-strategist",
+     prompt="""Target: {target_content}  Quick: {--quick}
+Design value proposition: customer JTBD, pain relievers, gain creators, differentiation, value statement.""")
+```
+
+The market lens (ROI / TAM-SAM-SOM / SWOT / Five Forces) runs **inline** in this
+command — `Read("${CLAUDE_PLUGIN_ROOT}/skills/product/refs/strategy.md")` and apply its
+market rubric directly to the target: investment/returns/payback for `roi`, TAM/SAM/SOM
++ timing for `market`, SWOT/positioning for `competitive`. No separate dispatch.
+
+## 4. Synthesis (always inline)
+
+Render the verdict inline — Proceed / Caution / Defer / Do-Not-Proceed + confidence +
+assumptions + metrics (`refs/strategy.md` output format). Never delegate the synthesis.

package/commands/product/synthesize.md

@@ -0,0 +1,23 @@
+---
+description: Generate actionable recommendations from customer feedback insights
+argument-hint: "[--priority high|medium|low|critical] [--feature X] [--format brief|detailed]"
+next-step: null
+phase_relevance: ["clarify", "design", "review"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:product:synthesize
+
+Translate customer-feedback analysis into prioritized, evidence-backed action items.
+Pipeline step 3 of 3: listen -> analyze -> **synthesize**.
+
+## Run it inline (no dispatch)
+
+1. Locate analysis input:
+   ```bash
+   PRODUCT_ROOT=$(sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" "${CLAUDE_PLUGIN_ROOT}/scripts/_run.py" scripts/resolve_path.py wicked-garden:product)
+   ls "${PRODUCT_ROOT}/voice/analysis/"
+   ```
+   If empty, tell the user to run `/wicked-garden:product:analyze` first and stop.
+2. `Read("${CLAUDE_PLUGIN_ROOT}/skills/product/refs/synthesize.md")` — the impact x frequency x trend x effort x risk-of-inaction prioritization model, per-recommendation fields, and output format.
+3. Apply the rubric directly, honoring `--priority`/`--feature`/`--format`. Emit prioritized recommendations, quick wins, strategic initiatives, and metrics to track.

package/commands/product/ux-review.md

@@ -0,0 +1,42 @@
+---
+description: |
+  Use when reviewing UX quality, visual design consistency, or accessibility — covers user flows,
+  design system adherence, spacing/typography/color, component patterns, and research quality.
+  NOT for generating UX flows (use product:ux) or accessibility code audits (use product:a11y).
+argument-hint: "<target> [--focus flows|ui|a11y|research|all] [--quick]"
+phase_relevance: ["clarify", "design", "review"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:product:ux-review
+
+Broad design audit across four lenses — flows, visual consistency (UI), WCAG
+accessibility, user-research quality. Each lens returns score 1-5 + findings.
+`--quick` = critical-only. Use `ux-review` to evaluate existing UI; use `product:ux`
+to generate flows.
+
+## 1. Determine focus
+
+Parse `--focus`. Auto-detect: `.tsx/.jsx/.vue` -> flows+ui+a11y; `.css/.scss` -> ui;
+requirements `.md` -> research; directory -> all.
+
+## 2. Single focus -> inline
+
+For one lens, `Read("${CLAUDE_PLUGIN_ROOT}/skills/product/refs/ux-review.md")`, apply
+that lens's rubric directly to the target, and emit the score + findings. No dispatch.
+
+## 3. `--focus all` -> dispatch the lenses in parallel
+
+Genuine multi-lens concurrency on a large surface earns the hop. Common preamble:
+`Target: {target_content}  Quick: {--quick}`. Each agent returns score 1-5 + findings.
+
+```
+Task(subagent_type="wicked-garden:product:ux-designer",
+     prompt="""<preamble> Two lenses. (1) Flows: clarity, error/empty/loading states, interaction patterns, IA. (2) Research: personas, journeys, JTBD, validation status. Issues with severity + file:line + impact + fix; plus a research-gap list.""")
+Task(subagent_type="wicked-garden:product:ui-reviewer",
+     prompt="""<preamble> Eval design-system adherence, color/typography/spacing, component patterns, responsive + visual states. Issues with severity + fix.""")
+Task(subagent_type="wicked-garden:product:a11y-expert",
+     prompt="""<preamble> Audit WCAG 2.1 AA (POUR): semantic HTML, ARIA, keyboard, screen reader, contrast, focus. Report WCAG level + issues with criterion + fix.""")
+```
+
+The research lens (personas / journeys / JTBD) is folded into the ux-designer dispatch — flow and research evaluation share the same artifact and reviewer skill. Merge the three returns into the combined report (`refs/ux-review.md` output format).

package/commands/product/ux.md

@@ -0,0 +1,20 @@
+---
+description: |
+  Use when creating or analyzing user flows, information architecture, and interaction patterns — in-chat,
+  without a design tool. NOT for production visual design (use figma plugin) or accessibility audits (use product:a11y).
+argument-hint: "<target-or-description> [--mode create|analyze]"
+phase_relevance: ["clarify", "design", "review"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:product:ux
+
+Design and analyze user flows, interaction patterns, and information architecture.
+For a broad design audit (UI + a11y + research), use `product:ux-review` instead.
+
+## Run it inline (no dispatch)
+
+1. Parse `<target>` (path or description) and `--mode`. Auto-detect: description string -> `create`; file/dir path -> `analyze`.
+2. Gather content: if a path, read the target files (components, pages, routing); if a description, use as the brief.
+3. `Read("${CLAUDE_PLUGIN_ROOT}/skills/product/refs/ux.md")` — create/analyze steps, flow checklist, Nielsen heuristics, interaction patterns, diagram + output formats.
+4. Apply the rubric directly and emit the flow/IA + findings. Pair with `product:mockup` for wireframes.

package/commands/product/visual-direction.md

@@ -0,0 +1,34 @@
+---
+description: |
+  Reason from content structure to visual form before proposing any treatment. Answers
+  five structured questions (content type, audience mental model, desired action, physical
+  artifact metaphor, stupid-question test) and produces a one-paragraph visual brief.
+
+  Use when designing or evaluating a section's visual treatment. NOT for accessibility
+  audits, visual consistency review, or wireframing.
+argument-hint: "<section-name-or-description> [--skip-to <question-number>]"
+phase_relevance: ["clarify", "design", "review"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:product:visual-direction
+
+Stop before proposing any visual form. Reason from what the content *is* to what it
+should look like — not from what the nearest project used.
+
+## Run it inline (no dispatch)
+
+1. Parse `<section-name-or-description>`. Read any file path given. `--skip-to <N>` starts at that question.
+
+2. `Read("${CLAUDE_PLUGIN_ROOT}/skills/product/visual-direction/SKILL.md")` — five questions, anti-patterns, visual brief format.
+
+3. Answer all five questions out loud before proposing any treatment:
+   - **Q1** What IS this content? (intrinsic structure, not appearance)
+   - **Q2** What does the audience already think in? (mental model)
+   - **Q3** What action do we want the user to take?
+   - **Q4** If this content were a physical artifact, what form would it take?
+   - **Q5** Stupid-question test: would the proposed form feel obviously wrong?
+
+4. Emit the **visual brief**: content type · audience mental model · proposed metaphor · animation role · nearest-neighbor risk named.
+
+Do not skip to wireframe or implementation without completing step 3.

package/commands/prove.md

@@ -0,0 +1,47 @@
+---
+description: Prove a claim by re-deriving it (run + gate) instead of asserting "done"
+phase_relevance: ["build", "review", "operate"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:prove
+
+The one-line re-derivation verb. Before you tell the user something is "done"
+/ "tests pass" / "the build is clean", **prove it** — don't assert it. This
+runs the command, freezes its real exit code as wicked-vault evidence, and gates
+by re-running the verifier. Exit 0 only on a re-derived PASS; fail-closed (exit
+3) when the loom/vault backend is unresolvable — never a vacuous pass.
+
+It collapses the gate ritual (vault init → declare-contract → record --run →
+gate) into one call, so the gate is something you reach for by reflex.
+
+Instructions:
+- Run it inline (the `--by` command executes in `--project-dir`, default `.`):
+  ```bash
+  sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" \
+    "${CLAUDE_PLUGIN_ROOT}/scripts/qe/prove.py" \
+    <claim> --by "<command>" [--verifier exit_code_eq:0] [--project-dir <dir>]
+  ```
+  e.g. `prove.py tests-pass --by "pytest -q"` · `prove.py build-clean --by "npm run build"`
+- **Validate the OUTPUT, not just an exit code.** `--verifier` re-runs against the
+  command's output: `regex_match:<re>` / `not_contains:<re>` scan stdout;
+  `jq_pred:<expr>` evaluates a predicate over the command's JSON stdout;
+  `commit_exists:<sha>` checks a git commit. This works on **final and interim**
+  artifacts — prove an intermediate produce the moment it exists, not only at the end:
+  ```
+  prove.py adr-has-decision --by "cat decision.md" --verifier "regex_match:## Decision" --kind doc
+  prove.py config-no-secrets --by "cat app.yaml"   --verifier "not_contains:(?i)password" --kind doc
+  prove.py enough-options    --by "cat options.json" --verifier "jq_pred:.options | length >= 2" --kind doc
+  ```
+- Read the JSON verdict: `satisfied` is the truth; `re_derived: true` means it
+  was recomputed from frozen evidence (not your claim); `gate: "unavailable"`
+  means the backend is down and the gate failed closed.
+- Only report the work as done when `satisfied: true`. On `REJECT`, the claim is
+  false — fix it, don't narrate around it.
+
+**Hard gates (incident/migrate/review): `--with-attestations`.** Add it and the
+gate stays `REJECT` (`UNATTESTED`) until an INDEPENDENT evaluator — not the agent
+that did the work — runs `wicked-vault attest <artifact-id> --opinion pass`. The
+doer's own evidence cannot satisfy a hard gate; that's the point. Find the
+artifact with `wicked-vault list --scope <scope> --phase <phase>`. A `reject`
+attestation flips the gate to `REJECT` even if the evidence re-derives.

package/commands/report-issue.md

@@ -0,0 +1,243 @@
+---
+description: File a GitHub issue for a bug, UX friction point, or unmet outcome
+argument-hint: "[bug | ux-friction | unmet-outcome | --list-unfiled]"
+allowed_tools:
+  - Bash
+  - Read
+  - Write
+  - Grep
+  - AskUserQuestion
+  - Skill
+phase_relevance: ["*"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:report-issue
+
+File a structured GitHub issue with acceptance criteria, steps to reproduce, and desired outcome.
+
+## Instructions
+
+### 1. Parse Arguments
+
+Determine issue type from arguments:
+- `bug` → Bug Report (label: `bug`)
+- `ux-friction` → UX Friction Report (label: `ux`)
+- `unmet-outcome` → Unmet Outcome Report (label: `gap`)
+- `--list-unfiled` → List and optionally file unfiled issues from fallback queue
+- No argument → Ask user to select type
+
+If `--list-unfiled` was provided, skip to Section 7.
+
+### 2. Collect Fields
+
+Gather information interactively based on issue type.
+
+**Bug Report**:
+- Title: Short summary of the bug
+- Steps to Reproduce: What actions led to the bug
+- Expected Behavior: What should have happened
+- Actual Behavior: What actually happened
+- Impact: How severe is this (optional)
+
+**UX Friction**:
+- Title: Short summary of the friction
+- What You Tried: The intent and actions taken
+- What Happened Instead: The confusing or unexpected result
+- Suggested Improvement: How it could be better (optional)
+
+**Unmet Outcome**:
+- Title: Short summary of the gap
+- Goal: What the session was trying to achieve
+- What Happened: The actual result
+- What Would Have Helped: Suggestions (optional)
+
+### 3. Research Before Filing
+
+After collecting the title and initial description, run three research steps. All findings are additive — they enrich the issue body but do not block filing.
+
+#### 3a. Duplicate Detection
+
+Search existing open issues for the same or similar problem:
+
+```bash
+gh issue list --repo {repo} --search "{title keywords}" --state open --json number,title,state --limit 10
+```
+
+- If `gh` is unavailable or the repo is not detected, skip this step.
+- If potential duplicates are found (titles with significant keyword overlap), note them:
+  ```
+  Potential duplicates found — will link in issue body: #123, #456
+  ```
+- If no duplicates found, note: "No open duplicates detected."
+- Append to issue body as a **Duplicate Check** section:
+  ```markdown
+  ## Duplicate Check
+
+  <!-- Searched: "{keywords}" -->
+  - Potential duplicates: #123 "{title}", #456 "{title}"
+  <!-- OR -->
+  - No open duplicates detected.
+  ```
+
+#### 3b. Codebase Research
+
+Search the codebase for files and symbols related to the issue keywords:
+
+```bash
+# Use Grep to find files relevant to the issue description
+grep -r --include="*.md" --include="*.py" --include="*.js" --include="*.ts" -l "{keyword1}\|{keyword2}" . --max-count=1 | head -10
+```
+
+If relevant files are found (up to 5 most relevant), list them as **Related Code**. If no relevant files are found, omit this section.
+
+Append to issue body when files are found:
+```markdown
+## Related Code
+
+Files likely relevant to this issue:
+- `{path/to/file.py}`
+- `{path/to/other.md}`
+```
+
+#### 3c. Memory Recall
+
+Recall any past context about this area from the memory store:
+
+```
+Skill(skill="wicked-brain:memory", args="{issue title keywords}")
+```
+
+If memories are returned that are relevant to the issue, summarize them as **Prior Context**. If no relevant memories exist, omit this section.
+
+Append to issue body when memories are found:
+```markdown
+## Prior Context
+
+From memory store:
+- {memory summary 1}
+- {memory summary 2}
+```
+
+### 4. Validate Acceptance Criteria (SMART)
+
+Before composing the final issue, validate each acceptance criterion against SMART criteria:
+
+**Specific**: The AC must reference a concrete behavior, file, command, or measurable artifact.
+- Fail: "should work better", "improves performance", "feels right"
+- Pass: "Bash hook returns `{\"ok\": true}` on success", "no grep results for hardcoded paths"
+
+**Measurable**: The AC must include a verifiable assertion — something that can be confirmed true or false without ambiguity.
+- Fail: "works as expected", "no errors occur"
+- Pass: "passes `/wg-check`", "exit code 0", "output contains 'No issues found'"
+
+For each AC that fails either check:
+- **In just-finish / auto mode**: Auto-improve the AC. Rewrite it to be specific and measurable using context from the issue description. Log the change: `[SMART] Improved AC: "{original}" → "{improved}"`
+- **In interactive mode**: Warn the user and suggest an improved version. Ask if they'd like to use the improved version or keep the original.
+
+### 5. Compose Issue
+
+Build the issue body using the template from the skill's `refs/templates.md`. Include:
+- Reporter info (Claude Code manual report)
+- All collected fields
+- Research findings (Duplicate Check, Related Code, Prior Context) appended after main body
+- Acceptance criteria checklist (SMART-validated)
+- Desired outcome statement
+
+Auto-detect the repo:
+```bash
+gh repo view --json nameWithOwner -q .nameWithOwner
+```
+
+### 6. Quality Gate and File
+
+#### 6a. Quality Gate (advisory — warns only, does not block filing)
+
+Run these checks before filing. Log any warnings but proceed regardless:
+
+| Check | Criteria | Warning Message |
+|-------|----------|-----------------|
+| Title length | Under 80 characters | "Title is {N} chars — consider shortening for readability" |
+| Title descriptiveness | Not a single word or generic phrase | "Title may be too vague — add more context" |
+| Steps to reproduce | For bugs: at least 2 numbered steps | "Bug report has fewer than 2 reproduction steps" |
+| Acceptance criteria count | At least 2 ACs | "Only {N} acceptance criteria — add at least 2" |
+| AC verb prefix | Each AC starts with an action verb | "AC '{text}' does not start with a verb" |
+| AC independence | Each AC is independently verifiable (no 'and' combining two checks) | "AC '{text}' may combine multiple assertions — split for clarity" |
+| Duplicate check | Duplicate search was completed | "Duplicate check was skipped — search for existing issues manually" |
+
+Display warnings (if any) before the preview:
+```markdown
+## Quality Warnings
+
+- Title is 92 chars — consider shortening for readability
+- AC 'Root cause identified' does not start with a verb
+```
+
+If no warnings, skip the Quality Warnings block.
+
+#### 6b. Confirm and File
+
+Show the composed issue to the user:
+
+```markdown
+## Issue Preview
+
+**Title**: {title}
+**Label**: {label}
+**Repo**: {repo}
+
+{body}
+
+---
+File this issue? (Approve to submit via gh, or cancel)
+```
+
+On confirmation:
+- If `gh` is available and repo detected:
+  - Write body to a temp file
+  - Run: `gh issue create --repo {repo} --title "{title}" --body-file {tmpfile} --label "{label}"`
+  - Report the issue URL to the user
+  - Clean up temp file
+- If `gh` unavailable or no repo:
+  1. **Print to screen**: Display the full issue as formatted markdown:
+     ```markdown
+     ## Issue: {title}
+     **Label**: {label}
+     **Repo**: {repo or "unknown"}
+
+     {body}
+     ```
+  2. **Generate GitHub URL**: Build a pre-filled issue creation URL using Python:
+     ```python
+     import urllib.parse
+     title_enc = urllib.parse.quote(title)
+     body_enc = urllib.parse.quote(body)
+     label_enc = urllib.parse.quote(label)
+     url = f"https://github.com/{owner}/{repo}/issues/new?title={title_enc}&body={body_enc}&labels={label_enc}"
+     print(url)
+     ```
+     Display the URL to the user with instructions: "Open this URL to file the issue directly in your browser."
+  3. **Ask to save locally**: Ask the user: "Save this issue locally for later filing with `/wicked-garden:report-issue --list-unfiled`? (yes/no)"
+     - If yes: Resolve path `UNFILED=$(sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" "${CLAUDE_PLUGIN_ROOT}/scripts/_run.py" scripts/resolve_path.py wicked-garden unfiled-issues)` and save to `${UNFILED}/{timestamp}.json`
+     - If no: Skip caching. Done.
+
+### 7. List Unfiled Issues (--list-unfiled)
+
+If `--list-unfiled` was provided:
+
+1. Resolve path: `UNFILED=$(sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" "${CLAUDE_PLUGIN_ROOT}/scripts/_run.py" scripts/resolve_path.py wicked-garden unfiled-issues)`
+2. Read all JSON files from `${UNFILED}/`
+3. If empty: report "No unfiled issues found."
+4. If found: display a summary table:
+
+```markdown
+| # | Title | Type | Date |
+|---|-------|------|------|
+| 1 | Tool failure: Bash (3x) | bug | 2026-02-17 |
+| 2 | Navigation is confusing | ux | 2026-02-16 |
+```
+
+5. Ask user which to file (all, specific numbers, or cancel)
+5. For each selected: run `gh issue create` with the stored title, body, and label
+6. On success: delete the unfiled JSON file
+7. Report results

package/commands/reset.md

@@ -0,0 +1,144 @@
+---
+allowed-tools: ["Bash", "Read", "AskUserQuestion"]
+description: "Reset wicked-garden to a clean state — choose which data to clear"
+argument-hint: "[--all] [--only domain1,domain2] [--keep domain] [--force] [--list-projects] [--all-projects]"
+phase_relevance: ["*"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:reset
+
+Selectively clear wicked-garden local state. Shows what exists and lets the user choose what to reset.
+
+## Arguments
+
+- `--all`: Select all domains for clearing (can combine with `--keep`)
+- `--only {domains}`: Comma-separated list of specific domains to clear
+- `--keep {domains}`: Comma-separated domains to preserve when using `--all`
+- `--force`: Skip confirmation prompt
+- `--list-projects`: List all projects with stored state (each working directory is a separate project)
+- `--all-projects`: Operate on all projects, not just the current one
+
+## Project Scope
+
+State is project-scoped — each working directory gets its own isolated storage. The reset command operates on the current project by default. Use `--list-projects` to see all projects, and `--all-projects` to clear data across all of them.
+
+## Question Mode
+
+Detect whether AskUserQuestion is available:
+
+```bash
+python3 -c "
+import json, os, sys
+from pathlib import Path
+sys.path.insert(0, str(Path(os.environ.get('CLAUDE_PLUGIN_ROOT', '.')).resolve() / 'scripts'))
+from _session import SessionState
+state = SessionState.load()
+print('PLAIN_TEXT' if state.dangerous_mode else 'INTERACTIVE')
+"
+```
+
+## Instructions
+
+### 1. Scan Current State
+
+Run a dry-run scan to see what exists:
+
+```bash
+sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" "${CLAUDE_PLUGIN_ROOT}/scripts/_run.py" scripts/reset.py --json
+```
+
+Parse the JSON output. Extract the domains where `exists` is `true`.
+
+The JSON output includes `project` (current project slug) and `project_root` (storage path).
+
+If no domains have state, tell the user: "Nothing to reset — wicked-garden has no local state for project {project}." and stop.
+
+**If `--list-projects` was passed**: Run `sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" "${CLAUDE_PLUGIN_ROOT}/scripts/_run.py" scripts/reset.py --list-projects --json` instead and display the project list. Stop after showing.
+
+**If `--all-projects` was passed**: Add `--all-projects` to the reset command in Step 4.
+
+### 2. Show State and Ask What to Clear
+
+**If `--all` or `--only` was passed**: Skip the selection — targets are already known. Go to Step 3.
+
+**Otherwise**: Present the found domains and let the user choose.
+
+Show a numbered list of domains that have state, plus an "All" option:
+
+```
+## Current wicked-garden state (project: {project_slug})
+
+Found {n} domain(s) with local data:
+
+  1. config — Setup configuration (52 B)
+  2. smaht — Session history and context cache (12 KB)
+  3. crew — Crew project data (4 KB)
+  4. mem — Memory store (8 KB)
+  5. search — Search index (2.1 MB)
+  a. All of the above
+
+Which domains would you like to reset? (comma-separated numbers, or 'a' for all)
+```
+
+Only list domains where `exists` is `true`. Number them sequentially.
+
+**INTERACTIVE mode**: Use AskUserQuestion. Since there may be more than 4 options, use plain text instead (AskUserQuestion only supports up to 4 options).
+
+**In both modes**: Present as plain text and STOP. Wait for the user to reply.
+
+Parse the user's reply:
+- Single number → that domain only
+- Comma-separated numbers (e.g., "1,3,5") → those domains
+- "a" or "all" → all found domains
+- Domain names (e.g., "smaht, crew") → those domains directly
+
+Echo back: "You selected: **{domain list}**."
+
+### 3. Confirm
+
+**If `--force` was passed**: Skip to Step 4.
+
+Present a confirmation:
+
+```
+This will permanently clear: {selected domains}
+
+1. Yes, clear selected data
+2. Cancel
+
+Please reply with 1 or 2.
+```
+
+STOP and wait. If the user cancels, say "Reset cancelled." and stop.
+
+### 4. Execute Reset
+
+Build the `--only` list from the user's selection:
+
+```bash
+sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" "${CLAUDE_PLUGIN_ROOT}/scripts/_run.py" scripts/reset.py --confirm --only {selected_domains_space_separated} --json
+```
+
+Or if `--all` with `--keep`:
+
+```bash
+sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" "${CLAUDE_PLUGIN_ROOT}/scripts/_run.py" scripts/reset.py --confirm --all --keep {kept_domains_space_separated} --json
+```
+
+### 5. Report Results
+
+Parse the JSON output and show:
+
+```
+## Reset complete
+
+Cleared: smaht, crew
+Kept: config, mem, search, delivery, jam
+Errors: none
+
+Note: If you cleared 'config', the setup wizard will run on your next session.
+Run /wicked-garden:setup to reconfigure now.
+```
+
+If there were errors, show them and suggest manual cleanup.

package/commands/search/blast-radius.md

@@ -0,0 +1,58 @@
+---
+description: |
+  Use when you need to know what would break or be affected by changing a symbol — traces
+  dependents (what uses this) over the code-relationship graph, including injected edges
+  (bus/dispatch/capability) that grep and a static call-graph cannot see.
+  NOT for full data lineage tracing (use search:lineage) or general code search (use wicked-brain:search).
+argument-hint: "<symbol> [--depth N]"
+phase_relevance: ["build", "review"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:search:blast-radius
+
+Analyze what would be affected if you changed a symbol — **delegates to wicked-brain's
+code-relationship graph** (`wicked-brain:graph`), which owns the unified static + injected
+graph as of ADR 0004. Garden no longer maintains its own graph; it consumes brain's.
+
+> **Scope**: `blast-radius` answers "what breaks if I change X?" (the dependents graph).
+> For **data-flow tracing** (UI field → DB column or reverse), use `/wicked-garden:search:lineage`.
+
+## Arguments
+- `symbol` (required): the symbol to analyze (a file node like `src/app.py`, or a symbol name).
+- `--depth` (optional): traversal depth (brain default applies if omitted).
+
+## Instructions
+
+1. **Ensure the graph is fresh** (brain builds the codegraph static graph + runs the injected-edge extractors in one pass):
+   ```bash
+   npx -y wicked-brain-call graph-index
+   ```
+   The result carries a `staleness` stamp; if `stale` is true after editing, re-run it.
+
+2. **Resolve the symbol to a graph node id.** Node ids are `file:<relpath>` for files, or `function:<hash>` etc. for symbols. For a file, use `file:<path>` directly. For a named symbol, find its id via brain:
+   ```bash
+   npx -y wicked-brain-call symbols --query "<symbol>"     # or wicked-brain:lsp workspace-symbols
+   ```
+
+3. **Query blast radius from brain** (static + injected dependents in one answer — the authoritative layer):
+   ```bash
+   npx -y wicked-brain-call graph-blast-radius --node "file:<path-or-resolved-id>"
+   ```
+   The `dependents` array includes relationships grep can't see: a command that *dispatches* an agent (`injected:dispatch`), a consumer that *subscribes* to an event (`injected:bus`), an agent that *declares* a capability (`injected:capability`). Each result carries a `staleness` stamp.
+
+4. **Fallbacks** (in order):
+   - If `graph-blast-radius` returns `engine: "unavailable"`, codegraph isn't installed where brain runs — install it (`npx @colbymchenry/codegraph`) or set `WICKED_CODEGRAPH_BIN`, then `graph-index`.
+   - If brain is unreachable, fall back to `wicked-brain:search` for semantic neighbors, then Grep/Glob for literal refs — and **flag that injected relationships will be MISSING** from the result.
+
+5. Report: **dependents** (static + injected, with provenance), total blast-radius count, files affected, and the graph's staleness.
+
+## Example
+```
+/wicked-garden:search:blast-radius scripts/_bus.py
+/wicked-garden:search:blast-radius UserService --depth 3
+```
+
+## Notes
+- The graph + queries live in **wicked-brain** now (ADR 0004); this command is a thin wrapper over `wicked-brain:graph`. For lineage (downstream dependencies) use `/wicked-garden:search:lineage`.
+- Garden contributes its proprietary **archetype** edges to brain's graph via the drop-in extractor `.codegraph-extractors/archetype.mjs` (discovered by brain's registry) — so archetype→playbook relationships are in the blast radius too.