specdacular 0.8.1 → 0.10.0

package/README.md

@@ -25,8 +25,10 @@ npx specdacular
   - [Utilities](#utilities)
 - [The Flow in Detail](#the-flow-in-detail)
 - [How It Works](#how-it-works)
+  - [The Brain](#the-brain)
+  - [Pipeline Configuration](#pipeline-configuration)
+  - [Hooks](#hooks)
   - [Parallel Agents](#parallel-agents)
-  - [Task Flow](#task-flow)
 - [Multi-Project Support](#multi-project-support)
 - [Project Structure](#project-structure)
 - [Philosophy](#philosophy)
@@ -57,14 +59,14 @@ For monorepos and multi-repo setups, it maps each sub-project in parallel, then
 Three commands drive the entire task lifecycle:
 
 ```
-/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
+/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
 ```
 
 `continue` reads your task's current state and offers the natural next step. You never need to remember which command comes next.
 
-`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.
+`toolbox` gives you direct access to advanced task operations — discuss, research, plan, execute, review. Use `/specd.codebase.review` for section-by-section context file review with edit/re-map/add.
 
 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.
 
@@ -92,7 +94,7 @@ Choose:
 
 In Claude Code:
 ```
-/specd:help
+/specd.help
 ```
 
 ---
@@ -102,7 +104,7 @@ In Claude Code:
 ### Map a Codebase
 
 ```
-/specd:map-codebase
+/specd.codebase.map
 ```
 
 Creates `.specd/codebase/` with 4 AI-optimized documents. This gives Claude context about your codebase's architecture, patterns, structure, and gotchas. For multi-project setups, it detects sub-projects automatically and maps each one in parallel before producing system-level documentation.
@@ -112,7 +114,7 @@ Creates `.specd/codebase/` with 4 AI-optimized documents. This gives Claude cont
 **Step 1: Initialize**
 
 ```
-/specd:new user-dashboard
+/specd.new user-dashboard
 ```
 
 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.
@@ -120,31 +122,31 @@ Creates `.specd/tasks/user-dashboard/` and starts the first discussion. Claude a
 **Step 2: Drive the lifecycle**
 
 ```
-/specd:continue user-dashboard
+/specd.continue user-dashboard
 ```
 
 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, one PLAN.md per phase
-4. **Phase execution** — Implements with progress tracking
+3. **Planning** — Creates roadmap with phase goals
+4. **Phase execution** — Plans each phase just-in-time, then 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: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
+/specd.continue user-dashboard                # Default — auto-runs, pauses at phase steps
+/specd.continue user-dashboard --interactive  # Prompt at every step with skip/jump options
+/specd.continue user-dashboard --auto         # Run everything, stop only on review issues
 ```
 
 **No argument? It picks for you:**
 
 ```
-/specd:continue
+/specd.continue
 ```
 
 Scans for in-progress tasks and shows a picker.
@@ -152,10 +154,18 @@ Scans for in-progress tasks and shows a picker.
 **Need a specific operation?**
 
 ```
-/specd:toolbox user-dashboard
+/specd.toolbox user-dashboard
 ```
 
-Opens a menu with: Discuss, Research, Plan, Execute, Review. Useful when you want to jump to a specific action outside the normal flow.
+Opens a menu with task operations (Discuss, Research, Plan, Execute, Review). Useful when you want to jump to a specific action outside the normal flow.
+
+**Need to review codebase context?**
+
+```
+/specd.codebase.review
+```
+
+Section-by-section review of any context file: confirm, edit, remove, re-map, or add new content.
 
 ---
 
@@ -165,24 +175,25 @@ Opens a menu with: Discuss, Research, Plan, Execute, Review. Useful when you wan
 
 | Command | Description |
 |---------|-------------|
-| `/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 |
+| `/specd.new [name]` | Initialize a task, start first discussion |
+| `/specd.continue [name] [--interactive\|--auto]` | **Drive the entire lifecycle** — picks up where you left off |
+| `/specd.toolbox [name]` | Advanced task operations |
 
 ### Codebase Documentation
 
 | Command | Description |
 |---------|-------------|
-| `/specd:map-codebase` | Analyze codebase with parallel agents |
+| `/specd.codebase.map` | Analyze codebase with parallel agents |
+| `/specd.codebase.review` | Review and edit codebase context files section by section |
 
 ### Utilities
 
 | Command | Description |
 |---------|-------------|
-| `/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 |
+| `/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 |
 
 ---
 
@@ -195,33 +206,173 @@ Opens a menu with: Discuss, Research, Plan, Execute, Review. Useful when you wan
 - `STATE.md` — Progress tracking
 - `config.json` — Task configuration
 
-**`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:
+**`continue`** delegates to the brain — a config-driven orchestrator that reads `pipeline.json` and drives the lifecycle. It determines the next step from task state, executes pre-hooks → step workflow → post-hooks, updates state, and loops. The default pipeline 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 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.
-
-**`toolbox`** provides direct access to advanced operations outside the normal flow:
+- **Planning** — Creates `ROADMAP.md` with phases derived from dependency analysis. Phase goals only — no detailed PLAN.md files yet.
+- **Phase execution** — Nested sub-pipeline that loops per phase: plan → execute → review → revise. Each phase gets just-in-time planning (detailed PLAN.md from ROADMAP.md goal), then implementation with verification, commits per task, and progress tracking. Later phases can adapt based on earlier execution.
+- **Phase review** — Code review agent inspects executed code against plan intent. Generates fix plans (decimal phases like `phase-01.1`) if needed.
+- **Revise** — Collects feedback from review, creates fix plans, signals brain to re-execute.
 
+**`toolbox`** (`/specd.toolbox my-feature`) provides direct access to task operations outside the normal flow:
 - **Discuss** — Explore open questions, record decisions
 - **Research** — Spawn parallel agents for patterns/pitfalls
 - **Plan** — Create execution phases from task context
 - **Execute** — Execute the next phase's plan
 - **Review** — Review executed phase, approve or request fixes
 
+**`codebase.review`** (`/specd.codebase.review`) — Section-by-section review of any codebase context file: confirm, edit, remove, re-map (spawns a mapper agent to regenerate a section), or add new content. Sections are tracked with `AUTO_GENERATED` and `USER_MODIFIED` tags with dates.
+
 ---
 
 ## How It Works
 
+### The Brain
+
+The brain (`brain.md`) is a config-driven orchestrator that reads `pipeline.json` and drives the entire task lifecycle. Step workflows are pure execution — they do their work and return. The brain decides what comes next.
+
+```
+                        ┌─────────────────────┐
+                        │       BRAIN         │
+                        │  (config-driven     │
+                        │   orchestrator)     │
+                        └────────┬────────────┘
+                                 │
+                    ┌────────────┼────────────┐
+                    ▼            ▼            ▼
+              Read State   Load Pipeline   Check Mode
+                    │            │            │
+                    └────────────┼────────────┘
+                                 │
+                                 ▼
+                    ┌─────────────────────────┐
+                    │      Main Pipeline      │
+                    │                         │
+                    │  discuss → research →   │
+                    │  plan → phase-execution │
+                    └────────────┬────────────┘
+                                 │
+                         ┌───────┴───────┐
+                         ▼               │
+              ┌─────────────────────┐    │
+              │  Phase-Execution    │    │
+              │  Sub-Pipeline       │    │
+              │                     │    │
+              │  plan → execute →   │    │
+              │  review → revise   │    │
+              │      ──loop──┘     │    │
+              │                     │    │
+              │  Per phase, repeats │    │
+              │  until all phases   │    │
+              │  complete           │    │
+              └─────────────────────┘    │
+                         │               │
+                         └───────────────┘
+                                 │
+                                 ▼
+                          TASK COMPLETE
+```
+
+**The brain loop:**
+1. Read current state (`config.json`, `STATE.md`)
+2. Determine next step from pipeline config
+3. Execute pre-hooks → step workflow → post-hooks
+4. Update state → loop back
+
+**Execution modes:**
+
+| Mode | Behavior |
+|------|----------|
+| **Default** | Auto-runs steps, pauses where `pause: true`. Smart-skips unnecessary steps. |
+| **Interactive** (`--interactive`) | Prompts at each stage transition with skip/jump options |
+| **Auto** (`--auto`) | Runs everything, only stops on errors or task completion |
+
+### Pipeline Configuration
+
+The pipeline is defined in `pipeline.json` — nothing is hardcoded. The default pipeline ships with Specdacular and can be fully replaced by placing a `.specd/pipeline.json` in your project (full replace, not merge).
+
+**Default pipeline structure:**
+
+```json
+{
+  "schema_version": "1.0",
+  "pipelines": {
+    "main": [
+      { "name": "discuss",  "workflow": "discuss.md" },
+      { "name": "research", "workflow": "research.md" },
+      { "name": "plan",     "workflow": "plan.md" },
+      { "name": "phase-execution", "pipeline": "phase-execution" }
+    ],
+    "phase-execution": [
+      { "name": "plan",    "workflow": "phase-plan.md" },
+      { "name": "execute", "workflow": "execute.md", "pause": true },
+      { "name": "review",  "workflow": "review.md",  "pause": true },
+      { "name": "revise",  "workflow": "revise.md",  "pause": true }
+    ]
+  },
+  "hooks": { "pre-step": null, "post-step": null }
+}
+```
+
+**Customization options:**
+- **Swap workflows:** Point any step's `workflow` to your own `.md` file
+- **Add hooks:** Configure pre/post hooks per step or globally
+- **Full replace:** Drop `.specd/pipeline.json` to replace the entire pipeline
+
+### Hooks
+
+Hooks are markdown workflow files (`.md`) that run before and after pipeline steps. They can read and modify task files just like any other workflow.
+
+```
+  Global pre-step hook
+         │
+         ▼
+  Step pre-hook
+         │
+         ▼
+  ┌─────────────┐
+  │  Step runs   │
+  │  (discuss,   │
+  │   execute,   │
+  │   etc.)      │
+  └──────┬──────┘
+         │
+         ▼
+  Step post-hook
+         │
+         ▼
+  Global post-step hook
+```
+
+**Configuration in pipeline.json:**
+
+```json
+{
+  "name": "execute",
+  "workflow": "execute.md",
+  "hooks": {
+    "pre": { "workflow": ".specd/hooks/pre-execute.md", "mode": "inline", "optional": false },
+    "post": { "workflow": ".specd/hooks/post-execute.md", "mode": "subagent", "optional": true }
+  }
+}
+```
+
+**Hook modes:**
+- **`inline`** — Runs in the brain's context (can see all state)
+- **`subagent`** — Spawns a separate agent (fresh context, isolated)
+
+**Convention fallback:** If no hooks are configured explicitly, the brain checks for `.specd/hooks/pre-{step}.md` and `.specd/hooks/post-{step}.md` automatically.
+
+**Error handling:** Required hooks (`optional: false`) stop the pipeline on failure. Optional hooks log a warning and continue.
+
 ### Parallel Agents
 
 Specdacular spawns specialized agents that run simultaneously:
 
 ```
 ┌─────────────────────────────────────────────────────────┐
-│                  /specd:map-codebase                    │
+│                  /specd.codebase.map                    │
 └─────────────────────────────────────────────────────────┘
                           │
           ┌───────────────┼───────────────┐
@@ -240,46 +391,6 @@ Specdacular spawns specialized agents that run simultaneously:
 - Faster execution (parallel, not sequential)
 - Agents write directly to files
 
-### Task Flow
-
-```
-/specd:new              /specd:continue
-      │                           │
-      ▼                           ▼
- Create task             ┌─── Read state ◀──────────────┐
- First discussion        │    Show status                │
- Offer to continue       │    Offer next step            │
-      │                  │         │                     │
-      ▼                  │         ▼                     │
- "Keep discussing?"      │   ┌──────────────┐           │
-  Yes → discuss loop     │   │  Execute the │           │
-  No  → continue         │   │  next action │           │
-                         │   └──────────────┘           │
-                         │         │                     │
-                         │    ┌────┴────┐                │
-                         │    │ Discuss │ Research       │
-                         │    │ Plan    │ Execute        │
-                         │    │ Review  │                │
-                         │    └────┬────┘                │
-                         │         │                     │
-                         │         ▼                     │
-                         │   "Continue or stop?"         │
-                         │    Continue ──────────────────┘
-                         │    Stop → clean exit
-                         │
-                         └─── No tasks? → /specd:new
-```
-
-**Under the hood,** `continue` delegates to specialized workflows:
-
-```
-discussion  → discuss workflow
-research    → research workflow (3 parallel agents)
-planning    → plan workflow
-execution   → execute workflow
-review      → review workflow (code review agent)
-```
-
 ---
 
 ## Multi-Project Support
@@ -289,7 +400,7 @@ Specdacular supports monorepos and multi-repo setups through an orchestrator lay
 ### Setup
 
 ```
-/specd:map-codebase
+/specd.codebase.map
 ```
 
 When it detects multiple projects (via `package.json`, `go.mod`, `Cargo.toml`, etc.), it offers to enable multi-project mode. This:
@@ -316,8 +427,8 @@ Planning creates per-project roadmaps plus a cross-project dependency graph (`DE
 `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:continue auth-system       # Auto-picks next unblocked phase across projects
-/specd: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
 ```
 
 ---
@@ -329,7 +440,12 @@ Planning creates per-project roadmaps plus a cross-project dependency graph (`DE
 ```
 your-project/
 ├── .specd/
-│   ├── codebase/              # From /specd:map-codebase
+│   ├── pipeline.json          # Optional — custom pipeline (full replace)
+│   ├── hooks/                 # Optional — convention-based hooks
+│   │   ├── pre-execute.md
+│   │   └── post-review.md
+│   │
+│   ├── codebase/              # From /specd.codebase.map
 │   │   ├── MAP.md
 │   │   ├── PATTERNS.md
 │   │   ├── STRUCTURE.md
@@ -425,7 +541,7 @@ npx specdacular@latest
 
 Or in Claude Code:
 ```
-/specd:update
+/specd.update
 ```
 
 ---

package/agents/specd-codebase-mapper.md

@@ -8,7 +8,7 @@ color: cyan
 <role>
 You are a codebase mapper optimized for AI consumption. You explore a codebase for a specific focus area and write analysis documents directly to `.specd/codebase/`.
 
-You are spawned by `/specd:map-codebase` with one of four focus areas:
+You are spawned by `/specd.codebase.map` with one of four focus areas:
 - **map**: Create navigation map → write MAP.md
 - **patterns**: Extract code patterns → write PATTERNS.md
 - **structure**: Document organization → write STRUCTURE.md

package/bin/install.js

@@ -166,13 +166,27 @@ function uninstall(isGlobal) {
 
   let removedCount = 0;
 
-  // Remove specd commands
+  // Remove specd commands (both old directory format and new flat format)
   const specCommandsDir = path.join(targetDir, 'commands', 'specd');
   if (fs.existsSync(specCommandsDir)) {
     fs.rmSync(specCommandsDir, { recursive: true });
     removedCount++;
     console.log(`  ${green}✓${reset} Removed commands/specd/`);
   }
+  const commandsDir = path.join(targetDir, 'commands');
+  if (fs.existsSync(commandsDir)) {
+    let cmdCount = 0;
+    for (const file of fs.readdirSync(commandsDir)) {
+      if (file.startsWith('specd.') && file.endsWith('.md')) {
+        fs.unlinkSync(path.join(commandsDir, file));
+        cmdCount++;
+      }
+    }
+    if (cmdCount > 0) {
+      removedCount++;
+      console.log(`  ${green}✓${reset} Removed ${cmdCount} specd commands`);
+    }
+  }
 
   // Remove specdacular directory
   const specDir = path.join(targetDir, 'specdacular');
@@ -292,14 +306,34 @@ function install(isGlobal) {
   const commandsDir = path.join(targetDir, 'commands');
   fs.mkdirSync(commandsDir, { recursive: true });
 
-  const specSrc = path.join(src, 'commands', 'specd');
-  const specDest = path.join(commandsDir, 'specd');
-  if (fs.existsSync(specSrc)) {
-    copyWithPathReplacement(specSrc, specDest, pathPrefix);
-    if (verifyInstalled(specDest, 'commands/specd')) {
-      console.log(`  ${green}✓${reset} Installed commands/specd`);
+  // Remove old commands/specd/ directory if it exists (pre-0.10.0 format)
+  const oldSpecDir = path.join(commandsDir, 'specd');
+  if (fs.existsSync(oldSpecDir)) {
+    fs.rmSync(oldSpecDir, { recursive: true });
+  }
+
+  // Remove old specd.*.md command files before copying new ones
+  for (const file of fs.readdirSync(commandsDir)) {
+    if (file.startsWith('specd.') && file.endsWith('.md')) {
+      fs.unlinkSync(path.join(commandsDir, file));
+    }
+  }
+
+  const commandsSrc = path.join(src, 'commands');
+  if (fs.existsSync(commandsSrc)) {
+    let commandCount = 0;
+    for (const file of fs.readdirSync(commandsSrc)) {
+      if (file.startsWith('specd.') && file.endsWith('.md')) {
+        let content = fs.readFileSync(path.join(commandsSrc, file), 'utf8');
+        content = content.replace(/~\/\.claude\//g, pathPrefix);
+        fs.writeFileSync(path.join(commandsDir, file), content);
+        commandCount++;
+      }
+    }
+    if (commandCount > 0) {
+      console.log(`  ${green}✓${reset} Installed ${commandCount} specd commands`);
     } else {
-      failures.push('commands/specd');
+      failures.push('commands');
     }
   }
 
@@ -430,12 +464,12 @@ function install(isGlobal) {
   }
 
   console.log(`
-  ${green}Done!${reset} Launch Claude Code and run ${cyan}/specd:help${reset}.
+  ${green}Done!${reset} Launch Claude Code and run ${cyan}/specd.help${reset}.
 
   ${yellow}Commands:${reset}
-    /specd:map-codebase  - Analyze and document your codebase
-    /specd:update        - Update to latest version
-    /specd:help          - Show all commands
+    /specd.codebase.map  - Analyze and document your codebase
+    /specd.update        - Update to latest version
+    /specd.help          - Show all commands
 `);
 }
 

package/commands/{specd/map-codebase.md → specd.codebase.map.md}

@@ -1,5 +1,5 @@
 ---
-name: specd:map-codebase
+name: specd.codebase.map
 description: Analyze codebase with parallel agents to produce AI-optimized documentation
 argument-hint: ""
 allowed-tools:

package/commands/specd.codebase.review.md

@@ -0,0 +1,39 @@
+---
+name: specd.codebase.review
+description: "Review and edit codebase context files section by section"
+argument-hint: ""
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - AskUserQuestion
+---
+
+<objective>
+Walk through and review a codebase context file (.specd/codebase/*.md) section by section. Confirm, edit, remove, or re-map individual sections.
+
+Output: Updated context file with reviewed/edited sections and updated timestamps.
+</objective>
+
+<execution_context>
+Follow the context-manual-review workflow:
+@~/.claude/specdacular/workflows/context-manual-review.md
+</execution_context>
+
+<context>
+**Context workflows:**
+@~/.claude/specdacular/workflows/context-manual-review.md
+@~/.claude/specdacular/workflows/context-add.md
+</context>
+
+<success_criteria>
+- [ ] User selects a context file to review
+- [ ] Section list shown with tag status
+- [ ] User can confirm, edit, remove, or re-map each section
+- [ ] Timestamps updated after review
+- [ ] Changes committed
+</success_criteria>

package/commands/{specd/config.md → specd.config.md}

@@ -1,5 +1,5 @@
 ---
-name: specd:config
+name: specd.config
 description: Create or update .specd/config.json with commit settings
 argument-hint: ""
 allowed-tools:

package/commands/specd.continue.md

@@ -0,0 +1,67 @@
+---
+name: specd.continue
+description: Continue task lifecycle — picks up where you left off
+argument-hint: "[task-name] [--interactive|--auto]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - AskUserQuestion
+---
+
+<objective>
+Config-driven orchestrator that reads pipeline.json and drives the entire task lifecycle. One command from discussion through execution and review.
+
+**Modes:**
+- **Default:** Auto-runs steps, pauses where `pause: true`. Smart-skips unnecessary steps.
+- **--interactive:** Prompts at every stage transition with skip/jump options
+- **--auto:** Runs everything, only stops on errors or task completion
+
+**How it works:**
+1. Select task (from argument or picker)
+2. Load pipeline.json (user override or default)
+3. Read current state → determine next step
+4. Execute pre-hooks → step → post-hooks
+5. Update state → loop back or stop
+
+**Pipeline customization:**
+- Place `.specd/pipeline.json` to fully replace the default pipeline
+- Swap any step's workflow to a custom `.md` file
+- Add pre/post hooks (markdown workflow files)
+</objective>
+
+<execution_context>
+@~/.claude/specdacular/workflows/continue.md
+</execution_context>
+
+<context>
+Task name and flags: $ARGUMENTS
+
+**Pipeline config:**
+@.specd/pipeline.json (user override, if exists)
+@~/.claude/specdacular/pipeline.json (default)
+
+**Scans for tasks:**
+@.specd/tasks/*/config.json
+
+**Delegates to brain which dispatches:**
+@~/.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
+@~/.claude/specdacular/workflows/revise.md
+</context>
+
+<success_criteria>
+- [ ] Task selected (from argument or picker)
+- [ ] Pipeline loaded and validated
+- [ ] Current state accurately assessed
+- [ ] Correct next step dispatched with hooks
+- [ ] Mode flags (--interactive, --auto) respected
+- [ ] User can stop at any natural boundary
+</success_criteria>

package/commands/{specd/help.md → specd.help.md}

@@ -1,5 +1,5 @@
 ---
-name: specd:help
+name: specd.help
 description: Show all specdacular commands and usage guide
 allowed-tools:
   - Read