spets 0.1.38 → 0.1.40

package/dist/index.js

@@ -725,8 +725,8 @@ function formatDocStatus(status) {
 import { execSync as execSync2 } from "child_process";
 
 // src/orchestrator/index.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
 import matter2 from "gray-matter";
 
 // src/core/section-tree.ts
@@ -934,66 +934,732 @@ Save to: ${section.outputPath}
 `;
 }
 
-// src/orchestrator/index.ts
-var Orchestrator = class {
-  cwd;
-  constructor(cwd = process.cwd()) {
-    this.cwd = cwd;
+// src/core/prompt-builder.ts
+import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+function buildContextPrompt(params) {
+  const cwd = params.cwd || process.cwd();
+  const stepsDir = getStepsDir(cwd);
+  const isFirstStep = params.stepIndex === 1;
+  const instructionPath = join4(stepsDir, params.step, "instruction.md");
+  const instruction = existsSync4(instructionPath) ? readFileSync4(instructionPath, "utf-8") : "";
+  const parts = [];
+  parts.push("# Context Gathering Phase");
+  parts.push("");
+  parts.push("Your task is to gather context before generating a document.");
+  parts.push("Do NOT generate the document yet - only gather information.");
+  parts.push("");
+  parts.push("## Task Information");
+  parts.push("");
+  parts.push(`- **Task ID**: ${params.taskId}`);
+  parts.push(`- **Current Step**: ${params.step} (${params.stepIndex}/${params.totalSteps})`);
+  parts.push("");
+  if (isFirstStep) {
+    parts.push("## User Request");
+    parts.push("");
+    parts.push(`> ${params.description}`);
+    parts.push("");
+  } else if (params.previousOutput) {
+    parts.push("## Previous Step Output");
+    parts.push("");
+    if (existsSync4(params.previousOutput)) {
+      parts.push(readFileSync4(params.previousOutput, "utf-8"));
+    }
+    parts.push("");
   }
-  // ===========================================================================
-  // Config & Path Helpers
-  // ===========================================================================
-  getSteps() {
-    const config = loadConfig(this.cwd);
-    return config.steps;
+  if (instruction) {
+    parts.push("## Step Instruction (Preview)");
+    parts.push("");
+    parts.push("The next phase will use this instruction to generate a document:");
+    parts.push("");
+    parts.push("```");
+    parts.push(instruction.slice(0, 500) + (instruction.length > 500 ? "..." : ""));
+    parts.push("```");
+    parts.push("");
   }
-  getOutputPath() {
-    return getOutputsDir(this.cwd);
+  parts.push("## Your Task");
+  parts.push("");
+  parts.push("1. **Analyze** the request/input to understand what is being asked");
+  parts.push("2. **Search** the codebase for relevant files, patterns, conventions");
+  parts.push("3. **Identify** key constraints, dependencies, and considerations");
+  parts.push("");
+  parts.push("## Output Format");
+  parts.push("");
+  parts.push("Output a JSON object with this structure:");
+  parts.push("");
+  parts.push("```json");
+  parts.push("{");
+  parts.push('  "summary": "Brief summary of what you understood and found",');
+  parts.push('  "relevantFiles": ["path/to/file1.ts", "path/to/file2.ts"],');
+  parts.push('  "keyFindings": [');
+  parts.push('    "Finding 1: description",');
+  parts.push('    "Finding 2: description"');
+  parts.push("  ]");
+  parts.push("}");
+  parts.push("```");
+  parts.push("");
+  parts.push("**Important:** Output ONLY the JSON, no other text.");
+  parts.push("");
+  return parts.join("\n");
+}
+function buildExplorePrompt(params) {
+  const cwd = params.cwd || process.cwd();
+  const stepsDir = getStepsDir(cwd);
+  const isFirstStep = params.stepIndex === 1;
+  const instructionPath = join4(stepsDir, params.step, "instruction.md");
+  const instruction = existsSync4(instructionPath) ? readFileSync4(instructionPath, "utf-8") : "";
+  const parts = [];
+  parts.push("# Explore Phase - Deep Codebase Analysis");
+  parts.push("");
+  parts.push("Your task is to deeply explore the codebase to understand context for document generation.");
+  parts.push("**IMPORTANT:** Do NOT just list files. You MUST read file contents and analyze them.");
+  parts.push("");
+  parts.push("## Task Information");
+  parts.push("");
+  parts.push(`- **Task ID**: ${params.taskId}`);
+  parts.push(`- **Current Step**: ${params.step} (${params.stepIndex}/${params.totalSteps})`);
+  parts.push("");
+  if (isFirstStep) {
+    parts.push("## User Request");
+    parts.push("");
+    parts.push(`> ${params.description}`);
+    parts.push("");
+  } else if (params.previousOutput) {
+    parts.push("## Previous Step Output");
+    parts.push("");
+    if (existsSync4(params.previousOutput)) {
+      parts.push(readFileSync4(params.previousOutput, "utf-8"));
+    }
+    parts.push("");
   }
-  getStatePath(taskId) {
-    return join4(this.getOutputPath(), taskId, ".state.json");
+  if (instruction) {
+    parts.push("## Step Instruction (Preview)");
+    parts.push("");
+    parts.push("The document to be generated must follow this instruction:");
+    parts.push("");
+    parts.push("```");
+    parts.push(instruction.slice(0, 1e3) + (instruction.length > 1e3 ? "\n...(truncated)" : ""));
+    parts.push("```");
+    parts.push("");
   }
-  getSpecPath(taskId, step) {
-    return join4(this.getOutputPath(), taskId, `${step}.md`);
+  parts.push("## Your Task");
+  parts.push("");
+  parts.push("1. **Search** for relevant files using patterns (Glob, Grep)");
+  parts.push("2. **Read** the content of important files (not just paths)");
+  parts.push("3. **Analyze** code patterns, naming conventions, architecture");
+  parts.push('4. **Identify** constraints (e.g., "uses TypeScript strict mode")');
+  parts.push("5. **Find** dependencies (internal and external)");
+  parts.push("");
+  parts.push("**Key difference from context phase:** You must READ file contents, not just list them.");
+  parts.push("");
+  parts.push("## Output Format");
+  parts.push("");
+  parts.push("Output a JSON object with this structure:");
+  parts.push("");
+  parts.push("```json");
+  parts.push("{");
+  parts.push('  "summary": "Comprehensive summary of what you found and understood",');
+  parts.push('  "relevantFiles": [');
+  parts.push("    {");
+  parts.push('      "path": "src/core/example.ts",');
+  parts.push('      "purpose": "Why this file is relevant",');
+  parts.push('      "keySnippets": ["function doSomething() {...}", "export interface Config {...}"]');
+  parts.push("    }");
+  parts.push("  ],");
+  parts.push('  "patterns": [');
+  parts.push('    "Uses dependency injection pattern",');
+  parts.push('    "All exports are named (no default exports)"');
+  parts.push("  ],");
+  parts.push('  "constraints": [');
+  parts.push('    "TypeScript strict mode enabled",');
+  parts.push('    "Must maintain backward compatibility"');
+  parts.push("  ],");
+  parts.push('  "dependencies": [');
+  parts.push('    "gray-matter for frontmatter parsing",');
+  parts.push('    "Internal: uses ../core/config.js"');
+  parts.push("  ]");
+  parts.push("}");
+  parts.push("```");
+  parts.push("");
+  parts.push("**Important:** Output ONLY the JSON, no other text.");
+  parts.push("");
+  return parts.join("\n");
+}
+function buildClarifyPrompt(params) {
+  const cwd = params.cwd || process.cwd();
+  const stepsDir = getStepsDir(cwd);
+  const instructionPath = join4(stepsDir, params.step, "instruction.md");
+  const instruction = existsSync4(instructionPath) ? readFileSync4(instructionPath, "utf-8") : "";
+  const parts = [];
+  parts.push("# Clarify Phase");
+  parts.push("");
+  parts.push("Your task is to identify any questions that need user input before generating the document.");
+  parts.push("Do NOT generate the document yet - only generate questions if needed.");
+  parts.push("");
+  parts.push("## Task Information");
+  parts.push("");
+  parts.push(`- **Task ID**: ${params.taskId}`);
+  parts.push(`- **Current Step**: ${params.step}`);
+  parts.push(`- **Description**: ${params.description}`);
+  parts.push("");
+  parts.push("## Gathered Context");
+  parts.push("");
+  parts.push(params.gatheredContext);
+  parts.push("");
+  if (instruction) {
+    parts.push("## Step Instruction");
+    parts.push("");
+    parts.push(instruction);
+    parts.push("");
   }
-  getStepInstructionPath(step) {
-    return join4(getStepsDir(this.cwd), step, "instruction.md");
+  if (params.previousQA && params.previousQA.length > 0) {
+    parts.push("## Previous Questions & Answers");
+    parts.push("");
+    parts.push("The following questions have already been asked and answered:");
+    parts.push("");
+    for (const entry of params.previousQA) {
+      parts.push(`**Q: ${entry.question.question}**`);
+      if (entry.question.context) {
+        parts.push(`Context: ${entry.question.context}`);
+      }
+      parts.push(`A: ${entry.answer.answer}`);
+      parts.push("");
+    }
+    parts.push("Based on these answers, determine if there are still ambiguities that need clarification.");
+    parts.push("Do NOT repeat questions that have already been answered.");
+    parts.push("");
   }
-  getStepTemplatePath(step) {
-    return join4(getStepsDir(this.cwd), step, "template.md");
+  parts.push("## Consider These Questions");
+  parts.push("");
+  parts.push("1. Is the task description clear enough to proceed?");
+  parts.push("2. Are there multiple valid approaches that need user decision?");
+  parts.push("3. Are there ambiguities that could lead to wrong implementation?");
+  parts.push("4. Are there missing requirements or constraints?");
+  parts.push("");
+  parts.push("## Output Format");
+  parts.push("");
+  parts.push("Output a JSON object with questions array:");
+  parts.push("");
+  parts.push("```json");
+  parts.push("{");
+  parts.push('  "questions": [');
+  parts.push("    {");
+  parts.push('      "id": "q1",');
+  parts.push('      "question": "Your specific question?",');
+  parts.push('      "context": "Why this matters for the document",');
+  parts.push('      "options": ["Option A", "Option B"]  // optional');
+  parts.push("    }");
+  parts.push("  ]");
+  parts.push("}");
+  parts.push("```");
+  parts.push("");
+  parts.push('If no questions are needed, return: `{"questions": []}`');
+  parts.push("");
+  parts.push("**Important:** Output ONLY the JSON, no other text.");
+  parts.push("");
+  return parts.join("\n");
+}
+function buildGeneratePrompt(params) {
+  const cwd = params.cwd || process.cwd();
+  const config = loadConfig(cwd);
+  const stepsDir = getStepsDir(cwd);
+  const outputsDir = getOutputsDir(cwd);
+  const isFirstStep = params.stepIndex === 1;
+  const prevStep = params.stepIndex > 1 ? config.steps[params.stepIndex - 2] : null;
+  const instructionPath = join4(stepsDir, params.step, "instruction.md");
+  const templatePath = join4(stepsDir, params.step, "template.md");
+  const outputPath = join4(outputsDir, params.taskId, `${params.step}.md`);
+  if (!existsSync4(instructionPath)) {
+    throw new Error(`Instruction not found: ${instructionPath}`);
   }
-  // ===========================================================================
-  // State Management
-  // ===========================================================================
-  loadState(taskId) {
-    const statePath = this.getStatePath(taskId);
-    if (!existsSync4(statePath)) {
-      return null;
+  const instruction = readFileSync4(instructionPath, "utf-8");
+  const template = existsSync4(templatePath) ? readFileSync4(templatePath, "utf-8") : null;
+  let previousSpec = null;
+  if (prevStep) {
+    const prevPath = join4(outputsDir, params.taskId, `${prevStep}.md`);
+    if (existsSync4(prevPath)) {
+      previousSpec = {
+        step: prevStep,
+        content: readFileSync4(prevPath, "utf-8")
+      };
     }
-    const data = JSON.parse(readFileSync4(statePath, "utf-8"));
-    return data;
   }
-  saveState(state) {
-    state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const statePath = this.getStatePath(state.taskId);
-    const dir = dirname2(statePath);
-    if (!existsSync4(dir)) {
-      mkdirSync3(dir, { recursive: true });
-    }
-    writeFileSync3(statePath, JSON.stringify(state, null, 2));
+  const parts = [];
+  parts.push("# Document Generation Phase");
+  parts.push("");
+  parts.push("Generate the document based on the gathered context and user answers.");
+  parts.push("");
+  parts.push("## Step Instruction");
+  parts.push("");
+  parts.push(instruction);
+  parts.push("");
+  if (template) {
+    parts.push("## Document Template");
+    parts.push("");
+    parts.push("**CRITICAL: You MUST follow this template structure completely.**");
+    parts.push("");
+    parts.push(template);
+    parts.push("");
   }
-  // ===========================================================================
-  // Spec Helpers
-  // ===========================================================================
-  checkUnresolvedQuestions(specPath) {
-    if (!existsSync4(specPath)) {
-      return [];
+  parts.push("## Gathered Context");
+  parts.push("");
+  parts.push(params.gatheredContext);
+  parts.push("");
+  if (params.answers && params.answers.length > 0) {
+    parts.push("## User Answers");
+    parts.push("");
+    for (const answer of params.answers) {
+      parts.push(`- **${answer.questionId}**: ${answer.answer}`);
     }
-    const content = readFileSync4(specPath, "utf-8");
-    const { data } = matter2(content);
-    const questions = [];
-    if (data.open_questions && Array.isArray(data.open_questions)) {
-      for (let i = 0; i < data.open_questions.length; i++) {
+    parts.push("");
+  }
+  if (isFirstStep) {
+    parts.push("## User Request");
+    parts.push("");
+    parts.push(`> ${params.description}`);
+    parts.push("");
+  } else if (previousSpec) {
+    parts.push(`## Input: ${previousSpec.step}.md`);
+    parts.push("");
+    parts.push(previousSpec.content);
+    parts.push("");
+  }
+  parts.push("## Task Context");
+  parts.push("");
+  parts.push(`- **Task ID**: ${params.taskId}`);
+  parts.push(`- **Current Step**: ${params.step} (${params.stepIndex}/${params.totalSteps})`);
+  parts.push("");
+  if (params.revisionFeedback) {
+    parts.push("## Revision Feedback");
+    parts.push("");
+    parts.push("Previous version was not approved. Please revise based on this feedback:");
+    parts.push("");
+    parts.push(`> ${params.revisionFeedback}`);
+    parts.push("");
+  }
+  parts.push("## Output Instructions");
+  parts.push("");
+  parts.push(`Generate the document and save to: \`${outputPath}\``);
+  parts.push("");
+  parts.push("**Required frontmatter:**");
+  parts.push("```yaml");
+  parts.push("---");
+  parts.push(`id: ${params.taskId}`);
+  parts.push(`step: ${params.step}`);
+  parts.push("status: pending_approval");
+  parts.push("---");
+  parts.push("```");
+  parts.push("");
+  return {
+    prompt: parts.join("\n"),
+    outputPath
+  };
+}
+function buildSectionPrompt(params) {
+  const { section, sharedContext, gatheredContext, answers } = params;
+  const parts = [];
+  parts.push(`# Section: ${section.title}`);
+  parts.push("");
+  parts.push("## Document Context");
+  parts.push("");
+  parts.push(`**Goal:** ${sharedContext.documentGoal}`);
+  parts.push(`**Step:** ${sharedContext.stepName}`);
+  parts.push(`**Total Sections:** ${sharedContext.totalSections}`);
+  parts.push("");
+  parts.push("## Document Structure");
+  parts.push("");
+  parts.push("```");
+  parts.push(sharedContext.treeOverview);
+  parts.push("```");
+  parts.push("");
+  parts.push("## Your Position");
+  parts.push("");
+  parts.push(`- **Path:** ${section.position.path.join(" > ")}`);
+  parts.push(`- **Siblings:** ${section.position.siblings.join(", ") || "None"}`);
+  parts.push(`- **Parent:** ${section.position.parent || "Root"}`);
+  parts.push("");
+  if (gatheredContext) {
+    parts.push("## Gathered Context");
+    parts.push("");
+    parts.push(gatheredContext);
+    parts.push("");
+  }
+  if (answers && answers.length > 0) {
+    parts.push("## User Answers");
+    parts.push("");
+    for (const answer of answers) {
+      parts.push(`- **${answer.questionId}**: ${answer.answer}`);
+    }
+    parts.push("");
+  }
+  if (section.templateContent) {
+    parts.push("## Template Guide");
+    parts.push("");
+    parts.push(section.templateContent);
+    parts.push("");
+  }
+  parts.push("## Your Task");
+  parts.push("");
+  parts.push(`Write the "${section.title.replace(/^#+\\s*/, "")}" section.`);
+  parts.push("Consider how it relates to sibling sections and contributes to the parent section.");
+  parts.push("");
+  parts.push("## Output");
+  parts.push("");
+  parts.push(`Save to: \`${section.outputPath}\``);
+  parts.push("");
+  parts.push("Write ONLY the content for this section (including its header).");
+  parts.push("Do NOT include content from other sections.");
+  parts.push("");
+  return {
+    prompt: parts.join("\n"),
+    outputPath: section.outputPath
+  };
+}
+function buildConsolidatePrompt(params) {
+  const { group, childContents, sharedContext, parentTitle } = params;
+  const parts = [];
+  parts.push("# Consolidate Sections");
+  parts.push("");
+  parts.push("## Document Context");
+  parts.push("");
+  parts.push(`**Goal:** ${sharedContext.documentGoal}`);
+  parts.push(`**Step:** ${sharedContext.stepName}`);
+  parts.push("");
+  parts.push("## Document Structure");
+  parts.push("");
+  parts.push("```");
+  parts.push(sharedContext.treeOverview);
+  parts.push("```");
+  parts.push("");
+  parts.push("## Your Task");
+  parts.push("");
+  parts.push(`Consolidate the following child sections into the parent section "${parentTitle || group.parentId}".`);
+  parts.push("");
+  parts.push("## Child Sections to Consolidate");
+  parts.push("");
+  for (const child of childContents) {
+    parts.push(`### Child: ${child.id}`);
+    parts.push("");
+    parts.push(child.content);
+    parts.push("");
+    parts.push("---");
+    parts.push("");
+  }
+  parts.push("## Output Instructions");
+  parts.push("");
+  parts.push(`Save consolidated content to: \`${group.outputPath}\``);
+  parts.push("");
+  parts.push("**Guidelines:**");
+  parts.push("- Combine child sections into a coherent parent section");
+  parts.push("- Maintain the hierarchy (parent header, then children)");
+  parts.push("- Ensure smooth transitions between sections");
+  parts.push("- Preserve all content from child sections");
+  parts.push("");
+  return {
+    prompt: parts.join("\n"),
+    outputPath: group.outputPath
+  };
+}
+function buildExecutePrompt(params) {
+  const cwd = params.cwd || process.cwd();
+  const config = loadConfig(cwd);
+  const stepsDir = getStepsDir(cwd);
+  const outputsDir = getOutputsDir(cwd);
+  const isFirstStep = params.stepIndex === 1;
+  const prevStep = params.stepIndex > 1 ? config.steps[params.stepIndex - 2] : null;
+  const instructionPath = join4(stepsDir, params.step, "instruction.md");
+  const templatePath = join4(stepsDir, params.step, "template.md");
+  const outputPath = join4(outputsDir, params.taskId, `${params.step}.md`);
+  if (!existsSync4(instructionPath)) {
+    throw new Error(`Instruction not found: ${instructionPath}`);
+  }
+  const instruction = readFileSync4(instructionPath, "utf-8");
+  const template = existsSync4(templatePath) ? readFileSync4(templatePath, "utf-8") : null;
+  let previousSpec = null;
+  if (prevStep) {
+    const prevPath = join4(outputsDir, params.taskId, `${prevStep}.md`);
+    if (existsSync4(prevPath)) {
+      previousSpec = {
+        step: prevStep,
+        content: readFileSync4(prevPath, "utf-8")
+      };
+    }
+  }
+  const parts = [];
+  parts.push("# Execute Phase - Document/Code Generation");
+  parts.push("");
+  parts.push("Generate the document/code based on the explored context and user answers.");
+  parts.push("");
+  parts.push("## Step Instruction");
+  parts.push("");
+  parts.push(instruction);
+  parts.push("");
+  if (template) {
+    parts.push("## Document Template");
+    parts.push("");
+    parts.push("**CRITICAL: You MUST follow this template structure completely.**");
+    parts.push("");
+    parts.push(template);
+    parts.push("");
+  }
+  parts.push("## Explored Context");
+  parts.push("");
+  parts.push(`### Summary`);
+  parts.push(params.exploreOutput.summary);
+  parts.push("");
+  if (params.exploreOutput.relevantFiles.length > 0) {
+    parts.push("### Relevant Files");
+    for (const file of params.exploreOutput.relevantFiles) {
+      parts.push(`- **${file.path}**: ${file.purpose}`);
+      if (file.keySnippets && file.keySnippets.length > 0) {
+        parts.push("  ```");
+        parts.push("  " + file.keySnippets.slice(0, 2).join("\n  "));
+        parts.push("  ```");
+      }
+    }
+    parts.push("");
+  }
+  if (params.exploreOutput.patterns.length > 0) {
+    parts.push("### Patterns");
+    for (const pattern of params.exploreOutput.patterns) {
+      parts.push(`- ${pattern}`);
+    }
+    parts.push("");
+  }
+  if (params.exploreOutput.constraints.length > 0) {
+    parts.push("### Constraints");
+    for (const constraint of params.exploreOutput.constraints) {
+      parts.push(`- ${constraint}`);
+    }
+    parts.push("");
+  }
+  if (params.exploreOutput.dependencies.length > 0) {
+    parts.push("### Dependencies");
+    for (const dep of params.exploreOutput.dependencies) {
+      parts.push(`- ${dep}`);
+    }
+    parts.push("");
+  }
+  if (params.answers && params.answers.length > 0) {
+    parts.push("## User Answers");
+    parts.push("");
+    for (const answer of params.answers) {
+      parts.push(`- **${answer.questionId}**: ${answer.answer}`);
+    }
+    parts.push("");
+  }
+  if (isFirstStep) {
+    parts.push("## User Request");
+    parts.push("");
+    parts.push(`> ${params.description}`);
+    parts.push("");
+  } else if (previousSpec) {
+    parts.push(`## Input: ${previousSpec.step}.md`);
+    parts.push("");
+    parts.push(previousSpec.content);
+    parts.push("");
+  }
+  parts.push("## Task Context");
+  parts.push("");
+  parts.push(`- **Task ID**: ${params.taskId}`);
+  parts.push(`- **Current Step**: ${params.step} (${params.stepIndex}/${params.totalSteps})`);
+  parts.push("");
+  if (params.verifyFeedback) {
+    parts.push("## Auto-Fix Required");
+    parts.push("");
+    parts.push("**Previous draft failed verification. Fix these issues:**");
+    parts.push("");
+    parts.push(params.verifyFeedback);
+    parts.push("");
+  }
+  if (params.revisionFeedback) {
+    parts.push("## Revision Feedback");
+    parts.push("");
+    parts.push("Previous version was not approved. Please revise based on this feedback:");
+    parts.push("");
+    parts.push(`> ${params.revisionFeedback}`);
+    parts.push("");
+  }
+  parts.push("## Output Instructions");
+  parts.push("");
+  parts.push(`Generate the document and save to: \`${outputPath}\``);
+  parts.push("");
+  parts.push("**Required frontmatter:**");
+  parts.push("```yaml");
+  parts.push("---");
+  parts.push(`id: ${params.taskId}`);
+  parts.push(`step: ${params.step}`);
+  parts.push("status: pending_approval");
+  parts.push("---");
+  parts.push("```");
+  parts.push("");
+  return {
+    prompt: parts.join("\n"),
+    outputPath
+  };
+}
+function buildVerifyPrompt(params) {
+  const cwd = params.cwd || process.cwd();
+  const stepsDir = getStepsDir(cwd);
+  const instructionPath = join4(stepsDir, params.step, "instruction.md");
+  const templatePath = join4(stepsDir, params.step, "template.md");
+  const instruction = existsSync4(instructionPath) ? readFileSync4(instructionPath, "utf-8") : "";
+  const template = existsSync4(templatePath) ? readFileSync4(templatePath, "utf-8") : "";
+  const document = existsSync4(params.documentPath) ? readFileSync4(params.documentPath, "utf-8") : "";
+  const parts = [];
+  parts.push("# Verify Phase - Self-Validation");
+  parts.push("");
+  parts.push("Your task is to validate the generated document against the requirements.");
+  parts.push("This is an automated quality check before human review.");
+  parts.push("");
+  parts.push(`**Attempt ${params.verifyAttempts} of 3**`);
+  parts.push("");
+  parts.push("## Task Information");
+  parts.push("");
+  parts.push(`- **Task ID**: ${params.taskId}`);
+  parts.push(`- **Current Step**: ${params.step} (${params.stepIndex}/${params.totalSteps})`);
+  parts.push("");
+  parts.push("## Document to Verify");
+  parts.push("");
+  parts.push("```markdown");
+  parts.push(document);
+  parts.push("```");
+  parts.push("");
+  parts.push("## Requirements (Instruction)");
+  parts.push("");
+  if (instruction) {
+    parts.push(instruction);
+  } else {
+    parts.push("(No instruction found)");
+  }
+  parts.push("");
+  if (template) {
+    parts.push("## Expected Structure (Template)");
+    parts.push("");
+    parts.push(template);
+    parts.push("");
+  }
+  parts.push("## Verification Checklist");
+  parts.push("");
+  parts.push("Evaluate the document against these criteria:");
+  parts.push("");
+  parts.push("1. **Requirements Coverage** (0-100)");
+  parts.push("   - Does the document address all requirements from the instruction?");
+  parts.push("   - Are there missing pieces?");
+  parts.push("");
+  parts.push("2. **Template Compliance** (0-100)");
+  parts.push("   - Does it follow the template structure?");
+  parts.push("   - Are all required sections present?");
+  parts.push("   - Is frontmatter correct?");
+  parts.push("");
+  parts.push("3. **Consistency** (0-100)");
+  parts.push("   - Is terminology consistent throughout?");
+  parts.push("   - Are there contradictions?");
+  parts.push("   - Does it align with explored codebase patterns?");
+  parts.push("");
+  parts.push("4. **Completeness** (0-100)");
+  parts.push("   - Are all sections fully filled in?");
+  parts.push("   - Are there placeholder texts or TODOs?");
+  parts.push("   - Is there enough detail?");
+  parts.push("");
+  parts.push("## Pass Criteria");
+  parts.push("");
+  parts.push("The document passes if:");
+  parts.push("- ALL scores >= 70");
+  parts.push('- NO issues with severity "error"');
+  parts.push("");
+  parts.push("If it fails, the document will be automatically revised (up to 3 attempts).");
+  parts.push("");
+  parts.push("## Output Format");
+  parts.push("");
+  parts.push("Output a JSON object with this structure:");
+  parts.push("");
+  parts.push("```json");
+  parts.push("{");
+  parts.push('  "passed": true,');
+  parts.push('  "score": {');
+  parts.push('    "requirementsCoverage": 85,');
+  parts.push('    "templateCompliance": 90,');
+  parts.push('    "consistency": 80,');
+  parts.push('    "completeness": 75');
+  parts.push("  },");
+  parts.push('  "issues": [');
+  parts.push("    {");
+  parts.push('      "severity": "warning",');
+  parts.push('      "category": "completeness",');
+  parts.push('      "description": "Section X could use more detail",');
+  parts.push('      "suggestion": "Add examples for the edge cases"');
+  parts.push("    }");
+  parts.push("  ],");
+  parts.push('  "summary": "Document meets requirements with minor suggestions for improvement."');
+  parts.push("}");
+  parts.push("```");
+  parts.push("");
+  parts.push("**Important:** Output ONLY the JSON, no other text.");
+  parts.push("");
+  return parts.join("\n");
+}
+
+// src/orchestrator/index.ts
+var Orchestrator = class {
+  cwd;
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  // ===========================================================================
+  // Config & Path Helpers
+  // ===========================================================================
+  getSteps() {
+    const config = loadConfig(this.cwd);
+    return config.steps;
+  }
+  getOutputPath() {
+    return getOutputsDir(this.cwd);
+  }
+  getStatePath(taskId) {
+    return join5(this.getOutputPath(), taskId, ".state.json");
+  }
+  getSpecPath(taskId, step) {
+    return join5(this.getOutputPath(), taskId, `${step}.md`);
+  }
+  getStepInstructionPath(step) {
+    return join5(getStepsDir(this.cwd), step, "instruction.md");
+  }
+  getStepTemplatePath(step) {
+    return join5(getStepsDir(this.cwd), step, "template.md");
+  }
+  // ===========================================================================
+  // State Management
+  // ===========================================================================
+  loadState(taskId) {
+    const statePath = this.getStatePath(taskId);
+    if (!existsSync5(statePath)) {
+      return null;
+    }
+    const data = JSON.parse(readFileSync5(statePath, "utf-8"));
+    return data;
+  }
+  saveState(state) {
+    state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const statePath = this.getStatePath(state.taskId);
+    const dir = dirname2(statePath);
+    if (!existsSync5(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    writeFileSync3(statePath, JSON.stringify(state, null, 2));
+  }
+  // ===========================================================================
+  // Spec Helpers
+  // ===========================================================================
+  checkUnresolvedQuestions(specPath) {
+    if (!existsSync5(specPath)) {
+      return [];
+    }
+    const content = readFileSync5(specPath, "utf-8");
+    const { data } = matter2(content);
+    const questions = [];
+    if (data.open_questions && Array.isArray(data.open_questions)) {
+      for (let i = 0; i < data.open_questions.length; i++) {
         const q = data.open_questions[i];
         if (!q.resolved) {
           questions.push({
@@ -1013,6 +1679,7 @@ var Orchestrator = class {
   // ===========================================================================
   /**
    * Phase 1: Context gathering
+   * @deprecated Use responsePhaseExplore instead
    */
   responsePhaseContext(state) {
     const steps = this.getSteps();
@@ -1020,8 +1687,8 @@ var Orchestrator = class {
     let previousOutput;
     if (state.stepIndex > 1) {
       const prevStep = steps[state.stepIndex - 2];
-      const prevPath = join4(outputPath, state.taskId, `${prevStep}.md`);
-      if (existsSync4(prevPath)) {
+      const prevPath = join5(outputPath, state.taskId, `${prevStep}.md`);
+      if (existsSync5(prevPath)) {
         previousOutput = prevPath;
       }
     }
@@ -1040,16 +1707,64 @@ var Orchestrator = class {
       onComplete: `context-done ${state.taskId}`
     };
   }
+  /**
+   * Phase 1 (New): Deep codebase exploration
+   */
+  responsePhaseExplore(state) {
+    const steps = this.getSteps();
+    const outputPath = this.getOutputPath();
+    let previousOutput;
+    if (state.stepIndex > 1) {
+      const prevStep = steps[state.stepIndex - 2];
+      const prevPath = join5(outputPath, state.taskId, `${prevStep}.md`);
+      if (existsSync5(prevPath)) {
+        previousOutput = prevPath;
+      }
+    }
+    const prompt = buildExplorePrompt({
+      taskId: state.taskId,
+      step: state.currentStep,
+      description: state.description,
+      stepIndex: state.stepIndex,
+      totalSteps: state.totalSteps,
+      previousOutput,
+      cwd: this.cwd
+    });
+    return {
+      type: "phase",
+      phase: "explore",
+      step: state.currentStep,
+      stepIndex: state.stepIndex,
+      totalSteps: state.totalSteps,
+      taskId: state.taskId,
+      description: state.description,
+      prompt,
+      context: {
+        instruction: this.getStepInstructionPath(state.currentStep),
+        previousOutput
+      },
+      onComplete: `explore-done ${state.taskId}`
+    };
+  }
   /**
    * Phase 2: Question generation
    */
   responsePhaseClarify(state) {
+    const prompt = buildClarifyPrompt({
+      taskId: state.taskId,
+      step: state.currentStep,
+      description: state.description,
+      gatheredContext: state.context || "",
+      previousQA: state.qaHistory,
+      cwd: this.cwd
+    });
     return {
       type: "phase",
       phase: "clarify",
       step: state.currentStep,
       taskId: state.taskId,
       description: state.description,
+      prompt,
       gatheredContext: state.context || "",
       previousQA: state.qaHistory,
       context: {
@@ -1060,6 +1775,7 @@ var Orchestrator = class {
   }
   /**
    * Phase 3: Document generation
+   * @deprecated Use responsePhaseExecute instead
    */
   responsePhaseGenerate(state) {
     const steps = this.getSteps();
@@ -1067,13 +1783,13 @@ var Orchestrator = class {
     let previousOutput;
     if (state.stepIndex > 1) {
       const prevStep = steps[state.stepIndex - 2];
-      const prevPath = join4(outputPath, state.taskId, `${prevStep}.md`);
-      if (existsSync4(prevPath)) {
+      const prevPath = join5(outputPath, state.taskId, `${prevStep}.md`);
+      if (existsSync5(prevPath)) {
         previousOutput = prevPath;
       }
     }
     const templatePath = this.getStepTemplatePath(state.currentStep);
-    const hasTemplate = existsSync4(templatePath);
+    const hasTemplate = existsSync5(templatePath);
     return {
       type: "phase",
       phase: "generate",
@@ -1088,12 +1804,112 @@ var Orchestrator = class {
         instruction: this.getStepInstructionPath(state.currentStep),
         template: hasTemplate ? templatePath : void 0,
         previousOutput,
-        output: join4(outputPath, state.taskId, `${state.currentStep}.md`),
+        output: join5(outputPath, state.taskId, `${state.currentStep}.md`),
         revisionFeedback: state.revisionFeedback
       },
       onComplete: `generate-done ${state.taskId}`
     };
   }
+  /**
+   * Phase 3 (New): Document/code generation with explore output
+   */
+  responsePhaseExecute(state) {
+    const steps = this.getSteps();
+    const outputPath = this.getOutputPath();
+    let previousOutput;
+    if (state.stepIndex > 1) {
+      const prevStep = steps[state.stepIndex - 2];
+      const prevPath = join5(outputPath, state.taskId, `${prevStep}.md`);
+      if (existsSync5(prevPath)) {
+        previousOutput = prevPath;
+      }
+    }
+    const templatePath = this.getStepTemplatePath(state.currentStep);
+    const hasTemplate = existsSync5(templatePath);
+    let verifyFeedback;
+    if (state.verifyOutput && !state.verifyOutput.passed && state.verifyAttempts && state.verifyAttempts > 1) {
+      const issues = state.verifyOutput.issues.filter((i) => i.severity === "error").map((i) => `- [${i.category}] ${i.description}${i.suggestion ? ` \u2192 ${i.suggestion}` : ""}`).join("\n");
+      verifyFeedback = `Auto-fix attempt ${state.verifyAttempts}/3. Fix these issues:
+${issues}`;
+    }
+    const exploreOutput = state.exploreOutput || {
+      summary: state.context || "",
+      relevantFiles: [],
+      patterns: [],
+      constraints: [],
+      dependencies: []
+    };
+    const { prompt } = buildExecutePrompt({
+      taskId: state.taskId,
+      step: state.currentStep,
+      description: state.description,
+      stepIndex: state.stepIndex,
+      totalSteps: state.totalSteps,
+      exploreOutput,
+      answers: state.answers,
+      revisionFeedback: state.revisionFeedback,
+      verifyFeedback,
+      cwd: this.cwd
+    });
+    return {
+      type: "phase",
+      phase: "execute",
+      step: state.currentStep,
+      stepIndex: state.stepIndex,
+      totalSteps: state.totalSteps,
+      taskId: state.taskId,
+      description: state.description,
+      prompt,
+      exploreOutput,
+      answers: state.answers,
+      context: {
+        instruction: this.getStepInstructionPath(state.currentStep),
+        template: hasTemplate ? templatePath : void 0,
+        previousOutput,
+        output: join5(outputPath, state.taskId, `${state.currentStep}.md`),
+        revisionFeedback: state.revisionFeedback,
+        verifyFeedback
+      },
+      onComplete: `execute-done ${state.taskId}`
+    };
+  }
+  /**
+   * Phase 4 (New): Self-validation
+   */
+  responsePhaseVerify(state) {
+    const outputPath = this.getOutputPath();
+    const templatePath = this.getStepTemplatePath(state.currentStep);
+    const hasTemplate = existsSync5(templatePath);
+    const documentPath = join5(outputPath, state.taskId, `${state.currentStep}.md`);
+    const prompt = buildVerifyPrompt({
+      taskId: state.taskId,
+      step: state.currentStep,
+      description: state.description,
+      stepIndex: state.stepIndex,
+      totalSteps: state.totalSteps,
+      documentPath,
+      verifyAttempts: state.verifyAttempts || 1,
+      cwd: this.cwd
+    });
+    return {
+      type: "phase",
+      phase: "verify",
+      step: state.currentStep,
+      stepIndex: state.stepIndex,
+      totalSteps: state.totalSteps,
+      taskId: state.taskId,
+      description: state.description,
+      prompt,
+      verifyAttempts: state.verifyAttempts || 1,
+      maxAttempts: 3,
+      context: {
+        instruction: this.getStepInstructionPath(state.currentStep),
+        template: hasTemplate ? templatePath : void 0,
+        document: documentPath
+      },
+      onComplete: `verify-done ${state.taskId}`
+    };
+  }
   /**
    * Phase 3 (section mode): Parallel section generation
    */
@@ -1106,15 +1922,15 @@ var Orchestrator = class {
     let previousOutput;
     if (state.stepIndex > 1) {
       const prevStep = steps[state.stepIndex - 2];
-      const prevPath = join4(outputPath, state.taskId, `${prevStep}.md`);
-      if (existsSync4(prevPath)) {
+      const prevPath = join5(outputPath, state.taskId, `${prevStep}.md`);
+      if (existsSync5(prevPath)) {
         previousOutput = prevPath;
       }
     }
     const parallelSections = state.sectionPlan.leaves.map((leaf) => ({
       id: leaf.id,
       title: leaf.title,
-      outputPath: join4(outputPath, state.taskId, leaf.outputPath),
+      outputPath: join5(outputPath, state.taskId, leaf.outputPath),
       instruction: buildSectionInstruction(leaf, state.sectionPlan.sharedContext),
       position: {
         path: leaf.position.path,
@@ -1138,7 +1954,7 @@ var Orchestrator = class {
         instruction: this.getStepInstructionPath(state.currentStep),
         template: this.getStepTemplatePath(state.currentStep),
         previousOutput,
-        outputDir: join4(outputPath, state.taskId, "sections", state.currentStep)
+        outputDir: join5(outputPath, state.taskId, "sections", state.currentStep)
       },
       onComplete: `sections-done ${state.taskId}`
     };
@@ -1153,7 +1969,7 @@ var Orchestrator = class {
     const outputPath = this.getOutputPath();
     const parallelGroups = level.groups.map((group) => ({
       ...group,
-      outputPath: join4(outputPath, state.taskId, group.outputPath)
+      outputPath: join5(outputPath, state.taskId, group.outputPath)
     }));
     return {
       type: "phase",
@@ -1195,11 +2011,11 @@ var Orchestrator = class {
           missing.push(childId);
           continue;
         }
-        const fullPath = join4(outputPath, state.taskId, childPath);
-        if (!existsSync4(fullPath)) {
+        const fullPath = join5(outputPath, state.taskId, childPath);
+        if (!existsSync5(fullPath)) {
           missing.push(childId);
         } else {
-          const content = readFileSync4(fullPath, "utf-8");
+          const content = readFileSync5(fullPath, "utf-8");
           if (!content.trim()) {
             warnings.push(`Empty section file: ${childId}`);
           }
@@ -1244,7 +2060,7 @@ var Orchestrator = class {
       step: state.currentStep,
       stepIndex: state.stepIndex,
       totalSteps: state.totalSteps,
-      specPath: join4(outputPath, state.taskId, `${state.currentStep}.md`),
+      specPath: join5(outputPath, state.taskId, `${state.currentStep}.md`),
       options: ["approve", "revise", "reject", "stop"],
       onComplete: {
         approve: `approve ${state.taskId}`,
@@ -1259,8 +2075,8 @@ var Orchestrator = class {
     const outputPath = this.getOutputPath();
     const outputs = [];
     for (let i = 0; i < state.stepIndex; i++) {
-      const specPath = join4(outputPath, state.taskId, `${steps[i]}.md`);
-      if (existsSync4(specPath)) {
+      const specPath = join5(outputPath, state.taskId, `${steps[i]}.md`);
+      if (existsSync5(specPath)) {
         outputs.push(specPath);
       }
     }
@@ -1287,7 +2103,7 @@ var Orchestrator = class {
   // Command Handlers
   // ===========================================================================
   /**
-   * Initialize a new workflow - starts at phase_context
+   * Initialize a new workflow - starts at phase_explore
    */
   cmdInit(description) {
     try {
@@ -1299,18 +2115,19 @@ var Orchestrator = class {
         currentStep: steps[0],
         stepIndex: 1,
         totalSteps: steps.length,
-        status: "phase_context",
-        phase: "context",
+        status: "phase_explore",
+        phase: "explore",
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       this.saveState(state);
-      return this.responsePhaseContext(state);
+      return this.responsePhaseExplore(state);
     } catch (e) {
       return this.responseError(e.message);
     }
   }
   /**
    * Phase 1 complete: Context gathered, move to clarify phase
+   * @deprecated Use cmdExploreDone instead
    */
   cmdContextDone(taskId, context) {
     const state = this.loadState(taskId);
@@ -1323,10 +2140,25 @@ var Orchestrator = class {
     this.saveState(state);
     return this.responsePhaseClarify(state);
   }
+  /**
+   * Phase 1 complete (New): Exploration complete, move to clarify phase
+   */
+  cmdExploreDone(taskId, exploreOutput) {
+    const state = this.loadState(taskId);
+    if (!state) {
+      return this.responseError(`No workflow found: ${taskId}`, taskId);
+    }
+    state.exploreOutput = exploreOutput;
+    state.context = JSON.stringify(exploreOutput);
+    state.status = "phase_clarify";
+    state.phase = "clarify";
+    this.saveState(state);
+    return this.responsePhaseClarify(state);
+  }
   /**
    * Phase 2 complete: Questions generated (or none)
    * If questions exist → checkpoint
-   * If no questions → move to generate phase with accumulated answers
+   * If no questions → move to draft phase with accumulated answers
    */
   cmdClarifyDone(taskId, questions) {
     const state = this.loadState(taskId);
@@ -1344,14 +2176,15 @@ var Orchestrator = class {
     this.initSectionPlan(state);
     if (state.sectionPlan) {
       state.status = "phase_sections";
-      state.phase = "generate";
+      state.phase = "draft";
       this.saveState(state);
       return this.responsePhaseGenerateSections(state);
     }
-    state.status = "phase_generate";
-    state.phase = "generate";
+    state.status = "phase_execute";
+    state.phase = "draft";
+    state.verifyAttempts = 0;
     this.saveState(state);
-    return this.responsePhaseGenerate(state);
+    return this.responsePhaseExecute(state);
   }
   /**
    * Human answered questions, loop back to clarify phase
@@ -1376,6 +2209,7 @@ var Orchestrator = class {
   }
   /**
    * Phase 3 complete: Document generated, move to approve checkpoint
+   * @deprecated Use cmdExecuteDone instead for new workflow
    */
   cmdGenerateDone(taskId) {
     const state = this.loadState(taskId);
@@ -1383,7 +2217,7 @@ var Orchestrator = class {
       return this.responseError(`No workflow found: ${taskId}`, taskId);
     }
     const specPath = this.getSpecPath(taskId, state.currentStep);
-    if (!existsSync4(specPath)) {
+    if (!existsSync5(specPath)) {
       return this.responseError(`Document not found: ${specPath}`, taskId, state.currentStep);
     }
     state.status = "approve_pending";
@@ -1392,209 +2226,79 @@ var Orchestrator = class {
     return this.responseCheckpointApprove(state);
   }
   /**
-   * @deprecated Use cmdContextDone, cmdClarifyDone, cmdGenerateDone instead
-   */
-  cmdDone(taskId) {
-    const state = this.loadState(taskId);
-    if (!state) {
-      return this.responseError(`No workflow found: ${taskId}`, taskId);
-    }
-    const specPath = this.getSpecPath(taskId, state.currentStep);
-    if (!existsSync4(specPath)) {
-      return this.responseError(`Spec not found: ${specPath}`, taskId, state.currentStep);
-    }
-    const questions = this.checkUnresolvedQuestions(specPath);
-    if (questions.length > 0) {
-      state.questions = questions;
-      state.status = "clarify_pending";
-      state.phase = "clarify";
-      this.saveState(state);
-      return this.responseCheckpointClarify(state);
-    }
-    state.status = "approve_pending";
-    state.phase = "review";
-    this.saveState(state);
-    return this.responseCheckpointApprove(state);
-  }
-  /**
-   * Approve current step and move to next
-   */
-  cmdApprove(taskId) {
-    const state = this.loadState(taskId);
-    if (!state) {
-      return this.responseError(`No workflow found: ${taskId}`, taskId);
-    }
-    const steps = this.getSteps();
-    const specPath = this.getSpecPath(taskId, state.currentStep);
-    if (existsSync4(specPath)) {
-      const content = readFileSync4(specPath, "utf-8");
-      const { content: body, data } = matter2(content);
-      data.status = "approved";
-      data.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-      writeFileSync3(specPath, matter2.stringify(body, data));
-    }
-    if (state.stepIndex < state.totalSteps) {
-      state.currentStep = steps[state.stepIndex];
-      state.stepIndex += 1;
-      state.status = "phase_context";
-      state.phase = "context";
-      state.context = void 0;
-      state.questions = void 0;
-      state.answers = void 0;
-      state.qaHistory = void 0;
-      state.revisionFeedback = void 0;
-      this.saveState(state);
-      return this.responsePhaseContext(state);
-    } else {
-      state.status = "completed";
-      this.saveState(state);
-      return this.responseComplete(state, "completed");
-    }
-  }
-  /**
-   * Request revision with feedback - goes back to generate phase
-   */
-  cmdRevise(taskId, feedback) {
-    const state = this.loadState(taskId);
-    if (!state) {
-      return this.responseError(`No workflow found: ${taskId}`, taskId);
-    }
-    state.status = "phase_generate";
-    state.phase = "generate";
-    state.revisionFeedback = feedback;
-    this.saveState(state);
-    return this.responsePhaseGenerate(state);
-  }
-  /**
-   * Reject and stop workflow
+   * Phase 3 complete (New): Execution complete, move to verify phase
    */
-  cmdReject(taskId) {
+  cmdExecuteDone(taskId) {
     const state = this.loadState(taskId);
     if (!state) {
       return this.responseError(`No workflow found: ${taskId}`, taskId);
     }
     const specPath = this.getSpecPath(taskId, state.currentStep);
-    if (existsSync4(specPath)) {
-      const content = readFileSync4(specPath, "utf-8");
-      const { content: body, data } = matter2(content);
-      data.status = "rejected";
-      data.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-      writeFileSync3(specPath, matter2.stringify(body, data));
-    }
-    state.status = "rejected";
-    this.saveState(state);
-    return this.responseComplete(state, "rejected");
-  }
-  /**
-   * Stop workflow (can resume later)
-   */
-  cmdStop(taskId) {
-    const state = this.loadState(taskId);
-    if (!state) {
-      return this.responseError(`No workflow found: ${taskId}`, taskId);
+    if (!existsSync5(specPath)) {
+      return this.responseError(`Document not found: ${specPath}`, taskId, state.currentStep);
     }
-    state.status = "stopped";
+    state.status = "phase_verify";
+    state.phase = "verify";
+    state.verifyAttempts = (state.verifyAttempts || 0) + 1;
     this.saveState(state);
-    return this.responseComplete(state, "stopped");
+    return this.responsePhaseVerify(state);
   }
-  // ===========================================================================
-  // Section-based Workflow Commands
-  // ===========================================================================
   /**
-   * Initialize section-based generation for current step
-   * Called internally when template has sections
+   * @deprecated Use cmdExecuteDone instead
    */
-  initSectionPlan(state) {
-    const templatePath = this.getStepTemplatePath(state.currentStep);
-    if (!existsSync4(templatePath)) {
-      return;
-    }
-    const template = readFileSync4(templatePath, "utf-8");
-    const instructionPath = this.getStepInstructionPath(state.currentStep);
-    const instructionSummary = existsSync4(instructionPath) ? readFileSync4(instructionPath, "utf-8").slice(0, 500) : "";
-    const plan = parseTemplateToTree(
-      template,
-      state.currentStep,
-      state.description,
-      `sections/${state.currentStep}`,
-      instructionSummary
-    );
-    if (plan.leaves.length > 1) {
-      state.sectionPlan = plan;
-      state.sectionStatuses = plan.leaves.map((leaf) => ({
-        id: leaf.id,
-        status: "pending",
-        outputPath: leaf.outputPath
-      }));
-      state.consolidateProgress = {
-        currentLevel: 0,
-        completedLevels: [],
-        totalLevels: plan.consolidateLevels.length
-      };
-    }
+  cmdDraftDone(taskId) {
+    return this.cmdExecuteDone(taskId);
   }
   /**
-   * All sections completed, move to consolidation
+   * Phase 4 complete (New): Verification done
+   * If passed → approve_pending
+   * If failed → phase_execute (auto-fix, max 3 attempts)
+   * If max attempts reached → approve_pending with warning
    */
-  cmdSectionsDone(taskId) {
+  cmdVerifyDone(taskId, verifyOutput) {
     const state = this.loadState(taskId);
     if (!state) {
       return this.responseError(`No workflow found: ${taskId}`, taskId);
     }
-    if (!state.sectionPlan || !state.consolidateProgress) {
-      return this.responseError("No section plan found", taskId, state.currentStep);
-    }
-    if (state.sectionStatuses) {
-      state.sectionStatuses = state.sectionStatuses.map((s) => ({
-        ...s,
-        status: "completed"
-      }));
+    state.verifyOutput = verifyOutput;
+    if (verifyOutput.passed) {
+      state.status = "approve_pending";
+      state.phase = "review";
+      this.saveState(state);
+      return this.responseCheckpointApprove(state);
     }
-    if (state.consolidateProgress.totalLevels > 0) {
-      state.status = "phase_consolidate";
-      state.consolidateProgress.currentLevel = 0;
+    const attempts = state.verifyAttempts || 1;
+    if (attempts >= 3) {
+      state.status = "approve_pending";
+      state.phase = "review";
       this.saveState(state);
-      const firstLevel = state.sectionPlan.consolidateLevels[0];
-      const validation = this.validateConsolidateReady(state, firstLevel);
-      if (!validation.valid) {
-        return this.responseError(
-          validation.error || "Validation failed",
-          taskId,
-          state.currentStep
-        );
-      }
-      return this.responsePhaseConsolidate(state, firstLevel);
+      const response = this.responseCheckpointApprove(state);
+      return response;
     }
-    state.status = "approve_pending";
-    state.phase = "review";
+    state.status = "phase_execute";
+    state.phase = "draft";
     this.saveState(state);
-    return this.responseCheckpointApprove(state);
+    return this.responsePhaseExecute(state);
   }
   /**
-   * Consolidation level completed, move to next level or approve
+   * @deprecated Use cmdExploreDone, cmdClarifyDone, cmdExecuteDone, cmdVerifyDone instead
    */
-  cmdConsolidateLevelDone(taskId, level) {
+  cmdDone(taskId) {
     const state = this.loadState(taskId);
     if (!state) {
       return this.responseError(`No workflow found: ${taskId}`, taskId);
     }
-    if (!state.sectionPlan || !state.consolidateProgress) {
-      return this.responseError("No section plan found", taskId, state.currentStep);
+    const specPath = this.getSpecPath(taskId, state.currentStep);
+    if (!existsSync5(specPath)) {
+      return this.responseError(`Spec not found: ${specPath}`, taskId, state.currentStep);
     }
-    state.consolidateProgress.completedLevels.push(level);
-    state.consolidateProgress.currentLevel++;
-    if (state.consolidateProgress.currentLevel < state.consolidateProgress.totalLevels) {
+    const questions = this.checkUnresolvedQuestions(specPath);
+    if (questions.length > 0) {
+      state.questions = questions;
+      state.status = "clarify_pending";
+      state.phase = "clarify";
       this.saveState(state);
-      const nextLevel = state.sectionPlan.consolidateLevels[state.consolidateProgress.currentLevel];
-      const validation = this.validateConsolidateReady(state, nextLevel);
-      if (!validation.valid) {
-        return this.responseError(
-          validation.error || "Validation failed",
-          taskId,
-          state.currentStep
-        );
-      }
-      return this.responsePhaseConsolidate(state, nextLevel);
+      return this.responseCheckpointClarify(state);
     }
     state.status = "approve_pending";
     state.phase = "review";
@@ -1602,394 +2306,261 @@ var Orchestrator = class {
     return this.responseCheckpointApprove(state);
   }
   /**
-   * Get current workflow status
+   * Approve current step and move to next
    */
-  cmdStatus(taskId) {
+  cmdApprove(taskId) {
     const state = this.loadState(taskId);
     if (!state) {
       return this.responseError(`No workflow found: ${taskId}`, taskId);
     }
-    switch (state.status) {
-      case "phase_context":
-        return this.responsePhaseContext(state);
-      case "phase_clarify":
-        return this.responsePhaseClarify(state);
-      case "clarify_pending":
-        return this.responseCheckpointClarify(state);
-      case "phase_generate":
-        return this.responsePhaseGenerate(state);
-      case "phase_sections":
-        return this.responsePhaseGenerateSections(state);
-      case "phase_consolidate":
-        if (state.sectionPlan && state.consolidateProgress) {
-          const level = state.sectionPlan.consolidateLevels[state.consolidateProgress.currentLevel];
-          return this.responsePhaseConsolidate(state, level);
-        }
-        return this.responseError("Invalid consolidate state", taskId);
-      case "approve_pending":
-        return this.responseCheckpointApprove(state);
-      case "completed":
-      case "stopped":
-      case "rejected":
-        return this.responseComplete(state, state.status);
-      default:
-        return this.responseError(`Unknown status: ${state.status}`, taskId);
-    }
-  }
-};
-
-// src/core/step-executor.ts
-import { existsSync as existsSync6, writeFileSync as writeFileSync4 } from "fs";
-import matter3 from "gray-matter";
-
-// src/core/prompt-builder.ts
-import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
-import { join as join5 } from "path";
-function buildContextPrompt(params) {
-  const cwd = params.cwd || process.cwd();
-  const stepsDir = getStepsDir(cwd);
-  const isFirstStep = params.stepIndex === 1;
-  const instructionPath = join5(stepsDir, params.step, "instruction.md");
-  const instruction = existsSync5(instructionPath) ? readFileSync5(instructionPath, "utf-8") : "";
-  const parts = [];
-  parts.push("# Context Gathering Phase");
-  parts.push("");
-  parts.push("Your task is to gather context before generating a document.");
-  parts.push("Do NOT generate the document yet - only gather information.");
-  parts.push("");
-  parts.push("## Task Information");
-  parts.push("");
-  parts.push(`- **Task ID**: ${params.taskId}`);
-  parts.push(`- **Current Step**: ${params.step} (${params.stepIndex}/${params.totalSteps})`);
-  parts.push("");
-  if (isFirstStep) {
-    parts.push("## User Request");
-    parts.push("");
-    parts.push(`> ${params.description}`);
-    parts.push("");
-  } else if (params.previousOutput) {
-    parts.push("## Previous Step Output");
-    parts.push("");
-    if (existsSync5(params.previousOutput)) {
-      parts.push(readFileSync5(params.previousOutput, "utf-8"));
-    }
-    parts.push("");
-  }
-  if (instruction) {
-    parts.push("## Step Instruction (Preview)");
-    parts.push("");
-    parts.push("The next phase will use this instruction to generate a document:");
-    parts.push("");
-    parts.push("```");
-    parts.push(instruction.slice(0, 500) + (instruction.length > 500 ? "..." : ""));
-    parts.push("```");
-    parts.push("");
-  }
-  parts.push("## Your Task");
-  parts.push("");
-  parts.push("1. **Analyze** the request/input to understand what is being asked");
-  parts.push("2. **Search** the codebase for relevant files, patterns, conventions");
-  parts.push("3. **Identify** key constraints, dependencies, and considerations");
-  parts.push("");
-  parts.push("## Output Format");
-  parts.push("");
-  parts.push("Output a JSON object with this structure:");
-  parts.push("");
-  parts.push("```json");
-  parts.push("{");
-  parts.push('  "summary": "Brief summary of what you understood and found",');
-  parts.push('  "relevantFiles": ["path/to/file1.ts", "path/to/file2.ts"],');
-  parts.push('  "keyFindings": [');
-  parts.push('    "Finding 1: description",');
-  parts.push('    "Finding 2: description"');
-  parts.push("  ]");
-  parts.push("}");
-  parts.push("```");
-  parts.push("");
-  parts.push("**Important:** Output ONLY the JSON, no other text.");
-  parts.push("");
-  return parts.join("\n");
-}
-function buildClarifyPrompt(params) {
-  const cwd = params.cwd || process.cwd();
-  const stepsDir = getStepsDir(cwd);
-  const instructionPath = join5(stepsDir, params.step, "instruction.md");
-  const instruction = existsSync5(instructionPath) ? readFileSync5(instructionPath, "utf-8") : "";
-  const parts = [];
-  parts.push("# Clarify Phase");
-  parts.push("");
-  parts.push("Your task is to identify any questions that need user input before generating the document.");
-  parts.push("Do NOT generate the document yet - only generate questions if needed.");
-  parts.push("");
-  parts.push("## Task Information");
-  parts.push("");
-  parts.push(`- **Task ID**: ${params.taskId}`);
-  parts.push(`- **Current Step**: ${params.step}`);
-  parts.push(`- **Description**: ${params.description}`);
-  parts.push("");
-  parts.push("## Gathered Context");
-  parts.push("");
-  parts.push(params.gatheredContext);
-  parts.push("");
-  if (instruction) {
-    parts.push("## Step Instruction");
-    parts.push("");
-    parts.push(instruction);
-    parts.push("");
-  }
-  if (params.previousQA && params.previousQA.length > 0) {
-    parts.push("## Previous Questions & Answers");
-    parts.push("");
-    parts.push("The following questions have already been asked and answered:");
-    parts.push("");
-    for (const entry of params.previousQA) {
-      parts.push(`**Q: ${entry.question.question}**`);
-      if (entry.question.context) {
-        parts.push(`Context: ${entry.question.context}`);
-      }
-      parts.push(`A: ${entry.answer.answer}`);
-      parts.push("");
+    const steps = this.getSteps();
+    const specPath = this.getSpecPath(taskId, state.currentStep);
+    if (existsSync5(specPath)) {
+      const content = readFileSync5(specPath, "utf-8");
+      const { content: body, data } = matter2(content);
+      data.status = "approved";
+      data.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+      writeFileSync3(specPath, matter2.stringify(body, data));
     }
-    parts.push("Based on these answers, determine if there are still ambiguities that need clarification.");
-    parts.push("Do NOT repeat questions that have already been answered.");
-    parts.push("");
-  }
-  parts.push("## Consider These Questions");
-  parts.push("");
-  parts.push("1. Is the task description clear enough to proceed?");
-  parts.push("2. Are there multiple valid approaches that need user decision?");
-  parts.push("3. Are there ambiguities that could lead to wrong implementation?");
-  parts.push("4. Are there missing requirements or constraints?");
-  parts.push("");
-  parts.push("## Output Format");
-  parts.push("");
-  parts.push("Output a JSON object with questions array:");
-  parts.push("");
-  parts.push("```json");
-  parts.push("{");
-  parts.push('  "questions": [');
-  parts.push("    {");
-  parts.push('      "id": "q1",');
-  parts.push('      "question": "Your specific question?",');
-  parts.push('      "context": "Why this matters for the document",');
-  parts.push('      "options": ["Option A", "Option B"]  // optional');
-  parts.push("    }");
-  parts.push("  ]");
-  parts.push("}");
-  parts.push("```");
-  parts.push("");
-  parts.push('If no questions are needed, return: `{"questions": []}`');
-  parts.push("");
-  parts.push("**Important:** Output ONLY the JSON, no other text.");
-  parts.push("");
-  return parts.join("\n");
-}
-function buildGeneratePrompt(params) {
-  const cwd = params.cwd || process.cwd();
-  const config = loadConfig(cwd);
-  const stepsDir = getStepsDir(cwd);
-  const outputsDir = getOutputsDir(cwd);
-  const isFirstStep = params.stepIndex === 1;
-  const prevStep = params.stepIndex > 1 ? config.steps[params.stepIndex - 2] : null;
-  const instructionPath = join5(stepsDir, params.step, "instruction.md");
-  const templatePath = join5(stepsDir, params.step, "template.md");
-  const outputPath = join5(outputsDir, params.taskId, `${params.step}.md`);
-  if (!existsSync5(instructionPath)) {
-    throw new Error(`Instruction not found: ${instructionPath}`);
-  }
-  const instruction = readFileSync5(instructionPath, "utf-8");
-  const template = existsSync5(templatePath) ? readFileSync5(templatePath, "utf-8") : null;
-  let previousSpec = null;
-  if (prevStep) {
-    const prevPath = join5(outputsDir, params.taskId, `${prevStep}.md`);
-    if (existsSync5(prevPath)) {
-      previousSpec = {
-        step: prevStep,
-        content: readFileSync5(prevPath, "utf-8")
-      };
+    if (state.stepIndex < state.totalSteps) {
+      state.currentStep = steps[state.stepIndex];
+      state.stepIndex += 1;
+      state.status = "phase_explore";
+      state.phase = "explore";
+      state.context = void 0;
+      state.exploreOutput = void 0;
+      state.questions = void 0;
+      state.answers = void 0;
+      state.qaHistory = void 0;
+      state.verifyOutput = void 0;
+      state.verifyAttempts = void 0;
+      state.revisionFeedback = void 0;
+      this.saveState(state);
+      return this.responsePhaseExplore(state);
+    } else {
+      state.status = "completed";
+      this.saveState(state);
+      return this.responseComplete(state, "completed");
     }
   }
-  const parts = [];
-  parts.push("# Document Generation Phase");
-  parts.push("");
-  parts.push("Generate the document based on the gathered context and user answers.");
-  parts.push("");
-  parts.push("## Step Instruction");
-  parts.push("");
-  parts.push(instruction);
-  parts.push("");
-  if (template) {
-    parts.push("## Document Template");
-    parts.push("");
-    parts.push("**CRITICAL: You MUST follow this template structure completely.**");
-    parts.push("");
-    parts.push(template);
-    parts.push("");
-  }
-  parts.push("## Gathered Context");
-  parts.push("");
-  parts.push(params.gatheredContext);
-  parts.push("");
-  if (params.answers && params.answers.length > 0) {
-    parts.push("## User Answers");
-    parts.push("");
-    for (const answer of params.answers) {
-      parts.push(`- **${answer.questionId}**: ${answer.answer}`);
+  /**
+   * Request revision with feedback - goes back to draft phase
+   */
+  cmdRevise(taskId, feedback) {
+    const state = this.loadState(taskId);
+    if (!state) {
+      return this.responseError(`No workflow found: ${taskId}`, taskId);
     }
-    parts.push("");
+    state.status = "phase_execute";
+    state.phase = "draft";
+    state.revisionFeedback = feedback;
+    state.verifyOutput = void 0;
+    state.verifyAttempts = 0;
+    this.saveState(state);
+    return this.responsePhaseExecute(state);
   }
-  if (isFirstStep) {
-    parts.push("## User Request");
-    parts.push("");
-    parts.push(`> ${params.description}`);
-    parts.push("");
-  } else if (previousSpec) {
-    parts.push(`## Input: ${previousSpec.step}.md`);
-    parts.push("");
-    parts.push(previousSpec.content);
-    parts.push("");
+  /**
+   * Reject and stop workflow
+   */
+  cmdReject(taskId) {
+    const state = this.loadState(taskId);
+    if (!state) {
+      return this.responseError(`No workflow found: ${taskId}`, taskId);
+    }
+    const specPath = this.getSpecPath(taskId, state.currentStep);
+    if (existsSync5(specPath)) {
+      const content = readFileSync5(specPath, "utf-8");
+      const { content: body, data } = matter2(content);
+      data.status = "rejected";
+      data.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+      writeFileSync3(specPath, matter2.stringify(body, data));
+    }
+    state.status = "rejected";
+    this.saveState(state);
+    return this.responseComplete(state, "rejected");
   }
-  parts.push("## Task Context");
-  parts.push("");
-  parts.push(`- **Task ID**: ${params.taskId}`);
-  parts.push(`- **Current Step**: ${params.step} (${params.stepIndex}/${params.totalSteps})`);
-  parts.push("");
-  if (params.revisionFeedback) {
-    parts.push("## Revision Feedback");
-    parts.push("");
-    parts.push("Previous version was not approved. Please revise based on this feedback:");
-    parts.push("");
-    parts.push(`> ${params.revisionFeedback}`);
-    parts.push("");
+  /**
+   * Stop workflow (can resume later)
+   */
+  cmdStop(taskId) {
+    const state = this.loadState(taskId);
+    if (!state) {
+      return this.responseError(`No workflow found: ${taskId}`, taskId);
+    }
+    state.status = "stopped";
+    this.saveState(state);
+    return this.responseComplete(state, "stopped");
   }
-  parts.push("## Output Instructions");
-  parts.push("");
-  parts.push(`Generate the document and save to: \`${outputPath}\``);
-  parts.push("");
-  parts.push("**Required frontmatter:**");
-  parts.push("```yaml");
-  parts.push("---");
-  parts.push(`id: ${params.taskId}`);
-  parts.push(`step: ${params.step}`);
-  parts.push("status: pending_approval");
-  parts.push("---");
-  parts.push("```");
-  parts.push("");
-  return {
-    prompt: parts.join("\n"),
-    outputPath
-  };
-}
-function buildSectionPrompt(params) {
-  const { section, sharedContext, gatheredContext, answers } = params;
-  const parts = [];
-  parts.push(`# Section: ${section.title}`);
-  parts.push("");
-  parts.push("## Document Context");
-  parts.push("");
-  parts.push(`**Goal:** ${sharedContext.documentGoal}`);
-  parts.push(`**Step:** ${sharedContext.stepName}`);
-  parts.push(`**Total Sections:** ${sharedContext.totalSections}`);
-  parts.push("");
-  parts.push("## Document Structure");
-  parts.push("");
-  parts.push("```");
-  parts.push(sharedContext.treeOverview);
-  parts.push("```");
-  parts.push("");
-  parts.push("## Your Position");
-  parts.push("");
-  parts.push(`- **Path:** ${section.position.path.join(" > ")}`);
-  parts.push(`- **Siblings:** ${section.position.siblings.join(", ") || "None"}`);
-  parts.push(`- **Parent:** ${section.position.parent || "Root"}`);
-  parts.push("");
-  if (gatheredContext) {
-    parts.push("## Gathered Context");
-    parts.push("");
-    parts.push(gatheredContext);
-    parts.push("");
+  // ===========================================================================
+  // Section-based Workflow Commands
+  // ===========================================================================
+  /**
+   * Initialize section-based generation for current step
+   * Called internally when template has sections
+   */
+  initSectionPlan(state) {
+    const templatePath = this.getStepTemplatePath(state.currentStep);
+    if (!existsSync5(templatePath)) {
+      return;
+    }
+    const template = readFileSync5(templatePath, "utf-8");
+    const instructionPath = this.getStepInstructionPath(state.currentStep);
+    const instructionSummary = existsSync5(instructionPath) ? readFileSync5(instructionPath, "utf-8").slice(0, 500) : "";
+    const plan = parseTemplateToTree(
+      template,
+      state.currentStep,
+      state.description,
+      `sections/${state.currentStep}`,
+      instructionSummary
+    );
+    if (plan.leaves.length > 1) {
+      state.sectionPlan = plan;
+      state.sectionStatuses = plan.leaves.map((leaf) => ({
+        id: leaf.id,
+        status: "pending",
+        outputPath: leaf.outputPath
+      }));
+      state.consolidateProgress = {
+        currentLevel: 0,
+        completedLevels: [],
+        totalLevels: plan.consolidateLevels.length
+      };
+    }
   }
-  if (answers && answers.length > 0) {
-    parts.push("## User Answers");
-    parts.push("");
-    for (const answer of answers) {
-      parts.push(`- **${answer.questionId}**: ${answer.answer}`);
+  /**
+   * All sections completed, move to consolidation
+   */
+  cmdSectionsDone(taskId) {
+    const state = this.loadState(taskId);
+    if (!state) {
+      return this.responseError(`No workflow found: ${taskId}`, taskId);
     }
-    parts.push("");
+    if (!state.sectionPlan || !state.consolidateProgress) {
+      return this.responseError("No section plan found", taskId, state.currentStep);
+    }
+    if (state.sectionStatuses) {
+      state.sectionStatuses = state.sectionStatuses.map((s) => ({
+        ...s,
+        status: "completed"
+      }));
+    }
+    if (state.consolidateProgress.totalLevels > 0) {
+      state.status = "phase_consolidate";
+      state.consolidateProgress.currentLevel = 0;
+      this.saveState(state);
+      const firstLevel = state.sectionPlan.consolidateLevels[0];
+      const validation = this.validateConsolidateReady(state, firstLevel);
+      if (!validation.valid) {
+        return this.responseError(
+          validation.error || "Validation failed",
+          taskId,
+          state.currentStep
+        );
+      }
+      return this.responsePhaseConsolidate(state, firstLevel);
+    }
+    state.status = "approve_pending";
+    state.phase = "review";
+    this.saveState(state);
+    return this.responseCheckpointApprove(state);
   }
-  if (section.templateContent) {
-    parts.push("## Template Guide");
-    parts.push("");
-    parts.push(section.templateContent);
-    parts.push("");
+  /**
+   * Consolidation level completed, move to next level or approve
+   */
+  cmdConsolidateLevelDone(taskId, level) {
+    const state = this.loadState(taskId);
+    if (!state) {
+      return this.responseError(`No workflow found: ${taskId}`, taskId);
+    }
+    if (!state.sectionPlan || !state.consolidateProgress) {
+      return this.responseError("No section plan found", taskId, state.currentStep);
+    }
+    state.consolidateProgress.completedLevels.push(level);
+    state.consolidateProgress.currentLevel++;
+    if (state.consolidateProgress.currentLevel < state.consolidateProgress.totalLevels) {
+      this.saveState(state);
+      const nextLevel = state.sectionPlan.consolidateLevels[state.consolidateProgress.currentLevel];
+      const validation = this.validateConsolidateReady(state, nextLevel);
+      if (!validation.valid) {
+        return this.responseError(
+          validation.error || "Validation failed",
+          taskId,
+          state.currentStep
+        );
+      }
+      return this.responsePhaseConsolidate(state, nextLevel);
+    }
+    state.status = "approve_pending";
+    state.phase = "review";
+    this.saveState(state);
+    return this.responseCheckpointApprove(state);
   }
-  parts.push("## Your Task");
-  parts.push("");
-  parts.push(`Write the "${section.title.replace(/^#+\\s*/, "")}" section.`);
-  parts.push("Consider how it relates to sibling sections and contributes to the parent section.");
-  parts.push("");
-  parts.push("## Output");
-  parts.push("");
-  parts.push(`Save to: \`${section.outputPath}\``);
-  parts.push("");
-  parts.push("Write ONLY the content for this section (including its header).");
-  parts.push("Do NOT include content from other sections.");
-  parts.push("");
-  return {
-    prompt: parts.join("\n"),
-    outputPath: section.outputPath
-  };
-}
-function buildConsolidatePrompt(params) {
-  const { group, childContents, sharedContext, parentTitle } = params;
-  const parts = [];
-  parts.push("# Consolidate Sections");
-  parts.push("");
-  parts.push("## Document Context");
-  parts.push("");
-  parts.push(`**Goal:** ${sharedContext.documentGoal}`);
-  parts.push(`**Step:** ${sharedContext.stepName}`);
-  parts.push("");
-  parts.push("## Document Structure");
-  parts.push("");
-  parts.push("```");
-  parts.push(sharedContext.treeOverview);
-  parts.push("```");
-  parts.push("");
-  parts.push("## Your Task");
-  parts.push("");
-  parts.push(`Consolidate the following child sections into the parent section "${parentTitle || group.parentId}".`);
-  parts.push("");
-  parts.push("## Child Sections to Consolidate");
-  parts.push("");
-  for (const child of childContents) {
-    parts.push(`### Child: ${child.id}`);
-    parts.push("");
-    parts.push(child.content);
-    parts.push("");
-    parts.push("---");
-    parts.push("");
+  /**
+   * Get current workflow status
+   */
+  cmdStatus(taskId) {
+    const state = this.loadState(taskId);
+    if (!state) {
+      return this.responseError(`No workflow found: ${taskId}`, taskId);
+    }
+    const migratedStatus = this.migrateStatus(state.status);
+    if (migratedStatus !== state.status) {
+      state.status = migratedStatus;
+      this.saveState(state);
+    }
+    switch (state.status) {
+      // Legacy (backward compatibility)
+      case "phase_context":
+        return this.responsePhaseContext(state);
+      case "phase_generate":
+        return this.responsePhaseGenerate(state);
+      case "phase_draft":
+        return this.responsePhaseExecute(state);
+      // New 5-phase workflow
+      case "phase_explore":
+        return this.responsePhaseExplore(state);
+      case "phase_clarify":
+        return this.responsePhaseClarify(state);
+      case "clarify_pending":
+        return this.responseCheckpointClarify(state);
+      case "phase_execute":
+        return this.responsePhaseExecute(state);
+      case "phase_verify":
+        return this.responsePhaseVerify(state);
+      // Section-based workflow
+      case "phase_sections":
+        return this.responsePhaseGenerateSections(state);
+      case "phase_consolidate":
+        if (state.sectionPlan && state.consolidateProgress) {
+          const level = state.sectionPlan.consolidateLevels[state.consolidateProgress.currentLevel];
+          return this.responsePhaseConsolidate(state, level);
+        }
+        return this.responseError("Invalid consolidate state", taskId);
+      // Checkpoints and completion
+      case "approve_pending":
+        return this.responseCheckpointApprove(state);
+      case "completed":
+      case "stopped":
+      case "rejected":
+        return this.responseComplete(state, state.status);
+      default:
+        return this.responseError(`Unknown status: ${state.status}`, taskId);
+    }
   }
-  parts.push("## Output Instructions");
-  parts.push("");
-  parts.push(`Save consolidated content to: \`${group.outputPath}\``);
-  parts.push("");
-  parts.push("**Guidelines:**");
-  parts.push("- Combine child sections into a coherent parent section");
-  parts.push("- Maintain the hierarchy (parent header, then children)");
-  parts.push("- Ensure smooth transitions between sections");
-  parts.push("- Preserve all content from child sections");
-  parts.push("");
-  return {
-    prompt: parts.join("\n"),
-    outputPath: group.outputPath
-  };
-}
+  /**
+   * Migrate legacy workflow status to new status
+   * This allows existing workflows to continue working
+   */
+  migrateStatus(status) {
+    return status;
+  }
+};
 
 // src/core/step-executor.ts
-import { readFileSync as readFileSync6, existsSync as fsExistsSync, mkdirSync as mkdirSync4 } from "fs";
-import { dirname as dirname3 } from "path";
-import { join as join6 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname3, join as join6 } from "path";
+import matter3 from "gray-matter";
+var fsExistsSync = existsSync6;
 var StepExecutor = class {
   adapter;
   config;
@@ -2005,6 +2576,7 @@ var StepExecutor = class {
   /**
    * Execute context phase - AI gathers context
    * Returns gathered context as string
+   * @deprecated Use executeExplorePhase instead
    */
   async executeContextPhase(step, context) {
     this.adapter.io.notify(`Phase 1/4: Gathering context for ${step}`, "info");
@@ -2030,6 +2602,39 @@ var StepExecutor = class {
     };
   }
   // ==========================================================================
+  // Phase 1 (New): Explore - Deep Codebase Analysis
+  // ==========================================================================
+  /**
+   * Execute explore phase - AI deeply analyzes codebase
+   * Returns detailed exploration output with patterns, constraints, etc.
+   */
+  async executeExplorePhase(step, context) {
+    this.adapter.io.notify(`Phase 1/5: Exploring codebase for ${step}`, "info");
+    const params = {
+      taskId: context.taskId,
+      step,
+      description: context.description,
+      stepIndex: context.stepIndex,
+      totalSteps: context.totalSteps,
+      previousOutput: context.previousOutput,
+      cwd: this.cwd
+    };
+    const prompt = buildExplorePrompt(params);
+    const response = await this.adapter.ai.execute({
+      prompt,
+      outputPath: ""
+      // No file output needed
+    });
+    const exploreOutput = this.parseExploreOutput(response || "");
+    this.adapter.io.notify(`Found ${exploreOutput.relevantFiles.length} relevant files, ${exploreOutput.patterns.length} patterns`, "info");
+    return {
+      phase: "explore",
+      exploreOutput,
+      context: JSON.stringify(exploreOutput)
+      // Also set legacy context
+    };
+  }
+  // ==========================================================================
   // Phase 2: Clarify (Question Generation)
   // ==========================================================================
   /**
@@ -2082,6 +2687,7 @@ var StepExecutor = class {
   // ==========================================================================
   /**
    * Execute generate phase - AI creates document
+   * @deprecated Use executeDraftPhase instead
    */
   async executeGeneratePhase(step, context) {
     this.adapter.io.notify(`Phase 3/4: Generating document for ${step}`, "info");
@@ -2108,6 +2714,94 @@ var StepExecutor = class {
     return { phase: "generate" };
   }
   // ==========================================================================
+  // Phase 3 (New): Execute - Document/Code Generation with Explore Output
+  // ==========================================================================
+  /**
+   * Execute the execute phase - AI creates document/code using explore output
+   */
+  async executeExecutePhase(step, context) {
+    const attemptInfo = context.verifyAttempts && context.verifyAttempts > 1 ? ` (attempt ${context.verifyAttempts}/3)` : "";
+    this.adapter.io.notify(`Phase 3/5: Executing for ${step}${attemptInfo}`, "info");
+    if (!context.exploreOutput && !context.gatheredContext) {
+      throw new Error("Explore phase must be completed before draft phase");
+    }
+    const exploreOutput = context.exploreOutput || {
+      summary: context.gatheredContext || "",
+      relevantFiles: [],
+      patterns: [],
+      constraints: [],
+      dependencies: []
+    };
+    const params = {
+      taskId: context.taskId,
+      step,
+      description: context.description,
+      stepIndex: context.stepIndex,
+      totalSteps: context.totalSteps,
+      exploreOutput,
+      answers: context.answers,
+      revisionFeedback: context.revisionFeedback,
+      verifyFeedback: context.verifyFeedback,
+      cwd: this.cwd
+    };
+    const { prompt, outputPath } = buildExecutePrompt(params);
+    await this.adapter.ai.execute({ prompt, outputPath });
+    if (!existsSync6(outputPath)) {
+      throw new Error(`AI did not create document at ${outputPath}`);
+    }
+    this.adapter.io.notify(`Document created: ${outputPath}`, "success");
+    return { phase: "execute" };
+  }
+  /**
+   * @deprecated Use executeExecutePhase instead
+   */
+  async executeDraftPhase(step, context) {
+    return this.executeExecutePhase(step, context);
+  }
+  // ==========================================================================
+  // Phase 4 (New): Verify - Self-Validation
+  // ==========================================================================
+  /**
+   * Execute verify phase - AI validates the generated document
+   */
+  async executeVerifyPhase(step, context) {
+    const attempts = context.verifyAttempts || 1;
+    this.adapter.io.notify(`Phase 4/5: Verifying document for ${step} (attempt ${attempts}/3)`, "info");
+    const outputsDir = getOutputsDir(this.cwd);
+    const documentPath = join6(outputsDir, context.taskId, `${step}.md`);
+    if (!existsSync6(documentPath)) {
+      throw new Error(`Document not found: ${documentPath}`);
+    }
+    const params = {
+      taskId: context.taskId,
+      step,
+      description: context.description,
+      stepIndex: context.stepIndex,
+      totalSteps: context.totalSteps,
+      documentPath,
+      verifyAttempts: attempts,
+      cwd: this.cwd
+    };
+    const prompt = buildVerifyPrompt(params);
+    const response = await this.adapter.ai.execute({
+      prompt,
+      outputPath: ""
+      // No file output needed
+    });
+    const verifyOutput = this.parseVerifyOutput(response || "");
+    if (verifyOutput.passed) {
+      this.adapter.io.notify(`Verification passed! Scores: ${JSON.stringify(verifyOutput.score)}`, "success");
+    } else {
+      const errorCount = verifyOutput.issues.filter((i) => i.severity === "error").length;
+      const warningCount = verifyOutput.issues.filter((i) => i.severity === "warning").length;
+      this.adapter.io.notify(`Verification failed: ${errorCount} errors, ${warningCount} warnings`, "warning");
+    }
+    return {
+      phase: "verify",
+      verifyOutput
+    };
+  }
+  // ==========================================================================
   // Phase 3 (Section Mode): Parallel Section Generation
   // ==========================================================================
   /**
@@ -2379,6 +3073,75 @@ var StepExecutor = class {
     }
     return { questions: [] };
   }
+  /**
+   * Parse explore phase output (JSON)
+   */
+  parseExploreOutput(response) {
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        if (typeof parsed.summary === "string") {
+          return {
+            summary: parsed.summary || "",
+            relevantFiles: Array.isArray(parsed.relevantFiles) ? parsed.relevantFiles : [],
+            patterns: Array.isArray(parsed.patterns) ? parsed.patterns : [],
+            constraints: Array.isArray(parsed.constraints) ? parsed.constraints : [],
+            dependencies: Array.isArray(parsed.dependencies) ? parsed.dependencies : []
+          };
+        }
+      }
+    } catch {
+    }
+    return {
+      summary: response,
+      relevantFiles: [],
+      patterns: [],
+      constraints: [],
+      dependencies: []
+    };
+  }
+  /**
+   * Parse verify phase output (JSON)
+   */
+  parseVerifyOutput(response) {
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        if (typeof parsed.passed === "boolean" && parsed.score) {
+          return {
+            passed: parsed.passed,
+            score: {
+              requirementsCoverage: parsed.score.requirementsCoverage ?? 0,
+              templateCompliance: parsed.score.templateCompliance ?? 0,
+              consistency: parsed.score.consistency ?? 0,
+              completeness: parsed.score.completeness ?? 0
+            },
+            issues: Array.isArray(parsed.issues) ? parsed.issues : [],
+            summary: parsed.summary || ""
+          };
+        }
+      }
+    } catch {
+    }
+    return {
+      passed: false,
+      score: {
+        requirementsCoverage: 0,
+        templateCompliance: 0,
+        consistency: 0,
+        completeness: 0
+      },
+      issues: [{
+        severity: "error",
+        category: "parsing",
+        description: "Failed to parse verification output",
+        suggestion: "Ensure AI returns valid JSON"
+      }],
+      summary: "Verification parsing failed"
+    };
+  }
   /**
    * Update document status in frontmatter
    */
@@ -2990,7 +3753,7 @@ async function startCommand(query, options) {
   console.log(`
 \u{1F680} Starting workflow: ${query}
 `);
-  if (response.type === "phase" && response.phase === "context") {
+  if (response.type === "phase" && (response.phase === "explore" || response.phase === "context")) {
     taskId = response.taskId;
     if (isGitHubMode && "io" in adapter && "setTaskId" in adapter.io) {
       adapter.io.setTaskId(taskId);
@@ -3001,7 +3764,21 @@ async function startCommand(query, options) {
       if (response.type === "phase") {
         const phaseResponse = response;
         taskId = phaseResponse.taskId;
-        if (phaseResponse.phase === "context") {
+        if (phaseResponse.phase === "explore") {
+          const exploreResp = phaseResponse;
+          console.log(`
+--- Step ${exploreResp.stepIndex}/${exploreResp.totalSteps}: ${exploreResp.step} ---`);
+          console.log("Phase 1/5: Exploring codebase...\n");
+          const stepContext = {
+            taskId: exploreResp.taskId,
+            description: exploreResp.description,
+            stepIndex: exploreResp.stepIndex,
+            totalSteps: exploreResp.totalSteps,
+            previousOutput: exploreResp.context.previousOutput
+          };
+          const result = await stepExecutor.executeExplorePhase(exploreResp.step, stepContext);
+          response = orchestrator.cmdExploreDone(taskId, result.exploreOutput);
+        } else if (phaseResponse.phase === "context") {
           const contextResp = phaseResponse;
           console.log(`
 --- Step ${contextResp.stepIndex}/${contextResp.totalSteps}: ${contextResp.step} ---`);
@@ -3028,6 +3805,36 @@ async function startCommand(query, options) {
           };
           const result = await stepExecutor.executeClarifyPhase(clarifyResp.step, stepContext);
           response = orchestrator.cmdClarifyDone(taskId, result.questions || []);
+        } else if (phaseResponse.phase === "execute" || phaseResponse.phase === "draft") {
+          const executeResp = phaseResponse;
+          const attemptInfo = executeResp.context.verifyFeedback ? " (auto-fix)" : "";
+          console.log(`Phase 3/5: Executing${attemptInfo}...
+`);
+          const stepContext = {
+            taskId: executeResp.taskId,
+            description: executeResp.description,
+            stepIndex: executeResp.stepIndex,
+            totalSteps: executeResp.totalSteps,
+            exploreOutput: executeResp.exploreOutput,
+            answers: executeResp.answers,
+            revisionFeedback: executeResp.context.revisionFeedback,
+            verifyFeedback: executeResp.context.verifyFeedback
+          };
+          await stepExecutor.executeExecutePhase(executeResp.step, stepContext);
+          response = orchestrator.cmdExecuteDone(taskId);
+        } else if (phaseResponse.phase === "verify") {
+          const verifyResp = phaseResponse;
+          console.log(`Phase 4/5: Verifying document (attempt ${verifyResp.verifyAttempts}/${verifyResp.maxAttempts})...
+`);
+          const stepContext = {
+            taskId: verifyResp.taskId,
+            description: verifyResp.description,
+            stepIndex: verifyResp.stepIndex,
+            totalSteps: verifyResp.totalSteps,
+            verifyAttempts: verifyResp.verifyAttempts
+          };
+          const result = await stepExecutor.executeVerifyPhase(verifyResp.step, stepContext);
+          response = orchestrator.cmdVerifyDone(taskId, result.verifyOutput);
         } else if (phaseResponse.phase === "generate") {
           const generateResp = phaseResponse;
           console.log("Phase 3/4: Generating document...\n");
@@ -3280,7 +4087,21 @@ async function resumeCommand(options) {
       if (response.type === "phase") {
         const phaseResponse = response;
         taskId = phaseResponse.taskId;
-        if (phaseResponse.phase === "context") {
+        if (phaseResponse.phase === "explore") {
+          const exploreResp = phaseResponse;
+          console.log(`
+--- Step ${exploreResp.stepIndex}/${exploreResp.totalSteps}: ${exploreResp.step} ---`);
+          console.log("Phase 1/5: Exploring codebase...\n");
+          const stepContext = {
+            taskId: exploreResp.taskId,
+            description: exploreResp.description,
+            stepIndex: exploreResp.stepIndex,
+            totalSteps: exploreResp.totalSteps,
+            previousOutput: exploreResp.context.previousOutput
+          };
+          const result = await stepExecutor.executeExplorePhase(exploreResp.step, stepContext);
+          response = orchestrator.cmdExploreDone(taskId, result.exploreOutput);
+        } else if (phaseResponse.phase === "context") {
           const contextResp = phaseResponse;
           console.log(`
 --- Step ${contextResp.stepIndex}/${contextResp.totalSteps}: ${contextResp.step} ---`);
@@ -3306,6 +4127,36 @@ async function resumeCommand(options) {
           };
           const result = await stepExecutor.executeClarifyPhase(clarifyResp.step, stepContext);
           response = orchestrator.cmdClarifyDone(taskId, result.questions || []);
+        } else if (phaseResponse.phase === "execute" || phaseResponse.phase === "draft") {
+          const executeResp = phaseResponse;
+          const attemptInfo = executeResp.context.verifyFeedback ? " (auto-fix)" : "";
+          console.log(`Phase 3/5: Executing${attemptInfo}...
+`);
+          const stepContext = {
+            taskId: executeResp.taskId,
+            description: executeResp.description,
+            stepIndex: executeResp.stepIndex,
+            totalSteps: executeResp.totalSteps,
+            exploreOutput: executeResp.exploreOutput,
+            answers: executeResp.answers,
+            revisionFeedback: executeResp.context.revisionFeedback,
+            verifyFeedback: executeResp.context.verifyFeedback
+          };
+          await stepExecutor.executeExecutePhase(executeResp.step, stepContext);
+          response = orchestrator.cmdExecuteDone(taskId);
+        } else if (phaseResponse.phase === "verify") {
+          const verifyResp = phaseResponse;
+          console.log(`Phase 4/5: Verifying document (attempt ${verifyResp.verifyAttempts}/${verifyResp.maxAttempts})...
+`);
+          const stepContext = {
+            taskId: verifyResp.taskId,
+            description: verifyResp.description,
+            stepIndex: verifyResp.stepIndex,
+            totalSteps: verifyResp.totalSteps,
+            verifyAttempts: verifyResp.verifyAttempts
+          };
+          const result = await stepExecutor.executeVerifyPhase(verifyResp.step, stepContext);
+          response = orchestrator.cmdVerifyDone(taskId, result.verifyOutput);
         } else if (phaseResponse.phase === "generate") {
           const generateResp = phaseResponse;
           console.log("Phase 3/4: Generating document...\n");
@@ -3551,11 +4402,14 @@ Parse JSON response \u2192 execute action from table below \u2192 loop until \`t
 
 | \`phase\` | Action |
 |---------|--------|
-| \`context\` | [ACTION_CONTEXT](#action_context) |
+| \`explore\` | [ACTION_EXPLORE](#action_explore) |
 | \`clarify\` | [ACTION_CLARIFY](#action_clarify) |
-| \`generate\` | [ACTION_GENERATE](#action_generate) |
+| \`execute\` | [ACTION_EXECUTE](#action_execute) |
+| \`verify\` | [ACTION_VERIFY](#action_verify) |
 | \`generate-sections\` | [ACTION_PARALLEL_SECTIONS](#action_parallel_sections) |
 | \`consolidate\` | [ACTION_PARALLEL_CONSOLIDATE](#action_parallel_consolidate) |
+| \`context\` | [ACTION_CONTEXT](#action_context) (legacy) |
+| \`generate\` | [ACTION_GENERATE](#action_generate) (legacy) |
 
 ### \`type: "checkpoint"\`
 
@@ -3580,28 +4434,66 @@ Print: "Error: {error}" \u2192 STOP
 
 ## Action Definitions
 
-### ACTION_CONTEXT
+**IMPORTANT:** Each phase response includes a \`prompt\` field containing the exact instructions to follow.
+This ensures identical behavior across CLI, Claude Code, and GitHub modes.
+
+### ACTION_EXPLORE
 
 \`\`\`
-1. Read(context.instruction)
-2. IF context.previousOutput EXISTS: Read(context.previousOutput)
-3. Explore codebase for: {description}
-4. Bash: npx spets orchestrate context-done {taskId}
-5. Parse response \u2192 next action
+1. Follow the instructions in response.prompt EXACTLY
+2. The prompt tells you:
+   - What to search for
+   - How to analyze the codebase
+   - The exact JSON output format required
+3. Bash: npx spets orchestrate explore-done {taskId} '{exploreJson}'
+4. Parse response \u2192 next action
 \`\`\`
 
 ### ACTION_CLARIFY
 
 \`\`\`
-1. Analyze: gatheredContext, previousQA (if exists)
-2. Generate questions array (0-4 questions)
+1. Follow the instructions in response.prompt EXACTLY
+2. The prompt tells you:
+   - What context to analyze
+   - How to generate questions
+   - The exact JSON output format required
 3. Bash: npx spets orchestrate clarify-done {taskId} '{questionsJson}'
    - Format: [{"id":"q1","question":"..."},...]
    - Empty if no questions: []
 4. Parse response \u2192 next action
 \`\`\`
 
-### ACTION_GENERATE
+### ACTION_EXECUTE
+
+\`\`\`
+1. Follow the instructions in response.prompt EXACTLY
+2. The prompt tells you:
+   - The instruction and template to follow
+   - The explore output and answers to use
+   - Where to save the document/code (context.output)
+   - Any revision/verify feedback to address
+3. Write the document/code to context.output
+4. Bash: npx spets orchestrate execute-done {taskId}
+5. Parse response \u2192 next action
+\`\`\`
+
+### ACTION_VERIFY
+
+\`\`\`
+1. Follow the instructions in response.prompt EXACTLY
+2. The prompt tells you:
+   - The document to verify (already included in prompt)
+   - The requirements and template to check against
+   - The scoring criteria and pass conditions
+   - The exact JSON output format required
+3. Bash: npx spets orchestrate verify-done {taskId} '{verifyJson}'
+4. Parse response \u2192 next action
+   - If passed: goes to human review
+   - If failed (attempts < 3): goes back to draft phase (auto-fix)
+   - If failed (attempts >= 3): goes to human review with warning
+\`\`\`
+
+### ACTION_GENERATE (legacy)
 
 \`\`\`
 1. Read(context.instruction)
@@ -3613,6 +4505,16 @@ Print: "Error: {error}" \u2192 STOP
 7. Parse response \u2192 next action
 \`\`\`
 
+### ACTION_CONTEXT (legacy)
+
+\`\`\`
+1. Read(context.instruction)
+2. IF context.previousOutput EXISTS: Read(context.previousOutput)
+3. Explore codebase for: {description}
+4. Bash: npx spets orchestrate context-done {taskId}
+5. Parse response \u2192 next action
+\`\`\`
+
 ### ACTION_PARALLEL_SECTIONS
 
 **PARALLEL EXECUTION (FOREGROUND)**
@@ -3731,17 +4633,25 @@ Print: "Error: {error}" \u2192 STOP
 ## Orchestrator Commands Reference
 
 \`\`\`bash
+# New 5-phase workflow
 npx spets orchestrate init "<description>"
-npx spets orchestrate context-done <taskId>
+npx spets orchestrate explore-done <taskId> '<json>'
 npx spets orchestrate clarify-done <taskId> '<json>'
 npx spets orchestrate clarified <taskId> '<json>'
-npx spets orchestrate generate-done <taskId>
-npx spets orchestrate sections-done <taskId>
-npx spets orchestrate consolidate-level-done <taskId> <level>
+npx spets orchestrate execute-done <taskId>
+npx spets orchestrate verify-done <taskId> '<json>'
 npx spets orchestrate approve <taskId>
 npx spets orchestrate revise <taskId> "<feedback>"
 npx spets orchestrate reject <taskId>
 npx spets orchestrate stop <taskId>
+
+# Section-based workflow
+npx spets orchestrate sections-done <taskId>
+npx spets orchestrate consolidate-level-done <taskId> <level>
+
+# Legacy (backward compatible)
+npx spets orchestrate context-done <taskId>
+npx spets orchestrate generate-done <taskId>
 \`\`\`
 
 ---
@@ -4293,6 +5203,31 @@ async function orchestrateCommand(action, args) {
         outputJSON(result);
         break;
       }
+      case "explore-done": {
+        const taskId = args[0];
+        const exploreJson = args[1];
+        if (!taskId) {
+          outputError("Task ID is required for explore-done");
+          return;
+        }
+        let exploreOutput = {
+          summary: "",
+          relevantFiles: [],
+          patterns: [],
+          constraints: [],
+          dependencies: []
+        };
+        if (exploreJson) {
+          try {
+            exploreOutput = JSON.parse(exploreJson);
+          } catch {
+            exploreOutput.summary = exploreJson;
+          }
+        }
+        const result = orchestrator.cmdExploreDone(taskId, exploreOutput);
+        outputJSON(result);
+        break;
+      }
       case "clarify-done": {
         const taskId = args[0];
         const questionsJson = args[1];
@@ -4323,6 +5258,57 @@ async function orchestrateCommand(action, args) {
         outputJSON(result);
         break;
       }
+      case "execute-done": {
+        const taskId = args[0];
+        if (!taskId) {
+          outputError("Task ID is required for execute-done");
+          return;
+        }
+        const result = orchestrator.cmdExecuteDone(taskId);
+        outputJSON(result);
+        break;
+      }
+      // Legacy alias for execute-done
+      case "draft-done": {
+        const taskId = args[0];
+        if (!taskId) {
+          outputError("Task ID is required for draft-done");
+          return;
+        }
+        const result = orchestrator.cmdExecuteDone(taskId);
+        outputJSON(result);
+        break;
+      }
+      case "verify-done": {
+        const taskId = args[0];
+        const verifyJson = args[1];
+        if (!taskId) {
+          outputError("Task ID is required for verify-done");
+          return;
+        }
+        let verifyOutput = {
+          passed: false,
+          score: {
+            requirementsCoverage: 0,
+            templateCompliance: 0,
+            consistency: 0,
+            completeness: 0
+          },
+          issues: [],
+          summary: ""
+        };
+        if (verifyJson) {
+          try {
+            verifyOutput = JSON.parse(verifyJson);
+          } catch {
+            outputError("Invalid JSON for verify output");
+            return;
+          }
+        }
+        const result = orchestrator.cmdVerifyDone(taskId, verifyOutput);
+        outputJSON(result);
+        break;
+      }
       case "done": {
         const taskId = args[0];
         if (!taskId) {
@@ -4430,7 +5416,7 @@ async function orchestrateCommand(action, args) {
         break;
       }
       default:
-        outputError(`Unknown action: ${action}. Valid actions: init, context-done, clarify-done, generate-done, done, clarified, approve, revise, reject, stop, status, sections-done, consolidate-level-done`);
+        outputError(`Unknown action: ${action}. Valid actions: init, explore-done, clarify-done, execute-done, verify-done, clarified, approve, revise, reject, stop, status, sections-done, consolidate-level-done (legacy: context-done, generate-done, draft-done, done)`);
     }
   } catch (e) {
     outputError(e.message);