@codename_inc/spectre 3.7.0

package/plugins/spectre/commands/fix.md

@@ -0,0 +1,61 @@
+---
+description: Investigate bugs & implement fixes - primary agent
+---
+# fix: Analyze bug and recommend fix
+
+## Description
+
+- **What** — Hypothesize root causes, investigate in parallel, recommend fix with logging
+- **Outcome** — Root cause identified, solution recommendation with `[🪳 TEMP]` debug logging
+
+## Variables
+
+### Dynamic Variables
+
+- `bug_report`: Error details, repro steps, context — (via ARGUMENTS: $ARGUMENTS)
+
+### Static Variables
+
+- `debug_prefix`: \[🪳 TEMP {TOPIC}\]
+
+## ARGUMENTS Input
+
+<ARGUMENTS> $ARGUMENTS </ARGUMENTS>
+
+## Step (1/5) - Gather Bug Context
+
+- **Action** — CheckInput: Verify bug report provided
+  - **If**: ARGUMENTS empty
+  - **Then**: Ask user for error message, repro steps, and relevant context
+  - **Else**: Use ARGUMENTS as bug report; request missing details if needed
+- **Wait** — Bug report with error details and repro steps
+
+## Step (2/5) - Generate Hypotheses
+
+- **Action** — Brainstorm: Reflect on 5-7 possible sources of the problem
+- **Action** — Prioritize: Distill to 1-2 most likely root causes
+  - Consider: the primary data flow for this component/module, recent changes, error patterns, stack traces, affected code paths
+
+## Step (3/5) - Investigate in Parallel
+
+- **Action** — DispatchAgents: Spawn parallel `@spectre:analyst` subagents to investigate top hypotheses
+  - Each agent gets one hypothesis to trace through codebase
+  - Agents search for: relevant code, recent commits, similar patterns, edge cases
+
+## Step (4/5) - Summarize Findings
+
+- **Action** — Synthesize: Summarize findings and solution recommendation
+  - Include: root cause, affected files, proposed fix approach
+  - **Rule**: Solution must include `{debug_prefix}` logging to verify fix and gather data if fix fails
+- **Action** — HoldForApproval: Present analysis; do NOT write code yet
+  - **Wait** — User approval before implementing fix
+
+## Step (5/5) - Execute
+
+- **Action** — Load TDD Skill: Load @spectre:spectre-tdd SKILL to use TDD
+- **Action** — Execute Fix: Add Logs and Implement Fix using TDD
+- **Action** — When finished, summarize what you delivered, including providing specific steps for the user to validate.
+
+## Next Steps
+
+Use the spectre-guide Skills and render the Next Steps Footer per the skill guidance

package/plugins/spectre/commands/forget.md

@@ -0,0 +1,58 @@
+---
+description: Clear session memory - archive all session files so next session starts fresh
+---
+
+# forget: Clear Session Memory
+
+## Description
+- **What** — Archive all session files (handoffs, todos, history) so the SessionStart hook doesn't auto-resume
+- **Outcome** — All session files moved to archive, user informed to start fresh session
+
+## Step (1/2) - Archive Session Logs
+
+- **Action** — ArchiveLogs: Move session logs to archive directory
+
+```bash
+branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo unknown)
+session_dir="docs/tasks/${branch}/session_logs"
+archive_dir="${session_dir}/archive"
+
+# Check if session logs exist
+if [ ! -d "$session_dir" ] || [ -z "$(ls -A ${session_dir}/*.json 2>/dev/null)" ]; then
+    echo "NO_SESSIONS"
+    exit 0
+fi
+
+# Create archive and move all session files
+mkdir -p "$archive_dir"
+mv ${session_dir}/*_handoff.json "$archive_dir/" 2>/dev/null || true
+mv ${session_dir}/*_todos.json "$archive_dir/" 2>/dev/null || true
+mv ${session_dir}/todos_history.json "$archive_dir/" 2>/dev/null || true
+
+# Count archived
+archived_count=$(ls -1 ${archive_dir}/*_handoff.json 2>/dev/null | wc -l | xargs)
+echo "ARCHIVED:${archived_count}"
+```
+
+## Step (2/2) - Confirm to User
+
+- **Action** — ConfirmCleared: Based on bash output, inform user
+
+  **If** output is `NO_SESSIONS`:
+  > No session logs found for this branch. Memory is already clear.
+
+  **Else** (output is `ARCHIVED:N`):
+  > ✓ Session memory cleared
+  >
+  > Archived {N} handoff file(s) to `docs/tasks/{branch}/session_logs/archive/`
+  >
+  > **Next**: Start a new session with `/clear` or close this terminal. Your next session will start fresh without auto-loaded context.
+
+## Success Criteria
+
+- [ ] Session logs directory checked for existence
+- [ ] All `*_handoff.json` files moved to `archive/` subdirectory
+- [ ] All `*_todos.json` files moved to `archive/` subdirectory
+- [ ] `todos_history.json` moved to `archive/` subdirectory
+- [ ] User informed of result (no sessions found OR count archived)
+- [ ] Clear instructions provided for starting fresh session

package/plugins/spectre/commands/handoff.md

@@ -0,0 +1,161 @@
+---
+description: Save state snapshot to session_logs for session resume
+---
+
+# handoff: Fast Session State Snapshot
+
+Generate progress update, gather context, output structured JSON for session resume. Output: `{timestamp}_handoff.json` in session_logs.
+
+**Performance Target**: 2-3 tool calls depending on session history
+
+**CRITICAL**: Do not narrate or explain what you're doing. No "Session count is 0, so..." or "Let me gather context...". Just execute the steps silently and output ONLY the final confirmation message. Every token matters at end of session.
+
+## ARGUMENTS
+
+<ARGUMENTS>
+$ARGUMENTS
+</ARGUMENTS>
+
+## Step 1: Gather Context (Single Bash Call)
+
+- **Action** — GatherContext: Run ONE bash command:
+
+```bash
+branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo unknown)
+mkdir -p "docs/tasks/${branch}/session_logs"
+
+# Count existing session logs for conditional flow
+session_count=$(ls docs/tasks/${branch}/session_logs/*_handoff.json 2>/dev/null | wc -l | xargs)
+
+beads_available=false
+beads_tasks='[]'
+beads_count=0
+
+if command -v bd &>/dev/null && bd doctor &>/dev/null; then
+  beads_available=true
+  open=$(bd list --label "$branch" --status open --json 2>/dev/null || echo '[]')
+  in_prog=$(bd list --label "$branch" --status in_progress --json 2>/dev/null || echo '[]')
+  blocked=$(bd list --label "$branch" --status blocked --json 2>/dev/null || echo '[]')
+  beads_tasks=$(echo "$open $in_prog $blocked" | jq -s 'add // []')
+  beads_count=$(echo "$beads_tasks" | jq 'length' 2>/dev/null || echo 0)
+fi
+
+cat << EOF
+{
+  "branch": "$branch",
+  "commit": "$(git rev-parse --short HEAD 2>/dev/null || echo unknown)",
+  "wip_count": $(git status --porcelain 2>/dev/null | wc -l | xargs),
+  "ts": "$(date +%Y-%m-%d-%H%M%S)",
+  "session_count": $session_count,
+  "beads_available": $beads_available,
+  "beads_count": $beads_count,
+  "beads": $beads_tasks
+}
+EOF
+```
+
+**Output**: JSON with branch, commit, wip_count, ts, session_count, beads_available, beads_count, beads[]
+
+## Step 2: Compose Handoff Data
+
+- **Action** — ComposeProgressUpdate: From session memory, compose using "WE" voice:
+
+  | Field | Required | Description |
+  |-------|----------|-------------|
+  | summary | ✓ | Slack-style paragraph a human would read |
+  | goal | ✓ | What we're building + success criteria |
+  | accomplished | ✓ | What we completed (2-5 bullets) |
+  | now | ✓ | **What you were actively working on when session ended** (critical!) |
+  | next_steps | ✓ | Upcoming work (2-4 bullets) |
+  | confidence | ✓ | high / medium / low |
+  | constraints | | Known constraints or assumptions |
+  | decisions | | Key decisions made (0-3 bullets) |
+  | blockers | | Things blocking progress |
+  | open_questions | | Questions needing answers |
+  | risks | | Identified risks |
+
+  **Tone**: "We finished the auth refactor and got tests passing. Hit a snag with OAuth callback - next we'll tackle session management."
+
+- **Action** — BuildWorkingSet: Capture active context:
+  - `key_files`: Files actively edited
+  - `active_ids`: Beads task IDs in progress
+  - `recent_commands`: Recent terminal commands (test, build, etc.)
+
+- **Action** — BuildBeadsTree (if available): From beads array, build hierarchy (epic → tasks → subtasks). Include task IDs for resume.
+
+## Step 3: Conditional Write
+
+Check `session_count` from Step 1:
+
+### If session_count = 0 (First Session)
+
+**Do not narrate. Just write the file and output the confirmation.**
+
+Write directly to `docs/tasks/{branch}/session_logs/{ts}_handoff.json`
+
+**JSON Schema**:
+```json
+{
+  "version": "1.1",
+  "timestamp": "{ts}",
+  "branch_name": "{branch}",
+  "task_name": "{ARGUMENTS or branch}",
+  "session_number": 1,
+  "progress_update": {
+    "summary": "string",
+    "goal": "string",
+    "accomplished": ["string"],
+    "now": "string (critical for resume)",
+    "next_steps": ["string"],
+    "confidence": "high|medium|low",
+    "constraints": ["string"],
+    "decisions": ["string"],
+    "blockers": ["string"],
+    "open_questions": ["string"],
+    "risks": ["string"]
+  },
+  "working_set": {
+    "key_files": ["path"],
+    "active_ids": ["bd-xxxxx"],
+    "recent_commands": ["command"]
+  },
+  "beads": {  // OMIT ENTIRE SECTION if beads_available=false OR beads_count=0
+    "available": true,
+    "workspace_label": "{branch}",
+    "task_count": "number",
+    "epic_id": "bd-xxxxx|null",
+    "epic_title": "string|null",
+    "tasks": [{"id", "title", "status", "type", "parent", "children", "labels"}]
+  },
+  "context": {
+    "wip_state": "uncommitted|clean",
+    "last_commit": "abc1234"
+  }
+}
+```
+
+Then respond: "✓ Handoff saved: {path}. First session recorded. Next session auto-resumes from this context."
+
+### If session_count >= 1 (Continuation)
+
+**Do not narrate. Just spawn the subagent and output the confirmation when done.**
+
+Spawn `@sesh:sync` subagent with the composed data:
+
+```
+<current_session>
+{full JSON object you composed above}
+</current_session>
+
+<session_logs_path>
+docs/tasks/{branch}/session_logs
+</session_logs_path>
+```
+
+The sync agent will:
+1. Read up to 3 previous handoff.json files
+2. Synthesize current context with historical arc
+3. Write the final `{ts}_handoff.json` with enriched continuity
+4. Return the file path
+
+Then respond: "✓ Handoff saved: {path}. Session {n} recorded with continuity from {x} previous sessions. Next session auto-resumes from this context."

package/plugins/spectre/commands/kickoff.md

@@ -0,0 +1,115 @@
+---
+description: 👻 | Project kickoff with deep research & MVP pathfinding - primary agent
+---
+
+# kickoff: Deep Codebase Research + MVP Path Discovery
+
+Comprehensive codebase research, external best practices, and MVP implementation path with file:line evidence. Output: kickoff document with architecture insights, gap analysis, and implementation options saved to `docs/tasks/{task_name}/kickoff/`.
+
+## ARGUMENTS
+
+<ARGUMENTS>
+$ARGUMENTS
+</ARGUMENTS>
+
+## Step 1: Acknowledge & Clarify
+
+- **Action** — ImmediateReply: Respond before any tools.
+  - **If** ARGUMENTS → acknowledge context, identify: what we're exploring, what decision we're heading toward, what success looks like
+  - **Else** → prompt for project context
+  - **CRITICAL**: No tool calls in this step
+
+## Step 2: Gather Context & Decompose
+
+- **Action** — ReadMentionedDocs: Read referenced docs FULLY in main context (not subagent). Extract: vision, constraints, decisions made, open questions.
+- **Action** — DecomposeResearchAreas: Break project into research areas. Consider: components to investigate, directories/files, architectural patterns, data flows, existing code to extend.
+- **Action** — CreateResearchPlan: Use TodoWrite to track research subtasks.
+
+## Step 3: Deep Parallel Research
+
+- **Action** — SpawnResearchAgents: Launch parallel agents for comprehensive context.
+
+| Agent | Task | Required Output |
+|-------|------|-----------------|
+| @finder | Find relevant files, entry points, handlers, models | File paths by domain |
+| @analyst | Trace data flow, dependencies, behavior, edge cases | file:line refs for ALL findings |
+| @patterns | Find similar implementations, patterns to follow/avoid | Code examples with file:line |
+| @web-research | Best practices, similar solutions, pitfalls | Findings WITH LINKS |
+
+**Strategy**: locator → analyzer on findings → parallel for breadth. Spawn follow-ups if shallow. Demand file:line evidence.
+
+**3rd Party Libs**: Use Context7 MCP for central libraries.
+
+- **Action** — WaitForAgents: ALL agents must complete before synthesis. Update TodoWrite as each completes.
+
+## Step 4: Synthesize Understanding
+
+- **Action** — CompileFindings: Synthesize with file:line refs throughout.
+  - Codebase: Connect findings across components, document data flow, answer "how does codebase handle [area]?"
+  - Architecture: Patterns to follow (with examples), conventions, constraints, reuse vs build new
+  - External: Industry patterns (with links), best practices, pitfalls
+
+- **Action** — PerformGapAnalysis: Current capabilities (with file refs) vs required capabilities. What's missing vs needs modification.
+
+- **Action** — IdentifyMVPAndOptions:
+  - MVP: Core value, minimum for value, what to defer (informed by codebase complexity)
+  - Options: 2-3 approaches with: summary, key decisions, code to leverage (file refs), new work, effort sense, trade-offs
+  - Decision points: Architecture, scope, technology, integration, patterns
+
+## Step 5: Generate Document
+
+- **Action** — DetermineOutputDir:
+  - Derive `task_name` from context (kebab-case)
+  - `OUT_DIR = user_specified || docs/tasks/{task_name}/kickoff`
+  - `mkdir -p "$OUT_DIR"`
+
+- **Action** — CreateDocument: Structure with YAML frontmatter (date, git_commit, branch, repo, topic, tags, status).
+
+  **Sections**: Title → Metadata → Project Context → Research Summary → Detailed Codebase Findings (by area, file:line refs, code snippets) → Code References (table) → Architecture Insights (patterns, conventions, constraints) → External Research (with links) → Gap Analysis → MVP Suggestion → Implementation Options (2-3 with trade-offs) → Decision Points → Open Questions → Related Resources
+
+- **Action** — AddGitHubPermalinks: If on main/pushed, convert file refs to `https://github.com/{owner}/{repo}/blob/{commit}/{file}#L{line}`
+
+- **Action** — SaveDocument: Save as `{task_name}_kickoff.md` (timestamp variant if exists). **CRITICAL**: Save before Step 6.
+
+## Step 6: Present & Scope
+
+- **Action** — PresentSummary:
+  > **Kickoff Complete** — saved to `{path}`
+  >
+  > **Vision**: [1-2 sentences]
+  > **What Exists**: [key components with file:line refs]
+  > **Architecture Insights**: [patterns, conventions, constraints]
+  > **External Learnings**: [key insights with links]
+  > **Gap**: [have → need]
+  > **MVP Path**: [smallest valuable slice]
+  >
+  > **Scoping Questions** (before planning):
+  > 1. [Scope/boundary question] — Option A (leverages `code:line`) vs Option B
+  > 2. [Technical approach] — suggested vs alternative
+  > 3. [Priority/constraint question]
+
+- **Action** — EngageInScoping: Wait for response, ask follow-ups. No planning until ambiguities resolved. Research answerable questions instead of asking.
+
+## Step 7: Handle Follow-ups
+
+- **Action** — HandleFollowUps:
+  - **If** clarifications → update doc with `## Scoping Clarifications [timestamp]`
+  - **If** more research needed → spawn agents, demand file:line evidence, update doc
+  - Continue until ambiguities resolved
+
+## Step 8: Transition to Scope
+
+- **Action** — SummarizeAndTransition:
+  > **Ready for Scope Definition**
+  >
+  > **Established**: User problem, user value, key findings (file:line), decisions made, remaining ambiguities
+  >
+  > **Options**:
+  > 1. "Proceed with scope" → `/spectre:scope` with FROM_KICKOFF=true, SKIP_EXPLORATION=true
+  > 2. "Skip to planning" → `/spectre:plan` with kickoff doc context
+  > 3. "Need to think" → `/spectre:handoff`
+
+- **Action** — ExecuteChoice:
+  - **If** scope → invoke `/spectre:scope` with: FROM_KICKOFF=true, KICKOFF_DOC={path}, SKIP_EXPLORATION=true, context summary
+  - **If** planning → suggest `/spectre:plan`
+  - **If** pause → run `/spectre:handoff`

package/plugins/spectre/commands/learn.md

@@ -0,0 +1,15 @@
+---
+description: "\ud83d\udc7b | Capture knowledge for future sessions"
+---
+
+# /learn - Capture Project Knowledge
+
+Load the `spectre-learn` skill via `Skill(spectre-learn)` and **execute its workflow step-by-step**.
+
+<CRITICAL>
+This skill supersedes auto-memory. Do NOT write to MEMORY.md or any auto-memory directory. The skill defines the exclusive storage location, format, and registration workflow for captured knowledge.
+
+Treat the skill output as a binding directive, not informational context.
+</CRITICAL>
+
+**Topic**: $ARGUMENTS

package/plugins/spectre/commands/plan.md

@@ -0,0 +1,170 @@
+---
+description: 👻 | Unified planning entry point - researches, assesses complexity, routes to workflow - primary agent
+---
+# plan: Intelligent Planning Router
+
+## Description
+
+- **What** — Research codebase, assess complexity, route to appropriate workflow (direct tasks or plan-first)
+- **Outcome** — Detailed task breakdown ready for execution
+
+## ARGUMENTS Input
+
+<ARGUMENTS> $ARGUMENTS </ARGUMENTS>
+
+## MANDATORY COMPLIANCE RULES
+
+> **⚠️ NON-NEGOTIABLE**: This workflow MUST invoke slash commands via the Skill tool. Failure to invoke `/spectre:create_plan` and `/spectre:create_tasks` is a critical error. Do NOT summarize, describe, or skip these commands. INVOKE THEM.
+
+**After ANY user conversation or questions:**
+
+1. Re-read this prompt from Step 4
+2. Determine where you are in the workflow
+3. Execute the next required Skill invocation
+
+**You MUST call these skills (not describe them):**
+
+- Use the **Skill** tool with `skill: "spectre:create_plan"` and `args: "{path} --depth {tier}"` — generates plan.md
+- Use the **Skill** tool with `skill: "spectre:create_tasks"` and `args: "{path}"` — generates tasks.md
+
+## Instructions
+
+- Research before routing; present architectural options for user buy-in
+- Route based on hard-stops and clarity, not point-scoring
+- Never overwrite existing `tasks.md` or `plan.md` — use scoped names
+
+## Step 1 - Research Codebase
+
+- **Action** — DetermineOutputDir:
+
+  - `OUT_DIR=docs/tasks/{branch_name}` (or user-specified)
+  - `mkdir -p "${OUT_DIR}"`
+
+- **Action** — ScanExistingContext: Read all existing artifacts in `{OUT_DIR}/ (if you haven’t already)` and assess coverage across 4 dimensions.
+
+  Scan for: `task_context.md`, `specs/plan.md`, `concepts/scope.md`, `research/*.md`
+
+  | Dimension | Covered if artifact contains... | Covered by |
+  | --- | --- | --- |
+  | **File locations** | Specific file paths relevant to this feature, entry points, config files | `@finder` |
+  | **Code understanding** | Data flow analysis, dependency tracing, how current code works with file:line refs | `@analyst` |
+  | **Codebase patterns** | Similar implementations found in codebase, reusable components, naming/style conventions | `@patterns` |
+  | **External research** | Best practices, libraries/frameworks, prior art, common pitfalls with source links | `@web-research` |
+
+  For each dimension, assess: **covered** (artifact has substantive findings for this feature) or **gap** (missing, superficial, or about a different feature).
+
+- **Action** — DispatchResearch: Spawn agents **only for dimensions marked as gaps**. Skip agents whose dimensions are already covered. Each prompt must include the feature/problem description from ARGUMENTS so the agent has full context.
+
+  - **If all 4 covered** → skip to SaveResearch (merge existing findings into task_context.md if scattered across files)
+
+  - **If gaps exist** → spawn only the needed agents in parallel:
+
+  - `@finder` *(if File locations = gap)* — "Find all files, components, entry points, routes, and configuration related to \[feature/problem\]. Include: (1) files that would need to be modified or extended, (2) entry points where this feature connects to the system (routes, handlers, event listeners, CLI commands), (3) configuration files, schemas, or migrations that may be affected, (4) test files covering the affected areas. Return file paths organized by relevance."
+
+  - `@analyst` *(if Code understanding = gap)* — "Analyze how the code paths related to \[feature/problem\] work end-to-end. Trace: (1) data flow from input through processing to storage and output, (2) key dependencies and how components interact, (3) state management patterns and data access methods in the affected areas, (4) error handling and edge cases in the current implementation. Return findings with specific file:line references."
+
+  - `@patterns` *(if Codebase patterns = gap)* — "Find existing implementations in this codebase that are similar to \[feature/problem\] and could serve as a reference. Look for: (1) analogous features already built — how were they structured?, (2) reusable components, utilities, or abstractions we should leverage, (3) conventions for naming, file organization, and code style in this area, (4) testing patterns used for similar features. Return concrete code examples with file:line references."
+
+  - `@web-research` *(if External research = gap)* — "Research best practices, proven patterns, relevant libraries/frameworks, and how other projects solve \[feature/problem\]. Focus on: (1) industry best practices and common pitfalls, (2) libraries or frameworks that simplify this work, (3) how well-known open-source projects approach similar problems, (4) architectural patterns recommended for this type of feature. Return findings with source links."
+
+  - **Wait** for all dispatched agents; read identified files
+
+- **Action** — SaveResearch: Merge all findings (existing artifacts + new agent results) into `{OUT_DIR}/task_context.md` with sections: Architecture Patterns, Dependencies, Implementation Approaches, Impact Summary, and External Research (best practices, recommended libraries/frameworks, prior art, common pitfalls)
+
+## Step 2 - Present Architectural Options
+
+- **Action** — PresentOptions: 2-4 strategies (simplest to most robust)
+  - Each: core approach, trade-offs, when it makes sense
+- **Wait** — User selects strategy
+- **Action** — UpdateContext: Document selection in task_context.md
+
+> **CHECKPOINT**: After architecture discussion, proceed IMMEDIATELY to Step 3. Do NOT end turn without continuing the workflow.
+
+## Step 3 - Assess Complexity
+
+Use research findings from Step 1 to determine appropriate planning depth.
+
+- **Action** — AssessFromResearch: Score complexity signals from research:
+
+  | Signal | Source | Assessment |
+  | --- | --- | --- |
+  | Files impacted | @finder | 1-3 files = Low, 4-8 = Med, 9+ = High |
+  | Pattern match | @patterns | Clear existing pattern = Low, Adapt pattern = Med, New pattern = High |
+  | Components crossed | @analyst | 1 component = Low, 2-3 = Med, 4+ = High |
+  | Data model changes | Research findings | None = Low, Modify existing = Med, New models/schema = High |
+  | Integration points | Research findings | Internal only = Low, 1-2 external = Med, 3+ external = High |
+  | External complexity | @web-research | Well-documented with libraries = Low, Some prior art = Med, Novel/emerging = High |
+
+- **Action** — CheckHardStops: Any true = automatic COMPREHENSIVE | db_schema_destructive | new_service_or_component | auth_or_pii_change | | payment_billing_logic | public_api_change | caching_consistency | slo_sla_risk |
+
+- **Action** — DetermineTier:
+
+  - **LIGHT**: All/most Low signals, single component, clear pattern match, no hard-stops
+  - **STANDARD**: Mix of Low/Med signals, multi-file but contained scope, no hard-stops
+  - **COMPREHENSIVE**: Any High signal, multiple Med signals, or any hard-stop triggered
+
+- **Action** — LogTier: Note the assessed tier in your response for transparency, then proceed immediately to Step 4. Do NOT ask for confirmation.
+
+> **CHECKPOINT**: After determining tier, proceed IMMEDIATELY to Step 4. The ONLY valid next action is invoking a Skill. Do NOT end turn here. Do NOT ask user to confirm the tier.
+
+## Step 4 - Route to Workflow
+
+### ⛔ MANDATORY SKILL INVOCATION ⛔
+
+```plaintext
+┌────────────────────────────────────────────────────────────────────────┐
+│  YOU MUST USE THE SKILL TOOL TO INVOKE THESE COMMANDS                  │
+│                                                                        │
+│  ❌ WRONG: "I'll now create the plan..."                               │
+│  ❌ WRONG: "The next step would be to run /spectre:create_plan"        │
+│  ❌ WRONG: Ending turn without invoking Skill tool                     │
+│                                                                        │
+│  ✅ CORRECT: Skill tool with skill: "spectre:create_plan", args: "..." │
+│  ✅ CORRECT: Skill tool with skill: "spectre:create_tasks", args: "..."│
+└────────────────────────────────────────────────────────────────────────┘
+```
+
+**DO NOT:**
+
+- Say you’ll create a plan or set of tasks yourself without running the skill tool
+- Describe what you would do
+- Summarize the plan/task steps yourself
+- End your turn without invoking Skill
+- Write plan.md or tasks.md content directly
+
+**YOU MUST:**
+
+- Use the Skill tool: `skill: "spectre:create_plan"`, `args: "{OUT_DIR}/task_context.md --depth {tier}"`
+- Use the Skill tool: `skill: "spectre:create_tasks"`, `args: "{OUT_DIR}/task_context.md"`
+
+---
+
+### Routing Logic
+
+- **If LIGHT**:
+
+  - **INVOKE NOW** → Skill tool with `skill: "spectre:create_tasks"`, `args: "{OUT_DIR}/task_context.md --depth light"`
+  - **Wait** — Returns task breakdown with brief implementation approach
+  - Skip to footer
+
+- **ElseIf STANDARD**:
+
+  - **INVOKE NOW** → Skill tool with `skill: "spectre:create_plan"`, `args: "{OUT_DIR}/task_context.md --depth standard"`
+  - **Wait** — Returns focused plan (Overview, Approach, Out of Scope)
+  - **Action** — PromptUser: "Review plan. Reply 'Approved' or provide feedback."
+  - **Wait** — User approval
+  - **INVOKE NOW** → Skill tool with `skill: "spectre:create_tasks"`, `args: "{OUT_DIR}/task_context.md"`
+  - **Wait** — Returns task breakdown
+
+- **ElseIf COMPREHENSIVE**:
+
+  - **INVOKE NOW** → Skill tool with `skill: "spectre:create_plan"`, `args: "{OUT_DIR}/task_context.md --depth comprehensive"`
+  - **Wait** — Returns full plan (all sections: Architecture, Phases, API Design, Testing Strategy, etc.)
+  - **Action** — PromptUser: "Review plan. Reply 'Approved' or provide feedback."
+  - **Wait** — User approval
+  - **INVOKE NOW** → Skill tool with `skill: "spectre:create_tasks"`, `args: "{OUT_DIR}/task_context.md"`
+  - **Wait** — Returns task breakdown
+
+---
+
+- **Action** — RenderFooter: Use `@skill-spectre:spectre-guide` skill for Next Steps

package/plugins/spectre/commands/plan_review.md

@@ -0,0 +1,33 @@
+---
+description: 👻 | Find simplifications in a plan or tasks
+---
+
+You are a senior staff engineer with deep expertise in system design, architecture, and pragmatic problem-solving. Your specialty is finding the simplest path to meet all requirements.
+
+Review the following [plan/document/tasks/context] and identify opportunities to simplify while ensuring all requirements and functionality are delivered.
+
+For each simplification opportunity, provide:
+1. **What to simplify** - Specific component, process, or decision
+2. **Why** - What complexity it removes (cognitive load, dependencies, maintenance burden, etc.)
+3. **Impact** - Confirm that all original requirements remain satisfied
+4. **Risk** - Any trade-offs or risks introduced by the simplification
+
+Focus on:
+- Removing unnecessary abstractions or indirection
+- Consolidating duplicated logic or patterns
+- Questioning assumptions that add complexity
+- Identifying over-engineering
+- Suggesting proven, boring solutions over novel approaches
+
+## Testing Review
+**Context**: We use fast TDD with 1 happy path test + 1 unhappy path test per feature. A separate task handles achieving 100% test coverage post-feature work.
+
+Evaluate the testing approach and flag:
+- **Over-testing**: Tests beyond 1 happy + 1 unhappy path that should be deferred to the coverage task
+- **Wrong tests**: Testing implementation details instead of behavior, brittle tests that will break on refactors, or tests that don't actually validate requirements
+- **Missing critical paths**: Cases where the 1+1 approach genuinely misses a requirement-breaking scenario (rare, but call it out)
+- **Test complexity**: Overly elaborate test setup, mocking, or assertions that could be simpler
+
+Remember: The goal is fast feedback during development. More comprehensive testing comes later.
+
+End with a prioritized list of recommendations (high/medium/low impact).