wicked-garden 12.27.0

package/commands/install.md

@@ -0,0 +1,118 @@
+---
+allowed-tools: ["AskUserQuestion", "Bash"]
+description: "Install wicked-* peer tools — version-checks garden first, then picks layers and solo beds via multi-select"
+argument-hint: ""
+phase_relevance: ["bootstrap"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:install
+
+First-run installer for the wicked-* ecosystem. Ensures wicked-garden is current, installs the required evidence floor (wicked-vault automatically — no question asked), then prompts for optional layers and solo beds via a multi-select picker. The loom peer-resolution engine is absorbed into wicked-garden itself (scripts/loom/) — no separate wicked-loom install is needed.
+
+## Instructions
+
+### 1. Check wicked-garden is current
+
+Get the installed version from its package.json (typically `~/.claude/plugins/wicked-garden/package.json` or the path Claude Code reports for `CLAUDE_PLUGIN_ROOT`):
+
+```bash
+node -e "try{const p=require('path'),os=require('os');const v=require(p.join(os.homedir(),'.claude','plugins','wicked-garden','package.json')).version;console.log(v)}catch(e){console.log('UNKNOWN')}" 2>/dev/null || echo "UNKNOWN"
+```
+
+Get the npm latest:
+
+```bash
+npm view wicked-garden version 2>/dev/null || echo "UNKNOWN"
+```
+
+If installed < latest: show "wicked-garden {installed} is installed — latest is {latest}. Consider updating via the marketplace (`claude plugins marketplace update wicked-garden`)." Then continue — don't block on this.
+
+If UNKNOWN: note it and continue.
+
+### 2. Install the required evidence floor
+
+No prompt — wicked-vault is the mandatory evidence backend for every gate. The loom
+peer-resolution engine is built into wicked-garden (scripts/loom/) — nothing to install
+for loom. Run vault install and show a progress line:
+
+```bash
+npx wicked-vault-install
+```
+
+On failure: display the raw error and note "you can install wicked-vault manually via `npx wicked-testing install` and re-run `/wicked-garden:install` to retry." Continue to step 3 regardless — step 5 will surface what's still missing.
+
+### 3. Pick optional layers and solo beds
+
+Detect question mode:
+
+```bash
+sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" "${CLAUDE_PLUGIN_ROOT}/scripts/setup/detect_state.py" question-mode 2>/dev/null || echo "INTERACTIVE"
+```
+
+---
+
+**INTERACTIVE mode (AskUserQuestion)**
+
+Q1 — multi-select, header "Layers":
+
+"Which optional layers do you want to add?"
+
+Options (multiSelect: true):
+- label: "wicked-testing", description: "QE pipeline — verdicts your agent can't fake · author ≠ executor ≠ reviewer"
+- label: "wicked-brain", description: "Persistent memory — cross-session recall, cited search, code graph"
+- label: "wicked-understanding", description: "Repo playbooks from HEAD — the repo's 'how,' always current"
+- label: "wicked-bus", description: "Local event bus — one SQLite file, no broker, no daemon, no ports"
+
+Q2 — single-select, header "Solo bed":
+
+"Add wicked-interactive — the live HTML presentation builder?"
+
+Options:
+- label: "Yes — add it", description: "Great for decks, landing pages, and demos at 11pm. Standalone — no garden required."
+- label: "Skip for now", description: "Add it later by re-running /wicked-garden:install"
+
+Echo back the full selection list before installing: "Installing: [comma-joined list]. Proceeding..."
+
+---
+
+**PLAIN_TEXT mode (dangerous — AskUserQuestion broken)**
+
+Present both questions as numbered plain-text lists. STOP and wait for the user's reply before proceeding. Parse the reply, echo it back, then continue.
+
+### 4. Install selected tools
+
+Run in the order listed. Show a ✓ or ✗ line per tool as each completes.
+
+| Tool | Method |
+|---|---|
+| wicked-testing | `npx wicked-testing install` |
+| wicked-brain | Claude Code slash command — display `/plugin install wicked-brain`, ask user to run it, then verify by checking if the plugin dir exists under `~/.claude/plugins/wicked-brain` |
+| wicked-understanding | `npx skills add mikeparcewski/wicked-understanding --all` |
+| wicked-bus | Claude Code slash command — display `/plugin install wicked-bus`, ask user to run it, then verify under `~/.claude/plugins/wicked-bus` |
+| wicked-interactive | `claude plugins marketplace add mikeparcewski/wicked-interactive && claude plugins install wicked-interactive` |
+
+For any tool where the user must run a slash command, clearly display the command, pause, and wait for confirmation before marking it done.
+
+### 5. Verify peer health
+
+Run the internal loom doctor (no external wicked-loom needed):
+
+```bash
+sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" -c "
+import sys, os, json
+sys.path.insert(0, os.path.join(os.environ.get('CLAUDE_PLUGIN_ROOT', '.'), 'scripts'))
+from loom import compose
+rows = compose.check_all()
+print(json.dumps(rows, indent=2))
+"
+```
+
+Parse JSON output. Show a summary table — peer name, version/status (`ok`/`drift`/`present`/`missing`/`error`), and a next-step hint for anything `missing` or `drift`. A `present` row (peer responds but version unreadable) is a warning, not blocking.
+
+### 6. Done
+
+Display:
+- A clean installed-tools summary with versions
+- Quick start hint: `/wicked-garden:setup` — full onboarding (indexes your codebase into wicked-brain, writes project memory, configures the status line)
+- Or just start: describe a task and wicked-garden routes it to the right work-shape archetype automatically

package/commands/intent.md

@@ -0,0 +1,54 @@
+---
+allowed-tools: ["Bash"]
+description: "Show or set the session intent variable (simple-edit | feature | rigor | research). Sticky for the session; auto-detect resets next session."
+argument-hint: "[simple-edit|feature|rigor|research]"
+phase_relevance: ["*"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:intent
+
+Show or override the session intent variable — the v10 Phase 1 keystone (#813). Auto-detected on turn 1; sticky for the session; this command overrides explicitly.
+
+**Vocabulary (locked)**: `simple-edit | feature | rigor | research`. To change, run a brainstorm — don't add ad-hoc.
+
+**Usage**:
+- `/wicked-garden:intent` — show the effective current value and how it was set
+- `/wicked-garden:intent <value>` — explicit override; sticky until session end
+
+```bash
+ARG="${1:-}"
+sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" - "$ARG" <<'PY'
+import os
+import sys
+
+plugin_root = os.environ.get("CLAUDE_PLUGIN_ROOT")
+if not plugin_root:
+    print("error: CLAUDE_PLUGIN_ROOT not set", file=sys.stderr)
+    sys.exit(1)
+sys.path.insert(0, os.path.join(plugin_root, "scripts"))
+
+from _session import SessionState
+
+VALID = ("simple-edit", "feature", "rigor", "research")
+arg = (sys.argv[1] if len(sys.argv) > 1 else "").strip()
+state = SessionState.load()
+
+if not arg:
+    eff = state.intent or "(not set; auto-detect runs on next turn)"
+    src = "explicit" if state.intent_explicit else "auto-detected" if state.intent else "n/a"
+    print(f"intent: {eff}  ({src})")
+    sys.exit(0)
+
+if arg not in VALID:
+    print(f"error: '{arg}' not in {VALID}", file=sys.stderr)
+    sys.exit(1)
+
+state.update(intent=arg, intent_explicit=True)
+print(f"intent set: {arg}  (explicit override; sticky until session end)")
+PY
+```
+
+After explicit override, the next system-reminder echoes a bare `<wg intent="X" t=N />` label so the model can see the user steered the framework. Auto-detected intent stays invisible (prevents confirmation bias).
+
+References: brain memory `v10-intent-variable-design-decision`, brainstorm `v10-session-01-intent-and-hook-gating`, PR #814 (the original Phase 1 ship), PRs #818/#819 (skill-discovery patches that proved skills under `skills/{domain}/{name}/SKILL.md` don't surface as slash commands — hence this command file).

package/commands/jam/brainstorm.md

@@ -0,0 +1,37 @@
+---
+description: Start a new brainstorm session with dynamic focus groups
+argument-hint: "<topic> [--personas list] [--rounds n] [--converge fast]"
+phase_relevance: ["clarify", "design"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:jam:brainstorm
+
+Start a full brainstorm with evidence-backed perspectives.
+
+> **Progression**: `quick` (60s gut-check) → `brainstorm` (full session, this command) → `council` (structured verdict).
+> See also: `/wicked-garden:jam:quick`, `/wicked-garden:jam:council` The facilitator gathers evidence from the ecosystem (past decisions, code context, brainstorm outcomes) before assembling personas, so they argue from data — not just opinions. After synthesis, a structured decision record is automatically stored via wicked-brain:memory for organizational memory.
+
+## Convergence Modes
+
+- **normal** (default): Run all requested rounds (2-3), then synthesize.
+- **fast** (`--converge fast`): After each round, assess whether there is enough signal to synthesize. If personas are converging on a clear direction with at least 2 actionable insights and no major unresolved tensions, skip remaining rounds and synthesize immediately. Maximum: 1 round before early synthesis is allowed.
+
+Delegate to the facilitator agent:
+
+```
+Task(subagent_type="wicked-garden:jam:brainstorm-facilitator",
+     prompt="Run a full brainstorm session on: {topic}. Options: {personas}, {rounds}, convergence_mode={converge|'normal'}.
+
+Convergence mode instructions:
+- If convergence_mode is 'fast': After EACH round, perform a convergence check before proceeding. Ask: (1) Are there at least 2 clear, actionable insights? (2) Is there broad directional agreement among personas? (3) Are remaining tensions minor or well-characterized? If all three are YES, skip remaining rounds and proceed directly to synthesis. This is the EXPECTED path in fast mode — do not run extra rounds just because they were planned.
+- If convergence_mode is 'normal': Run all planned rounds, but still note in synthesis if convergence happened early.
+
+Follow the full session structure including evidence gathering, persona assembly, discussion rounds, multi-AI perspective (if available), synthesis, and decision record storage.
+
+Native-task tracking (fail open on any tool errors):
+1. Session start: TaskCreate(subject='Jam: {topic}', metadata={'event_type':'task','chain_id':'jam-{topic-slug}.root','source_agent':'jam-facilitator','initiative':'{topic-slug}'})
+2. After each persona contributes, after synthesis, and on decision: TaskUpdate(taskId, description='append: {persona_name}: {key_insight}' / 'Synthesis: {summary}' / 'Decision: {decision_record}')
+
+Continue storing outcomes in wicked-brain:memory (native task = process, brain memory = outcome).")
+```

package/commands/jam/council.md

@@ -0,0 +1,49 @@
+---
+description: Structured multi-model evaluation using external LLM CLIs for independent perspectives
+argument-hint: "<topic>" --options "A, B, C" [--criteria "perf, cost, risk"]
+phase_relevance: ["clarify", "design"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:jam:council
+
+Structured evaluation tool that uses real external LLM CLIs — registry-driven (20+ CLIs: Codex, Gemini, Copilot, OpenCode, Pi, Aider, Goose, Amp, Droid, …; see `scripts/jam/agentic_cli_registry.py`) — to get genuinely independent model perspectives. Installed CLIs are detected AND usability-probed via `scripts/jam/detect_clis.py --probe` (auth-revoked / unconfigured / daemon-down CLIs are excluded). When fewer than 2 usable external CLIs are present, council seats are filled with `Task()` subagents so deliberation always happens. Unlike brainstorm (free-form creative exploration), council is a **rigid evaluation tool** for when you have defined options and need a verdict.
+
+**Key distinction**: `quick` = 60s ideation, `brainstorm` = full session (generation/explore), `council` = structured evaluation (decide).
+
+> **Progression**: `quick` → `brainstorm` → `council` (this command, final step).
+> See also: `/wicked-garden:jam:quick`, `/wicked-garden:jam:brainstorm`
+
+Natural workflow: `brainstorm → identify candidates → council → decide`
+
+Delegate to the council agent:
+
+```
+Task(subagent_type="wicked-garden:jam:council",
+     prompt="Run a council evaluation on: {topic}. Options: {options}. Criteria: {criteria}.")
+```
+
+## Acting on the council verdict
+
+The council returns a synthesised verdict plus per-model raw votes. v11
+archetypes decide what to do with the result; the council itself does
+not gate. Heuristics for the caller:
+
+- **Unanimous APPROVE / REJECT with all confidences ≥ 0.7** — proceed with
+  the verdict.
+- **Split verdict (3-1 or closer) OR any confidence < 0.6** — surface the
+  raw votes to the user and pause for human adjudication. The disagreement
+  carries information that the synthesised verdict erases.
+- **High-stakes archetypes (`migrate`, `incident`, anything with
+  `hard:cutover` / `hard:mitigate`)** — always show the raw votes
+  alongside the verdict; never auto-proceed on a synth-only summary.
+
+A v6-era helper (deleted in v11.0.0) encoded these rules in code as part
+of the universal-pipeline machinery. v11 deleted the gate it fed into;
+the heuristics above are the same shape, applied inline by the agent.
+
+## Raw per-model votes (Issue #584)
+
+Default output now carries both the synthesised verdict AND a `raw_votes` list so callers can see per-model nuance even on unanimous verdicts. Assemble the envelope via `scripts/jam/consensus.py::build_council_output(votes, synthesized)` — it returns `{"synthesized": {...}, "raw_votes": [{"model", "verdict", "confidence", "rationale"}, ...]}` where each `rationale` is the model's own one-liner (or the first 240 chars of its response) and missing confidences stay `null`, not `0.0`.
+
+Operator override: `WG_COUNCIL_OUTPUT=both|synth|raw` (default `both`). Use `synth` for the legacy single-key shape; use `raw` when tooling only wants the unvarnished per-model layer.

package/commands/jam/quick.md

@@ -0,0 +1,21 @@
+---
+description: Quick exploration with fewer personas and one round
+argument-hint: "<idea or question>"
+phase_relevance: ["clarify", "design"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:jam:quick
+
+Quick 60-second exploration with 4 personas and 1 round.
+
+> **Progression**: `quick` (60s gut-check, ephemeral) → `brainstorm` (full session
+> with evidence + decision storage) → `council` (structured verdict with external LLMs).
+> See also: `/wicked-garden:jam:brainstorm`, `/wicked-garden:jam:council`
+
+## Run it inline (no dispatch)
+
+1. `Read("${CLAUDE_PLUGIN_ROOT}/skills/jam/refs/quick.md")` — the single-pass
+   rubric: 4 personas, 1 forced round, synthesis format (Key Insights / Action
+   Items / Open Questions), hard constraints (no storage, no multi-AI, ≤200 words).
+2. Apply the rubric directly to the topic. Do NOT run additional rounds. Do NOT store.

package/commands/jam/revisit.md

@@ -0,0 +1,79 @@
+---
+description: Revisit a past brainstorm decision and record its outcome
+argument-hint: "<topic or decision keyword>"
+phase_relevance: ["clarify", "design"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:jam:revisit
+
+Revisit a past brainstorm decision to record whether it was validated, invalidated, or modified.
+
+## Instructions
+
+### 1. Recall Past Decision
+
+Search for the decision via wicked-brain
+
+```
+Skill(
+  skill="wicked-brain:memory",
+  args="recall \"decisions tagged 'jam,decision' related to: {topic}\" --filter_type decision"
+)
+```
+
+If no matching decision found, inform the user and suggest running `/wicked-garden:jam:brainstorm` first.
+
+### 2. Display Decision Summary
+
+Show the user what was decided:
+
+```markdown
+## Past Decision: {topic}
+
+**Decided**: {chosen option}
+**When**: {date}
+**Confidence**: {HIGH/MEDIUM/LOW}
+**Rationale**: {key reasoning}
+**Alternatives considered**: {other options}
+**Personas involved**: {list}
+```
+
+### 3. Ask for Outcome
+
+Ask the user:
+
+```markdown
+How did this decision work out?
+
+1. **Validated** — The decision was correct and worked well
+2. **Invalidated** — The decision was wrong, we had to change course
+3. **Modified** — The decision was partially right but needed adjustment
+```
+
+### 4. Record Outcome
+
+Store the outcome in wicked-brain:memory
+
+```
+wicked-brain:memory "Outcome: {topic}\nOriginal decision: {chosen}\nResult: {validated/invalidated/modified}\nReason: {user's explanation}\nLessons: {what we learned}"
+  --type decision
+  --tags jam,outcome,{topic-keywords}
+  --importance high
+```
+
+### 5. Report
+
+```markdown
+## Outcome Recorded
+
+**Decision**: {topic}
+**Result**: {validated/invalidated/modified}
+**Lesson**: {what was learned}
+
+This outcome will be surfaced in future brainstorms on similar topics.
+```
+
+## Graceful Degradation
+
+Without wicked-brain: display a message that decision revisit requires wicked-brain for decision storage. Suggest the user install the wicked-brain plugin for full decision lifecycle tracking.

package/commands/persona/as.md

@@ -0,0 +1,136 @@
+---
+description: Invoke a named persona to perform a task with a specific perspective
+argument-hint: "<persona-name> <task description>"
+phase_relevance: ["*"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:persona:as
+
+Invoke a named persona to apply their perspective to any task.
+
+## Arguments
+
+Parse from: $ARGUMENTS
+
+- `persona_name` (required): First word — the persona to invoke
+- `task` (required): Everything after the persona name — the task to perform
+
+If $ARGUMENTS is empty or contains only one word (no task), show usage and STOP:
+
+> "Usage: /wicked-garden:persona:as <persona-name> <task description>"
+> "Example: /wicked-garden:persona:as engineering 'review my auth flow'"
+
+## Execution
+
+### Step 1: Parse arguments
+
+Split $ARGUMENTS on the first space:
+- `persona_name` = first token
+- `task` = remaining text
+
+### Step 2: Look up the persona
+
+Run the registry script to resolve the persona definition:
+
+```bash
+PERSONA_JSON=$(sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" \
+  "${CLAUDE_PLUGIN_ROOT}/scripts/_run.py" \
+  scripts/persona/registry.py --get "${persona_name}" --json 2>/dev/null)
+REGISTRY_EXIT=$?
+```
+
+### Step 3: Handle lookup failure
+
+If the script exits non-zero or PERSONA_JSON is empty or contains `"error"`:
+
+1. Run the list command to get available personas:
+
+```bash
+AVAILABLE=$(sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" \
+  "${CLAUDE_PLUGIN_ROOT}/scripts/_run.py" \
+  scripts/persona/registry.py --list --json 2>/dev/null)
+```
+
+2. Show the user:
+
+> "No persona found named '{persona_name}'. Available personas:"
+
+3. List each available persona name with its description (name — description).
+
+4. **STOP** — do not dispatch a Task.
+
+### Step 4: Extract persona fields
+
+From PERSONA_JSON, extract:
+- `name`
+- `description`
+- `focus`
+- `traits` (list — format as bullet list, e.g. `- direct\n- pragmatic`)
+- `personality` (object with style, temperament, humor)
+- `constraints` (list — format as numbered list)
+- `not_focus` (list — scope guard; concerns this persona does NOT own. Format as bullet list)
+- `memories` (list — format as bullet list)
+- `preferences` (object with communication, code_style, review_focus, decision_making)
+
+If traits is empty, use: "No specific traits defined — apply the focus broadly."
+If personality is empty, use: "Apply the focus in a direct and professional style."
+If constraints is empty, use: "No hard constraints — use your judgment."
+If not_focus is empty, omit the "NOT Your Focus" section entirely (do not invent boundaries).
+If memories is empty, use: "No specific experiences — draw on your focus."
+If preferences is empty, use: "No specific preferences — communicate clearly and directly."
+
+### Step 5: Dispatch to persona-agent
+
+```python
+Task(
+    subagent_type="wicked-garden:persona:persona-agent",
+    prompt="""You are **{name}**.
+
+## Your Identity
+
+{description}
+
+## Your Focus
+
+{focus}
+
+## Your Traits
+
+{traits_as_bullets}
+
+## Your Personality
+
+- **Style**: {personality.style}
+- **Temperament**: {personality.temperament}
+- **Voice**: {personality.humor}
+
+## Your Constraints (MUST follow)
+
+{constraints_as_numbered_list}
+
+## NOT Your Focus (hand off, do not deep-dive)
+
+{not_focus_as_bullet_list}
+
+## Your Experience
+
+{memories_as_bullet_list}
+
+## Your Preferences
+
+- **Communication**: {preferences.communication}
+- **Code style**: {preferences.code_style}
+- **Review focus**: {preferences.review_focus}
+- **Decision making**: {preferences.decision_making}
+
+## Task
+
+{task}
+
+Respond fully in character as {name}. Open your response with `## {name}` and
+a one-line focus statement. Then deliver the task output from this persona's
+perspective, honoring all constraints and preferences above.
+"""
+)
+```

package/commands/persona/define.md

@@ -0,0 +1,24 @@
+---
+description: Create or update a custom persona for on-demand invocation
+argument-hint: "<name> --focus \"<focus>\" [--traits \"t1,t2\"] [--constraints \"FAILURE MODE — x: ...; ...\"] [--not-focus \"a; b\"] [--role <role>] [--save]"
+phase_relevance: ["*"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:persona:define
+
+Create or update a custom persona definition — the mechanism that lets an
+enterprise inject ITS house personas. Stored in project-scoped DomainStore by
+default. Use `--save` to also promote to the plugin-level cache for cross-project reuse.
+
+A persona only earns its keep if it encodes something the base model does NOT
+already supply: a **named failure-mode defense**, a **hard constraint**, or a
+**scope guard**. A persona that only restates a role ("act like a senior X") adds
+little durable value. The rubric below shows the GOOD pattern.
+
+## Run it inline (no dispatch)
+
+1. `Read("${CLAUDE_PLUGIN_ROOT}/skills/persona/refs/define.md")` — the rubric:
+   argument parsing + validation, DomainStore script call, optional cache-save,
+   and confirm output.
+2. Apply the rubric directly using `$ARGUMENTS`.

package/commands/persona/list.md

@@ -0,0 +1,118 @@
+---
+description: List all available personas with their focus and invocation syntax
+argument-hint: "[--role <role>]"
+phase_relevance: ["*"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:persona:list
+
+Discover all available personas — built-in specialists, custom personas, and cached personas.
+
+## Arguments
+
+Parse from: $ARGUMENTS
+
+- `--role` (optional): Filter by role category (e.g., engineering, devsecops, product, quality-engineering)
+
+## Execution
+
+### Step 1: Fetch persona list
+
+Build the command with optional role filter:
+
+```bash
+sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" \
+  "${CLAUDE_PLUGIN_ROOT}/scripts/_run.py" \
+  scripts/persona/registry.py --list [--role "${role}"] --json
+```
+
+If `--role` is present in $ARGUMENTS, include `--role <value>` in the command.
+
+### Step 2: Format output
+
+Present the front door first, then personas grouped by **value tier**, not just by
+source. Each row MUST include the exact invocation command so no separate
+documentation lookup is needed.
+
+**Front door (always show first):**
+
+```markdown
+## Personas
+
+The high-leverage move is your OWN house persona that encodes a failure-mode
+defense. Start here:
+
+- Define one: `/wicked-garden:persona:define <name> --focus "<focus>" --constraints "FAILURE MODE — …"`
+- Then invoke: `/wicked-garden:persona:as <name> <task>`
+```
+
+**Value tiers.** A persona is **Methodology** if its registry record carries a
+non-empty `constraints` list (it defends a named failure mode / hard constraint).
+Otherwise it is **Generic** (a role restatement the base model largely already
+supplies). Compute this from the `constraints` field returned by the registry;
+do not hardcode the split.
+
+The curated built-in surface is intentionally **small**: only the three
+methodology exemplars below carry rich profiles. A blinded lift eval
+(`tests/persona/EVAL_RESULTS.md`, 2026-06-12) found the built-in personas
+produce **lift=0** vs the base model, so the generic role personas were demoted
+to **thin role records** — still invokable, but with no curated constraints (the
+base model already plays those roles). The real product is `persona:define`.
+
+```markdown
+### Methodology personas (carry a failure-mode defense — prefer these)
+| Name | Focus | Invoke |
+|------|-------|--------|
+| platform | Security, blast radius, secret handling... | `/wicked-garden:persona:as platform <task>` |
+| qe | Test value, recovery paths, anti-happy-path... | `/wicked-garden:persona:as qe <task>` |
+| agentic | Agent safety, termination, idempotency... | `/wicked-garden:persona:as agentic <task>` |
+
+### Generic personas (thin role lens — base model already plays these)
+<details><summary>Show generic role names (no curated constraints — define your own for lift)</summary>
+
+These names still resolve (engineering, product, data, jam) but carry no curated
+profile — they apply the role as a plain lens. For durable value, define a HOUSE
+persona instead. Any unlisted role name falls back gracefully (`persona:as`
+lists what's available rather than crashing).
+
+| Name | Focus | Invoke |
+|------|-------|--------|
+| engineering | Code quality, architecture... | `/wicked-garden:persona:as engineering <task>` |
+| product | Requirements, UX, business value... | `/wicked-garden:persona:as product <task>` |
+| data | Pipelines, ML guidance, analytics... | `/wicked-garden:persona:as data <task>` |
+| jam | Ideation, multi-perspective... | `/wicked-garden:persona:as jam <task>` |
+</details>
+
+### Custom Personas
+| Name | Focus | Invoke |
+|------|-------|--------|
+| pragmatic-tech-lead | Delivery over perfection | `/wicked-garden:persona:as pragmatic-tech-lead <task>` |
+
+### Cached Personas (cross-project)
+| Name | Focus | Invoke |
+|------|-------|--------|
+| my-persona | Shared focus | `/wicked-garden:persona:as my-persona <task>` |
+```
+
+Rules:
+- **Tier split is data-driven**: a persona with a non-empty `constraints` list is
+  Methodology; one with an empty `constraints` list is Generic. Custom personas
+  follow the same rule.
+- Generic, custom, and cached sections render inside a `<details>` block (collapsed)
+  so the methodology tier and the define front door are what the user sees first.
+- Truncate the focus/description column at 60 characters if needed (add "...")
+- Only show sections that have personas (omit Custom and Cached sections if empty)
+- If `--role` was specified and returns zero results, show: "No personas found with role '{role}'."
+- Fallback personas (architect, skeptic, advocate) are shown in a "### Fallback Personas" section when specialist.json is unavailable. `skeptic` is Methodology (it carries constraints); `architect` and `advocate` are Generic.
+
+### Step 3: Show tip
+
+After the table(s), add:
+
+```
+**Tip:** The highest-leverage persona is your own — one that encodes a house
+failure-mode defense the base model won't volunteer:
+`/wicked-garden:persona:define <name> --focus "<focus>" --constraints "FAILURE MODE — …" --not-focus "…"`.
+Use `/wicked-garden:engineering:review --persona <name>` to route a code review through any persona's lens.
+```

package/commands/platform/actions.md

@@ -0,0 +1,20 @@
+---
+description: GitHub Actions workflow generation and optimization
+argument-hint: "<generate|optimize|troubleshoot> [workflow file]"
+phase_relevance: ["build", "review", "operate"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:platform:actions
+
+Generate, optimize, and troubleshoot GitHub Actions workflows.
+
+## Run it inline (no dispatch)
+
+1. Parse `<mode>` from `$ARGUMENTS`: `generate`, `optimize`, or `troubleshoot`.
+2. `Read("${CLAUDE_PLUGIN_ROOT}/skills/platform/actions/refs/actions.md")` — workflow rubric,
+   security/performance checklists, stack detection, and output format.
+3. Apply the rubric directly:
+   - **generate**: detect project stack (`ls package.json pyproject.toml ...`), produce complete workflow YAML.
+   - **optimize**: read the target workflow file, apply the optimization checklist, return annotated diff.
+   - **troubleshoot**: run `gh run list --status failure --limit 1`, fetch logs, diagnose root cause inline.