specdacular 0.7.1 → 0.8.0

package/README.md

@@ -26,7 +26,7 @@ npx specdacular
 - [The Flow in Detail](#the-flow-in-detail)
 - [How It Works](#how-it-works)
   - [Parallel Agents](#parallel-agents)
-  - [Feature Flow](#feature-flow)
+  - [Task Flow](#task-flow)
 - [Multi-Project Support](#multi-project-support)
 - [Project Structure](#project-structure)
 - [Philosophy](#philosophy)
@@ -54,17 +54,17 @@ For monorepos and multi-repo setups, it maps each sub-project in parallel, then
 
 ### 2. Plan Features
 
-Three commands drive the entire feature lifecycle:
+Three commands drive the entire task lifecycle:
 
 ```
-/specd:feature:new my-feature         # Initialize + first discussion
-/specd:feature:continue my-feature    # Everything else — discussion, research, planning, execution, review
-/specd:feature:toolbox my-feature     # Advanced operations menu
+/specd:new my-feature              # Initialize + first discussion
+/specd:continue my-feature         # Everything else — discussion, research, planning, execution, review
+/specd:toolbox my-feature          # Advanced operations menu
 ```
 
-`feature:continue` reads your feature's current state and offers the natural next step. You never need to remember which command comes next.
+`continue` reads your task's current state and offers the natural next step. You never need to remember which command comes next.
 
-`feature:toolbox` gives you direct access to advanced operations — discuss, research, plan, review, or insert a phase — when you want to jump to a specific action outside the normal flow.
+`toolbox` gives you direct access to advanced operations — discuss, research, plan, execute, review — when you want to jump to a specific action outside the normal flow.
 
 Works with single projects and multi-project setups (monorepos, multi-repo). In multi-project mode, features are discussed at the system level and routed to the relevant sub-projects, with cross-project dependency tracking and contract validation.
 
@@ -112,44 +112,50 @@ Creates `.specd/codebase/` with 4 AI-optimized documents. This gives Claude cont
 **Step 1: Initialize**
 
 ```
-/specd:feature:new user-dashboard
+/specd:new user-dashboard
 ```
 
-Creates `.specd/features/user-dashboard/` and starts the first discussion. Claude asks what you're building, follows the thread, and captures technical requirements. When done, offers to continue discussing or stop.
+Creates `.specd/tasks/user-dashboard/` and starts the first discussion. Claude asks what you're building, follows the thread, and captures technical requirements. When done, offers to continue discussing or stop.
 
 **Step 2: Drive the lifecycle**
 
 ```
-/specd:feature:continue user-dashboard
+/specd:continue user-dashboard
 ```
 
-That's it. `feature:continue` reads the current state and guides you through each stage:
+That's it. `continue` reads the current state and guides you through each stage:
 
 1. **Discussion** — Probes gray areas until clear
 2. **Research** — Spawns parallel agents for patterns/pitfalls
-3. **Planning** — Creates roadmap with phases
-4. **Phase preparation** — Discusses phase-specific gray areas
-5. **Phase planning** — Creates detailed PLAN.md files
-6. **Phase execution** — Implements with progress tracking
-7. **Phase review** — Compares plans against actual code
+3. **Planning** — Creates roadmap with phases, one PLAN.md per phase
+4. **Phase execution** — Implements with progress tracking
+5. **Phase review** — Code review agent compares plans against actual code
 
-After each step, you can continue or stop. Resume anytime with `/specd:feature:continue`.
+After each step, you can continue or stop. Resume anytime with `/specd:continue`.
+
+**Execution modes:**
+
+```
+/specd:continue user-dashboard                # Interactive (default) — pause after each step
+/specd:continue user-dashboard --semi-auto    # Auto through planning, pause after review
+/specd:continue user-dashboard --auto         # Run everything, stop only on review issues
+```
 
 **No argument? It picks for you:**
 
 ```
-/specd:feature:continue
+/specd:continue
 ```
 
-Scans for in-progress features and shows a picker.
+Scans for in-progress tasks and shows a picker.
 
 **Need a specific operation?**
 
 ```
-/specd:feature:toolbox user-dashboard
+/specd:toolbox user-dashboard
 ```
 
-Opens a menu with: Discuss, Research, Plan, Review, Insert phase. Useful when you want to jump to a specific action — like running research mid-execution or inserting a phase between existing ones.
+Opens a menu with: Discuss, Research, Plan, Execute, Review. Useful when you want to jump to a specific action outside the normal flow.
 
 ---
 
@@ -159,9 +165,9 @@ Opens a menu with: Discuss, Research, Plan, Review, Insert phase. Useful when yo
 
 | Command | Description |
 |---------|-------------|
-| `/specd:feature:new [name]` | Initialize a feature, start first discussion |
-| `/specd:feature:continue [name]` | **Drive the entire lifecycle** — picks up where you left off |
-| `/specd:feature:toolbox [name]` | Advanced operations: discuss, research, plan, review, insert |
+| `/specd:new [name]` | Initialize a task, start first discussion |
+| `/specd:continue [name] [--semi-auto\|--auto]` | **Drive the entire lifecycle** — picks up where you left off |
+| `/specd:toolbox [name]` | Advanced operations: discuss, research, plan, execute, review |
 
 ### Codebase Documentation
 
@@ -173,7 +179,8 @@ Opens a menu with: Discuss, Research, Plan, Review, Insert phase. Useful when yo
 
 | Command | Description |
 |---------|-------------|
-| `/specd:status [--all]` | Show feature status dashboard |
+| `/specd:config` | Configure auto-commit settings for docs and code |
+| `/specd:status [--all]` | Show task status dashboard |
 | `/specd:help` | Show available commands |
 | `/specd:update` | Update to latest version |
 
@@ -181,30 +188,28 @@ Opens a menu with: Discuss, Research, Plan, Review, Insert phase. Useful when yo
 
 ## The Flow in Detail
 
-**`feature:new`** creates the feature folder and starts the first discussion. After initialization, offers to continue discussing or come back later with `feature:continue`. Output:
+**`new`** creates the task folder and starts the first discussion. After initialization, offers to continue discussing or come back later with `continue`. Output:
 - `FEATURE.md` — Technical requirements from the conversation
 - `CONTEXT.md` — Discussion context (accumulates over time)
 - `DECISIONS.md` — Decisions with dates, rationale, and implications
 - `STATE.md` — Progress tracking
-- `config.json` — Feature configuration
+- `config.json` — Task configuration
 
-**`feature:continue`** is the smart state machine. It reads `config.json` and `STATE.md` to determine where the feature is, shows a status summary, and offers the natural next step. After each action it loops back — you keep going until you choose to stop. Under the hood it delegates to these stages:
+**`continue`** is the smart state machine. It reads `config.json` and `STATE.md` to determine where the task is, shows a status summary, and offers the natural next step. After each action it loops back — you keep going until you choose to stop. Under the hood it delegates to these stages:
 
 - **Discussion** — Probes gray areas, records decisions. Context accumulates across sessions.
 - **Research** — Spawns 3 parallel agents: codebase integration, external patterns, and pitfalls. Output: `RESEARCH.md`.
-- **Planning** — Creates `ROADMAP.md` with phases derived from dependency analysis, plus empty `plans/phase-{NN}/` directories.
-- **Phase preparation** — Discusses phase-specific gray areas, records resolutions to phase `CONTEXT.md` and `DECISIONS.md`. Optionally spawns research agents focused on the phase.
-- **Phase planning** — Creates detailed PLAN.md files. Each plan is a self-contained prompt for an implementing agent with exact file paths, code patterns, verification commands, and completion criteria. Plans are created just-in-time so they incorporate all context from preparation and earlier phases.
-- **Phase execution** — Implements plans with auto-fix for bugs/blockers, user confirmation for architectural changes, verification after each task, commits, and progress tracking in `STATE.md`.
-- **Phase review** — Reviews executed plans against actual code using git diff. Generates corrective plans if needed (fed back into execution). Review cycle tracked in `STATE.md`.
+- **Planning** — Creates `ROADMAP.md` with phases derived from dependency analysis, plus one `phases/phase-NN/PLAN.md` per phase. Plans are self-contained prompts for an implementing agent.
+- **Phase execution** — Implements plans with verification after each task, commits per task, and progress tracking in `STATE.md`.
+- **Phase review** — Code review agent inspects executed code against plan intent using semantic analysis and git diff. Generates fix plans (decimal phases like `phase-01.1`) if needed.
 
-**`feature:toolbox`** provides direct access to advanced operations outside the normal flow:
+**`toolbox`** provides direct access to advanced operations outside the normal flow:
 
-- **Discuss** — Explore open questions at the feature or phase level
+- **Discuss** — Explore open questions, record decisions
 - **Research** — Spawn parallel agents for patterns/pitfalls
-- **Plan** — Create implementation plans for a specific phase
-- **Review** — Review executed work and report issues
-- **Insert phase** — Add a phase mid-development using decimal numbering (e.g., Phase 3.1 after Phase 3)
+- **Plan** — Create execution phases from task context
+- **Execute** — Execute the next phase's plan
+- **Review** — Review executed phase, approve or request fixes
 
 ---
 
@@ -235,26 +240,26 @@ Specdacular spawns specialized agents that run simultaneously:
 - Faster execution (parallel, not sequential)
 - Agents write directly to files
 
-### Feature Flow
+### Task Flow
 
 ```
-/specd:feature:new        /specd:feature:continue
+/specd:new              /specd:continue
       │                           │
       ▼                           ▼
- Create feature          ┌─── Read state ◀──────────────┐
+ Create task             ┌─── Read state ◀──────────────┐
  First discussion        │    Show status                │
  Offer to continue       │    Offer next step            │
       │                  │         │                     │
       ▼                  │         ▼                     │
  "Keep discussing?"      │   ┌──────────────┐           │
   Yes → discuss loop     │   │  Execute the │           │
-  No  → feature:continue │   │  next action │           │
+  No  → continue         │   │  next action │           │
                          │   └──────────────┘           │
                          │         │                     │
                          │    ┌────┴────┐                │
                          │    │ Discuss │ Research       │
-                         │    │ Plan    │ Prepare phase  │
-                         │    │ Execute │ Review phase   │
+                         │    │ Plan    │ Execute        │
+                         │    │ Review  │                │
                          │    └────┬────┘                │
                          │         │                     │
                          │         ▼                     │
@@ -262,19 +267,17 @@ Specdacular spawns specialized agents that run simultaneously:
                          │    Continue ──────────────────┘
                          │    Stop → clean exit
                          │
-                         └─── No features? → feature:new
+                         └─── No tasks? → /specd:new
 ```
 
-**Under the hood,** `feature:continue` delegates to the same workflows as the toolbox operations:
+**Under the hood,** `continue` delegates to specialized workflows:
 
 ```
-discussion  → discuss-feature workflow
-research    → research-feature workflow (3 parallel agents)
-planning    → plan-feature workflow
-phase prep  → prepare-phase workflow
-phase plan  → plan-phase workflow
-execution   → execute-plan workflow
-review      → review-feature workflow
+discussion  → discuss workflow
+research    → research workflow (3 parallel agents)
+planning    → plan workflow
+execution   → execute workflow
+review      → review workflow (code review agent)
 ```
 
 ---
@@ -304,17 +307,17 @@ When it detects multiple projects (via `package.json`, `go.mod`, `Cargo.toml`, e
 
 ### Feature Planning
 
-`feature:new` conducts a system-level discussion, identifies which projects are involved, and creates per-project features with self-contained requirements. Each sub-project's `.specd/` works identically whether standalone or part of a multi-project setup.
+`new` conducts a system-level discussion, identifies which projects are involved, and creates per-project tasks with self-contained requirements. Each sub-project's `.specd/` works identically whether standalone or part of a multi-project setup.
 
 Planning creates per-project roadmaps plus a cross-project dependency graph (`DEPENDENCIES.md`) with cycle validation.
 
 ### Execution & Scheduling
 
-`feature:continue` schedules across projects, respecting cross-project dependencies. After each phase, it performs contract review — comparing what was implemented against system-level expectations and flagging deviations before they cascade to downstream projects.
+`continue` schedules across projects, respecting cross-project dependencies. After each phase, it performs contract review — comparing what was implemented against system-level expectations and flagging deviations before they cascade to downstream projects.
 
 ```
-/specd:feature:continue auth-system       # Auto-picks next unblocked phase across projects
-/specd:feature:continue auth-system api   # Target a specific sub-project
+/specd:continue auth-system       # Auto-picks next unblocked phase across projects
+/specd:continue auth-system api   # Target a specific sub-project
 ```
 
 ---
@@ -332,24 +335,19 @@ your-project/
 │   │   ├── STRUCTURE.md
 │   │   └── CONCERNS.md
 │   │
-│   └── features/              # From feature commands
+│   └── tasks/                 # From task commands
 │       └── user-dashboard/
 │           ├── FEATURE.md     # Technical requirements
-│           ├── CONTEXT.md     # Feature-level discussion
-│           ├── DECISIONS.md   # Decision log (feature + phase)
+│           ├── CONTEXT.md     # Discussion context
+│           ├── DECISIONS.md   # Decision log
 │           ├── STATE.md       # Progress tracking
-│           ├── RESEARCH.md    # Feature-level research
-│           ├── ROADMAP.md     # Phase overview (from feature:plan)
-│           └── plans/
+│           ├── RESEARCH.md    # Research findings
+│           ├── ROADMAP.md     # Phase overview
+│           └── phases/
 │               ├── phase-01/
-│               │   ├── CONTEXT.md   # Phase discussion
-│               │   ├── RESEARCH.md  # Phase research
-│               │   ├── 01-PLAN.md   # Detailed plans
-│               │   └── 02-PLAN.md
+│               │   └── PLAN.md
 │               └── phase-02/
-│                   ├── CONTEXT.md
-│                   ├── RESEARCH.md
-│                   └── 01-PLAN.md
+│                   └── PLAN.md
 └── ...
 ```
 
@@ -364,7 +362,7 @@ monorepo/
 │   │   ├── TOPOLOGY.md
 │   │   ├── CONTRACTS.md
 │   │   └── CONCERNS.md
-│   └── features/
+│   └── tasks/
 │       └── auth-system/
 │           ├── FEATURE.md          # System-level requirements
 │           ├── DEPENDENCIES.md     # Cross-project dependency graph
@@ -378,17 +376,17 @@ monorepo/
 │       │   ├── PATTERNS.md
 │       │   ├── STRUCTURE.md
 │       │   └── CONCERNS.md
-│       └── features/
+│       └── tasks/
 │           └── auth-system/
 │               ├── FEATURE.md      # Project-specific requirements
 │               ├── ROADMAP.md      # Per-project phases
-│               └── plans/...
+│               └── phases/...
 │
 └── web/
     └── .specd/                     # Another sub-project
         ├── config.json
         ├── codebase/...
-        └── features/...
+        └── tasks/...
 ```
 
 ---

package/commands/specd/continue.md

@@ -0,0 +1,59 @@
+---
+name: specd:continue
+description: Continue task lifecycle — picks up where you left off
+argument-hint: "[task-name] [--semi-auto|--auto]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - AskUserQuestion
+---
+
+<objective>
+Smart state machine that reads current task state and drives the entire lifecycle. One command from discussion through execution and review.
+
+**Modes:**
+- **Default (interactive):** Prompts at each stage transition
+- **--semi-auto:** Auto-runs discuss→research→plan, pauses after each phase execution + review
+- **--auto:** Runs everything, only stops on review issues or task completion
+
+**How it works:**
+1. Select task (from argument or picker)
+2. Read current state
+3. Determine natural next step
+4. Execute it (delegating to workflows)
+5. Loop back — offer the next step or stop
+
+**Covers the full lifecycle:**
+- Discussion → Research → Planning → Execution → Review → Next phase
+</objective>
+
+<execution_context>
+@~/.claude/specdacular/workflows/continue.md
+</execution_context>
+
+<context>
+Task name and flags: $ARGUMENTS
+
+**Scans for tasks:**
+@.specd/tasks/*/config.json
+
+**Delegates to workflows:**
+@~/.claude/specdacular/workflows/discuss.md
+@~/.claude/specdacular/workflows/research.md
+@~/.claude/specdacular/workflows/plan.md
+@~/.claude/specdacular/workflows/execute.md
+@~/.claude/specdacular/workflows/review.md
+</context>
+
+<success_criteria>
+- [ ] Task selected (from argument or picker)
+- [ ] Current state accurately assessed
+- [ ] Correct next action offered/executed
+- [ ] Mode flags (--semi-auto, --auto) respected
+- [ ] User can stop at any natural boundary
+</success_criteria>

package/commands/specd/new.md

@@ -0,0 +1,65 @@
+---
+name: specd:new
+description: Initialize a new task and start the first discussion
+argument-hint: "[task-name]"
+allowed-tools:
+  - Read
+  - Bash
+  - Glob
+  - Grep
+  - Write
+  - AskUserQuestion
+---
+
+<objective>
+Initialize a task folder and start the first discussion. Creates structure, asks initial questions about what's being built, and writes technical requirements. After initialization, offers to continue discussing or stop.
+
+**Creates:**
+- `.specd/tasks/{name}/FEATURE.md` — Technical requirements from discussion
+- `.specd/tasks/{name}/CONTEXT.md` — Discussion context (accumulates over time)
+- `.specd/tasks/{name}/DECISIONS.md` — Memory file for decisions with rationale
+- `.specd/tasks/{name}/CHANGELOG.md` — Implementation log
+- `.specd/tasks/{name}/STATE.md` — Progress tracking
+- `.specd/tasks/{name}/config.json` — Task configuration
+
+**This is the entry point.** After this, continue with `/specd:continue` to drive the entire lifecycle.
+</objective>
+
+<execution_context>
+@~/.claude/specdacular/workflows/new.md
+</execution_context>
+
+<context>
+Task name: $ARGUMENTS
+
+**Codebase context discovery:**
+1. Check for `.specd/config.json` — if exists, read `codebase_docs` path
+2. If no config, check for `.specd/codebase/` (default location)
+3. If neither found, offer `/specd:map-codebase`
+
+**Referenced docs (when available):**
+- `MAP.md` — System structure
+- `PATTERNS.md` — Code patterns
+- `STRUCTURE.md` — Directory layout
+</context>
+
+<process>
+1. **Validate** — Check name, check if exists
+2. **Codebase Context** — Look for codebase docs (offer map-codebase if missing)
+3. **First Discussion** — "What are you building?"
+4. **Follow the Thread** — Collaborative, not interrogative
+5. **Probe Until Clear** — What creates, what integrates with, constraints
+6. **Write Documents** — FEATURE.md, CONTEXT.md, DECISIONS.md, CHANGELOG.md, STATE.md, config.json
+7. **Commit and Present Options**
+</process>
+
+<success_criteria>
+- [ ] Task folder created at `.specd/tasks/{name}/`
+- [ ] FEATURE.md captures technical requirements
+- [ ] CONTEXT.md initialized with discussion context
+- [ ] DECISIONS.md initialized (possibly with initial decisions)
+- [ ] STATE.md tracks current position
+- [ ] config.json created
+- [ ] Committed to git
+- [ ] User offered to continue with `/specd:continue`
+</success_criteria>

package/commands/specd/status.md

@@ -9,7 +9,7 @@ allowed-tools:
 ---
 
 <objective>
-Display a dashboard showing all features and their current status, stage, plan progress, and recommended next action.
+Display a dashboard showing all tasks and their current status, stage, plan progress, and recommended next action.
 
 - By default, hide completed features
 - With `--all` flag, show completed features in a separate section

package/commands/specd/toolbox.md

@@ -0,0 +1,59 @@
+---
+name: specd:toolbox
+description: "Advanced task operations — discuss, research, plan, execute, review"
+argument-hint: "[task-name]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - AskUserQuestion
+  - WebSearch
+  - WebFetch
+---
+
+<objective>
+Menu of advanced task operations. Presents options and dispatches to the appropriate workflow.
+
+**Operations:**
+- **Discuss** — Explore open questions, record decisions
+- **Research** — Spawn parallel research agents
+- **Plan** — Create execution phases from task context
+- **Execute** — Execute the next phase's plan
+- **Review** — Review executed phase, approve or request fixes
+</objective>
+
+<execution_context>
+First, select the task using:
+@~/.claude/specdacular/references/validate-task.md
+
+Then present the menu using AskUserQuestion:
+- header: "Operation"
+- question: "What would you like to do with {task-name}?"
+- options:
+  - "Discuss" — Explore gray areas and record decisions
+  - "Research" — Spawn parallel agents for patterns/pitfalls
+  - "Plan" — Create execution phases
+  - "Execute" — Execute the next phase
+  - "Review" — Review executed phase
+
+Based on selection, delegate to the appropriate workflow:
+- Discuss → @~/.claude/specdacular/workflows/discuss.md
+- Research → @~/.claude/specdacular/workflows/research.md
+- Plan → @~/.claude/specdacular/workflows/plan.md
+- Execute → @~/.claude/specdacular/workflows/execute.md
+- Review → @~/.claude/specdacular/workflows/review.md
+</execution_context>
+
+<context>
+Task name: $ARGUMENTS
+</context>
+
+<success_criteria>
+- [ ] Task selected (from argument or picker)
+- [ ] Menu presented with operations
+- [ ] Selected operation executed via correct workflow
+</success_criteria>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specdacular",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Feature planning system for existing codebases. Map, understand, and plan features in large projects.",
   "bin": {
     "specdacular": "bin/install.js"

package/specdacular/HELP.md

@@ -8,46 +8,49 @@
 
 | Command | Description |
 |---------|-------------|
-| `/specd:feature:new [name]` | Initialize a feature, start first discussion |
-| `/specd:feature:continue [name]` | Continue feature lifecycle — picks up where you left off |
-| `/specd:feature:toolbox [name]` | Advanced operations: discuss, research, plan, review, insert |
+| `/specd:new [name]` | Initialize a task, start first discussion |
+| `/specd:continue [name] [--semi-auto\|--auto]` | Continue task lifecycle — picks up where you left off |
+
+| `/specd:toolbox [name]` | Advanced operations: discuss, research, plan, execute, review |
 
 ### Utilities
 
 | Command | Description |
 |---------|-------------|
 | `/specd:map-codebase` | Analyze codebase with parallel agents → AI-optimized docs |
-| `/specd:status [--all]` | Show feature status dashboard |
+| `/specd:config` | Configure auto-commit settings for docs and code |
+| `/specd:status [--all]` | Show task status dashboard |
 | `/specd:help` | Show this help |
 | `/specd:update` | Update Specdacular to the latest version |
 
 ---
 
-## Feature Flow
+## Task Flow
 
 ```
-/specd:feature:new → /specd:feature:continue → continue → continue → done
+/specd:new → /specd:continue → continue → continue → done
 ```
 
 **You only need three commands:**
 
-1. **`/specd:feature:new [name]`** — Start here. Creates feature folder, asks initial questions.
-2. **`/specd:feature:continue [name]`** — Picks up where you left off. Drives the entire lifecycle:
+1. **`/specd:new [name]`** — Start here. Creates task folder, asks initial questions.
+2. **`/specd:continue [name]`** — Picks up where you left off. Drives the entire lifecycle:
    - Discussion → Research → Planning → Phase Execution → Review
    - After each step, offers the next step or "stop for now"
    - Works across context windows — reads state fresh each time
-3. **`/specd:feature:toolbox [name]`** — Advanced operations menu:
-   - **Discuss** — Explore open questions (feature or phase level)
+   - Modes: interactive (default), `--semi-auto` (auto through planning, pause after review), `--auto` (run everything)
+3. **`/specd:toolbox [name]`** — Advanced operations menu:
+   - **Discuss** — Explore open questions, record decisions
    - **Research** — Spawn parallel agents for patterns/pitfalls
-   - **Plan** — Create implementation plans
-   - **Review** — Review executed work, report issues
-   - **Insert phase** — Add a phase mid-development (decimal numbering)
+   - **Plan** — Create execution phases
+   - **Execute** — Execute the next phase
+   - **Review** — Review executed phase, approve or request fixes
 
 ### Quick Start
 
 ```
-/specd:feature:new user-dashboard
-/specd:feature:continue user-dashboard
+/specd:new user-dashboard
+/specd:continue user-dashboard
 ```
 
 After initialization, just keep running `continue`. It figures out what's next.
@@ -81,4 +84,4 @@ Or manually: `npx specdacular@latest`
 
 ---
 
-GitHub: https://github.com/vlad-ds/specdacular
+GitHub: https://github.com/victorbalan/specdacular

package/specdacular/agents/feature-researcher.md

@@ -1,6 +1,6 @@
 ---
 name: feature-researcher
-description: Researches implementation patterns, libraries, and pitfalls for features. Spawned by /specd:feature:research and /specd:phase:prepare.
+description: Researches implementation patterns, libraries, and pitfalls for features. Spawned by /specd:research and /specd:research (phase-level).
 tools: Read, Write, Bash, Grep, Glob, WebSearch, WebFetch
 ---
 
@@ -8,9 +8,9 @@ tools: Read, Write, Bash, Grep, Glob, WebSearch, WebFetch
 You are a feature researcher. You investigate how to implement a specific feature well, producing findings that directly inform planning.
 
 You are spawned by:
-- `/specd:feature:research` orchestrator (parallel research)
-- `/specd:phase:prepare` (when user opts into research)
-- `/specd:phase:research` (standalone phase research)
+- `/specd:research` orchestrator (parallel research)
+- `/specd:research (phase-level)` (when user opts into research)
+- `/specd:research` (standalone phase research)
 
 Your job: Answer "What do I need to know to IMPLEMENT this feature well?" Produce structured findings that the synthesizer combines into RESEARCH.md.