spets 0.1.40 → 0.1.42

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import { Command } from "commander";
 import { readFileSync as readFileSync11 } from "fs";
-import { dirname as dirname6, join as join11 } from "path";
+import { dirname as dirname5, join as join11 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/commands/init.ts
@@ -729,211 +729,6 @@ import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsS
 import { join as join5, dirname as dirname2 } from "path";
 import matter2 from "gray-matter";
 
-// src/core/section-tree.ts
-function parseTemplateToTree(template, stepName, documentGoal, outputDir = "sections", instructionSummary = "") {
-  const lines = template.split("\n");
-  const headerRegex = /^(#{2,6})\s+(.+)$/;
-  const headers = [];
-  lines.forEach((line, index) => {
-    const match = line.match(headerRegex);
-    if (match) {
-      headers.push({
-        depth: match[1].length,
-        title: match[2].trim(),
-        fullTitle: line.trim(),
-        line: index + 1
-      });
-    }
-  });
-  if (headers.length === 0) {
-    return {
-      stepName,
-      sharedContext: {
-        documentGoal,
-        stepName,
-        stepInstruction: instructionSummary,
-        totalSections: 0,
-        treeOverview: "(no sections)"
-      },
-      leaves: [],
-      consolidateLevels: [],
-      rootOutputPath: `${outputDir}/${stepName}.md`
-    };
-  }
-  const root = {
-    id: "root",
-    title: "# Document",
-    depth: 1,
-    startLine: 0,
-    children: [],
-    isLeaf: false,
-    outputPath: `${outputDir}/${stepName}.md`,
-    position: { path: [], siblings: [], depth: 1 }
-  };
-  const stack = [root];
-  headers.forEach((header, idx) => {
-    const node = {
-      id: slugify(header.title),
-      title: header.fullTitle,
-      depth: header.depth,
-      startLine: header.line,
-      endLine: idx < headers.length - 1 ? headers[idx + 1].line : lines.length + 1,
-      children: [],
-      isLeaf: true,
-      // Will be updated when children are added
-      outputPath: "",
-      // Will be set after tree is built
-      templateContent: extractContent(lines, header.line, idx < headers.length - 1 ? headers[idx + 1].line : lines.length + 1),
-      position: { path: [], siblings: [], depth: header.depth }
-    };
-    while (stack.length > 1 && stack[stack.length - 1].depth >= header.depth) {
-      stack.pop();
-    }
-    const parent = stack[stack.length - 1];
-    parent.children.push(node);
-    parent.isLeaf = false;
-    stack.push(node);
-  });
-  calculatePositions(root, [], outputDir);
-  const leaves = [];
-  collectLeaves(root, leaves);
-  const consolidateLevels = generateConsolidateLevels(root);
-  const treeOverview = generateTreeOverview(root);
-  const totalSections = countSections(root);
-  return {
-    stepName,
-    sharedContext: {
-      documentGoal,
-      stepName,
-      stepInstruction: instructionSummary,
-      totalSections,
-      treeOverview
-    },
-    leaves,
-    consolidateLevels,
-    rootOutputPath: root.outputPath
-  };
-}
-function slugify(title) {
-  return title.toLowerCase().replace(/[^a-z0-9가-힣]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function extractContent(lines, startLine, endLine) {
-  return lines.slice(startLine, endLine - 1).join("\n").trim();
-}
-function calculatePositions(node, parentPath, outputDir) {
-  if (node.id === "root") {
-    node.position = { path: [], siblings: [], depth: 1 };
-    node.outputPath = `${outputDir}/_root.md`;
-  }
-  const siblingTitles = node.children.map(
-    (c) => c.title.replace(/^#+\s*/, "")
-  );
-  node.children.forEach((child, idx) => {
-    const childTitle = child.title.replace(/^#+\s*/, "");
-    const currentPath = [...parentPath, childTitle];
-    child.position = {
-      path: currentPath,
-      siblings: siblingTitles.filter((_, i) => i !== idx),
-      parent: parentPath.length > 0 ? parentPath[parentPath.length - 1] : void 0,
-      depth: child.depth
-    };
-    const pathSlug = currentPath.map((p) => slugify(p)).join("/");
-    child.outputPath = `${outputDir}/${pathSlug}.md`;
-    calculatePositions(child, currentPath, outputDir);
-  });
-}
-function collectLeaves(node, leaves) {
-  if (node.isLeaf && node.id !== "root") {
-    leaves.push(node);
-  }
-  node.children.forEach((child) => collectLeaves(child, leaves));
-}
-function generateConsolidateLevels(root) {
-  const levelMap = /* @__PURE__ */ new Map();
-  function traverse(node) {
-    if (node.children.length > 0) {
-      const childIds = node.children.map((c) => c.id);
-      const group = {
-        parentId: node.id,
-        childIds,
-        outputPath: node.outputPath
-      };
-      const childDepth = Math.max(...node.children.map((c) => c.depth));
-      if (!levelMap.has(childDepth)) {
-        levelMap.set(childDepth, []);
-      }
-      levelMap.get(childDepth).push(group);
-      node.children.forEach((child) => traverse(child));
-    }
-  }
-  traverse(root);
-  const levels = [];
-  const depths = Array.from(levelMap.keys()).sort((a, b) => b - a);
-  for (const depth of depths) {
-    levels.push({
-      depth,
-      groups: levelMap.get(depth)
-    });
-  }
-  return levels;
-}
-function generateTreeOverview(root) {
-  const lines = [];
-  function renderNode(node, prefix, isLast, isRoot) {
-    if (!isRoot) {
-      const marker = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-      lines.push(prefix + marker + node.title);
-    }
-    const childPrefix = isRoot ? "" : prefix + (isLast ? "    " : "\u2502   ");
-    node.children.forEach((child, idx) => {
-      const isChildLast = idx === node.children.length - 1;
-      renderNode(child, childPrefix, isChildLast, false);
-    });
-  }
-  renderNode(root, "", true, true);
-  return lines.join("\n");
-}
-function countSections(root) {
-  let count = 0;
-  function traverse(node) {
-    if (node.id !== "root") {
-      count++;
-    }
-    node.children.forEach((child) => traverse(child));
-  }
-  traverse(root);
-  return count;
-}
-function buildSectionInstruction(section, sharedContext) {
-  return `# Section: ${section.title}
-
-## Document Context
-**Goal:** ${sharedContext.documentGoal}
-**Step:** ${sharedContext.stepName}
-**Total Sections:** ${sharedContext.totalSections}
-
-## Tree Overview
-\`\`\`
-${sharedContext.treeOverview}
-\`\`\`
-
-## Your Position
-- **Path:** ${section.position.path.join(" > ")}
-- **Siblings:** ${section.position.siblings.join(", ") || "None"}
-- **Parent:** ${section.position.parent || "Root"}
-
-## Your Task
-Write the "${section.title.replace(/^#+\s*/, "")}" section.
-Consider how it relates to sibling sections and contributes to the parent section.
-
-${section.templateContent ? `## Template Guide
-${section.templateContent}` : ""}
-
-## Output
-Save to: ${section.outputPath}
-`;
-}
-
 // src/core/prompt-builder.ts
 import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
 import { join as join4 } from "path";
@@ -1255,111 +1050,6 @@ function buildGeneratePrompt(params) {
     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);
@@ -1910,131 +1600,6 @@ ${issues}`;
       onComplete: `verify-done ${state.taskId}`
     };
   }
-  /**
-   * Phase 3 (section mode): Parallel section generation
-   */
-  responsePhaseGenerateSections(state) {
-    if (!state.sectionPlan) {
-      throw new Error("Section plan not initialized");
-    }
-    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 parallelSections = state.sectionPlan.leaves.map((leaf) => ({
-      id: leaf.id,
-      title: leaf.title,
-      outputPath: join5(outputPath, state.taskId, leaf.outputPath),
-      instruction: buildSectionInstruction(leaf, state.sectionPlan.sharedContext),
-      position: {
-        path: leaf.position.path,
-        siblings: leaf.position.siblings,
-        parent: leaf.position.parent
-      },
-      templateContent: leaf.templateContent
-    }));
-    return {
-      type: "phase",
-      phase: "generate-sections",
-      step: state.currentStep,
-      stepIndex: state.stepIndex,
-      totalSteps: state.totalSteps,
-      taskId: state.taskId,
-      description: state.description,
-      sharedContext: state.sectionPlan.sharedContext,
-      parallelSections,
-      consolidateOrder: state.sectionPlan.consolidateLevels,
-      context: {
-        instruction: this.getStepInstructionPath(state.currentStep),
-        template: this.getStepTemplatePath(state.currentStep),
-        previousOutput,
-        outputDir: join5(outputPath, state.taskId, "sections", state.currentStep)
-      },
-      onComplete: `sections-done ${state.taskId}`
-    };
-  }
-  /**
-   * Phase: Consolidate sections at a specific level
-   */
-  responsePhaseConsolidate(state, level) {
-    if (!state.sectionPlan) {
-      throw new Error("Section plan not initialized");
-    }
-    const outputPath = this.getOutputPath();
-    const parallelGroups = level.groups.map((group) => ({
-      ...group,
-      outputPath: join5(outputPath, state.taskId, group.outputPath)
-    }));
-    return {
-      type: "phase",
-      phase: "consolidate",
-      step: state.currentStep,
-      taskId: state.taskId,
-      level: level.depth,
-      parallelGroups,
-      sharedContext: state.sectionPlan.sharedContext,
-      onComplete: `consolidate-level-done ${state.taskId} ${level.depth}`
-    };
-  }
-  /**
-   * Validate that all section files exist before consolidation
-   */
-  validateConsolidateReady(state, level) {
-    const outputPath = this.getOutputPath();
-    const warnings = [];
-    const missing = [];
-    for (const group of level.groups) {
-      for (const childId of group.childIds) {
-        const findSection = (plan, id) => {
-          for (const leaf of plan.leaves) {
-            if (leaf.id === id) {
-              return leaf.outputPath;
-            }
-          }
-          for (const lvl of plan.consolidateLevels) {
-            for (const g of lvl.groups) {
-              if (g.parentId === id) {
-                return g.outputPath;
-              }
-            }
-          }
-          return void 0;
-        };
-        const childPath = findSection(state.sectionPlan, childId);
-        if (!childPath) {
-          missing.push(childId);
-          continue;
-        }
-        const fullPath = join5(outputPath, state.taskId, childPath);
-        if (!existsSync5(fullPath)) {
-          missing.push(childId);
-        } else {
-          const content = readFileSync5(fullPath, "utf-8");
-          if (!content.trim()) {
-            warnings.push(`Empty section file: ${childId}`);
-          }
-          if (!content.match(/^#+ /m)) {
-            warnings.push(`Section missing header: ${childId}`);
-          }
-        }
-      }
-    }
-    if (missing.length > 0) {
-      return {
-        valid: false,
-        error: `Missing section files: ${missing.join(", ")}`,
-        warnings,
-        missing
-      };
-    }
-    return { valid: true, warnings };
-  }
   /**
    * Checkpoint: Questions need answers
    */
@@ -2158,7 +1723,7 @@ ${issues}`;
   /**
    * Phase 2 complete: Questions generated (or none)
    * If questions exist → checkpoint
-   * If no questions → move to draft phase with accumulated answers
+   * If no questions → move to execute phase with accumulated answers
    */
   cmdClarifyDone(taskId, questions) {
     const state = this.loadState(taskId);
@@ -2173,15 +1738,8 @@ ${issues}`;
       return this.responseCheckpointClarify(state);
     }
     state.answers = state.qaHistory?.map((entry) => entry.answer);
-    this.initSectionPlan(state);
-    if (state.sectionPlan) {
-      state.status = "phase_sections";
-      state.phase = "draft";
-      this.saveState(state);
-      return this.responsePhaseGenerateSections(state);
-    }
     state.status = "phase_execute";
-    state.phase = "draft";
+    state.phase = "execute";
     state.verifyAttempts = 0;
     this.saveState(state);
     return this.responsePhaseExecute(state);
@@ -2391,110 +1949,6 @@ ${issues}`;
     this.saveState(state);
     return this.responseComplete(state, "stopped");
   }
-  // ===========================================================================
-  // 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
-      };
-    }
-  }
-  /**
-   * All sections completed, move to consolidation
-   */
-  cmdSectionsDone(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);
-    }
-    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);
-  }
-  /**
-   * 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);
-  }
   /**
    * Get current workflow status
    */
@@ -2527,15 +1981,6 @@ ${issues}`;
         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);
@@ -2557,10 +2002,9 @@ ${issues}`;
 };
 
 // src/core/step-executor.ts
-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 { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join6 } from "path";
 import matter3 from "gray-matter";
-var fsExistsSync = existsSync6;
 var StepExecutor = class {
   adapter;
   config;
@@ -2802,159 +2246,6 @@ var StepExecutor = class {
     };
   }
   // ==========================================================================
-  // Phase 3 (Section Mode): Parallel Section Generation
-  // ==========================================================================
-  /**
-   * Execute section generation phase - AI creates individual sections in parallel
-   */
-  async executeSectionsPhase(sections, sharedContext, gatheredContext, answers) {
-    this.adapter.io.notify(
-      `Phase 3/4: Generating ${sections.length} sections in parallel`,
-      "info"
-    );
-    const executeParams = sections.map((section) => {
-      const params = {
-        section: {
-          id: section.id,
-          title: section.title,
-          outputPath: section.outputPath,
-          instruction: section.instruction,
-          position: section.position,
-          templateContent: section.templateContent
-        },
-        sharedContext,
-        gatheredContext,
-        answers
-      };
-      const { prompt, outputPath } = buildSectionPrompt(params);
-      return { id: section.id, prompt, outputPath };
-    });
-    let results;
-    if (this.adapter.ai.executeParallel) {
-      const parallelResults = await this.adapter.ai.executeParallel(executeParams);
-      results = parallelResults.map((r) => {
-        const param = executeParams.find((p) => p.id === r.id);
-        if (r.success && param && !fsExistsSync(param.outputPath)) {
-          return { id: r.id, success: false, error: `File not created: ${param.outputPath}` };
-        }
-        return { id: r.id, success: r.success, error: r.error };
-      });
-    } else {
-      results = await Promise.all(
-        executeParams.map(async ({ id, prompt, outputPath }) => {
-          try {
-            const dir = dirname3(outputPath);
-            if (!fsExistsSync(dir)) {
-              mkdirSync4(dir, { recursive: true });
-            }
-            await this.adapter.ai.execute({ prompt, outputPath });
-            if (!fsExistsSync(outputPath)) {
-              return { id, success: false, error: `File not created: ${outputPath}` };
-            }
-            this.adapter.io.notify(`Section created: ${id}`, "success");
-            return { id, success: true };
-          } catch (error) {
-            return {
-              id,
-              success: false,
-              error: error instanceof Error ? error.message : String(error)
-            };
-          }
-        })
-      );
-    }
-    const failures = results.filter((r) => !r.success);
-    if (failures.length > 0) {
-      const errorMsg = failures.map((f) => `${f.id}: ${f.error}`).join(", ");
-      throw new Error(`Section generation failed: ${errorMsg}`);
-    }
-    return { phase: "generate" };
-  }
-  /**
-   * Execute consolidation phase - AI merges child sections into parent
-   */
-  async executeConsolidatePhase(groups, sharedContext, getSectionPath) {
-    this.adapter.io.notify(
-      `Consolidating ${groups.length} section groups`,
-      "info"
-    );
-    const executeParams = [];
-    for (const group of groups) {
-      const childContents = [];
-      let hasError = false;
-      for (const childId of group.childIds) {
-        const childPath = getSectionPath(childId);
-        if (!childPath || !fsExistsSync(childPath)) {
-          executeParams.push({ id: group.parentId, error: `Child section not found: ${childId}` });
-          hasError = true;
-          break;
-        }
-        childContents.push({
-          id: childId,
-          content: readFileSync6(childPath, "utf-8")
-        });
-      }
-      if (hasError) continue;
-      const params = {
-        group: {
-          parentId: group.parentId,
-          childIds: group.childIds,
-          outputPath: group.outputPath
-        },
-        childContents,
-        sharedContext
-      };
-      const { prompt, outputPath } = buildConsolidatePrompt(params);
-      executeParams.push({ id: group.parentId, prompt, outputPath });
-    }
-    const earlyErrors = executeParams.filter((p) => "error" in p);
-    if (earlyErrors.length > 0) {
-      const errorMsg = earlyErrors.map((e) => `${e.id}: ${e.error}`).join(", ");
-      throw new Error(`Consolidation failed: ${errorMsg}`);
-    }
-    const validParams = executeParams;
-    let results;
-    if (this.adapter.ai.executeParallel) {
-      const parallelResults = await this.adapter.ai.executeParallel(validParams);
-      results = parallelResults.map((r) => {
-        const param = validParams.find((p) => p.id === r.id);
-        if (r.success && param && !fsExistsSync(param.outputPath)) {
-          return { id: r.id, success: false, error: `File not created: ${param.outputPath}` };
-        }
-        return { id: r.id, success: r.success, error: r.error };
-      });
-    } else {
-      results = await Promise.all(
-        validParams.map(async ({ id, prompt, outputPath }) => {
-          try {
-            const dir = dirname3(outputPath);
-            if (!fsExistsSync(dir)) {
-              mkdirSync4(dir, { recursive: true });
-            }
-            await this.adapter.ai.execute({ prompt, outputPath });
-            if (!fsExistsSync(outputPath)) {
-              return { id, success: false, error: `File not created: ${outputPath}` };
-            }
-            this.adapter.io.notify(`Consolidated: ${id}`, "success");
-            return { id, success: true };
-          } catch (error) {
-            return {
-              id,
-              success: false,
-              error: error instanceof Error ? error.message : String(error)
-            };
-          }
-        })
-      );
-    }
-    const failures = results.filter((r) => !r.success);
-    if (failures.length > 0) {
-      const errorMsg = failures.map((f) => `${f.id}: ${f.error}`).join(", ");
-      throw new Error(`Consolidation failed: ${errorMsg}`);
-    }
-    return { phase: "generate" };
-  }
-  // ==========================================================================
   // Phase 4: Review (Approval)
   // ==========================================================================
   /**
@@ -3156,8 +2447,8 @@ var StepExecutor = class {
 
 // src/adapters/cli.ts
 import { spawn, spawnSync } from "child_process";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync7, mkdirSync as mkdirSync5 } from "fs";
-import { dirname as dirname4 } from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname3 } from "path";
 import { input, select, confirm } from "@inquirer/prompts";
 var CLIAIAdapter = class {
   claudeCommand;
@@ -3168,9 +2459,9 @@ var CLIAIAdapter = class {
     console.log(`
 \u{1F4DD} Generating...`);
     if (params.outputPath) {
-      const outputDir = dirname4(params.outputPath);
+      const outputDir = dirname3(params.outputPath);
       if (!existsSync7(outputDir)) {
-        mkdirSync5(outputDir, { recursive: true });
+        mkdirSync4(outputDir, { recursive: true });
       }
     }
     const stdout = await this.callClaude(params.prompt);
@@ -3251,9 +2542,9 @@ var CLIAIAdapter = class {
         const id = p.id || p.outputPath;
         try {
           if (p.outputPath) {
-            const outputDir = dirname4(p.outputPath);
+            const outputDir = dirname3(p.outputPath);
             if (!existsSync7(outputDir)) {
-              mkdirSync5(outputDir, { recursive: true });
+              mkdirSync4(outputDir, { recursive: true });
             }
           }
           await this.callClaude(p.prompt, false);
@@ -3358,9 +2649,9 @@ var CLISystemAdapter = class {
     return readFileSync7(path, "utf-8");
   }
   writeFile(path, content) {
-    const dir = dirname4(path);
+    const dir = dirname3(path);
     if (!existsSync7(dir)) {
-      mkdirSync5(dir, { recursive: true });
+      mkdirSync4(dir, { recursive: true });
     }
     writeFileSync5(path, content);
   }
@@ -3396,8 +2687,8 @@ function createCLIAdapter(claudeCommand = "claude") {
 
 // src/adapters/github.ts
 import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync8, mkdirSync as mkdirSync6 } from "fs";
-import { dirname as dirname5 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname4 } from "path";
 var GitHubAIAdapter = class {
   claudeCommand;
   constructor(claudeCommand = "claude") {
@@ -3407,9 +2698,9 @@ var GitHubAIAdapter = class {
     console.log(`
 \u{1F4DD} Generating...`);
     if (params.outputPath) {
-      const outputDir = dirname5(params.outputPath);
+      const outputDir = dirname4(params.outputPath);
       if (!existsSync8(outputDir)) {
-        mkdirSync6(outputDir, { recursive: true });
+        mkdirSync5(outputDir, { recursive: true });
       }
     }
     const stdout = await this.callClaude(params.prompt);
@@ -3465,9 +2756,9 @@ var GitHubAIAdapter = class {
         const id = p.id || p.outputPath;
         try {
           if (p.outputPath) {
-            const outputDir = dirname5(p.outputPath);
+            const outputDir = dirname4(p.outputPath);
             if (!existsSync8(outputDir)) {
-              mkdirSync6(outputDir, { recursive: true });
+              mkdirSync5(outputDir, { recursive: true });
             }
           }
           await this.callClaude(p.prompt);
@@ -3640,9 +2931,9 @@ var GitHubSystemAdapter = class {
     return readFileSync8(path, "utf-8");
   }
   writeFile(path, content) {
-    const dir = dirname5(path);
+    const dir = dirname4(path);
     if (!existsSync8(dir)) {
-      mkdirSync6(dir, { recursive: true });
+      mkdirSync5(dir, { recursive: true });
     }
     writeFileSync6(path, content);
   }
@@ -4275,7 +3566,7 @@ Resume with: spets resume --task ${taskId}`);
 }
 
 // src/commands/plugin.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, writeFileSync as writeFileSync7, rmSync } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, writeFileSync as writeFileSync7, rmSync } from "fs";
 import { join as join8 } from "path";
 import { homedir } from "os";
 async function pluginCommand(action, name) {
@@ -4320,7 +3611,7 @@ async function installPlugin(name) {
 function installClaudePlugin() {
   const claudeDir = join8(homedir(), ".claude");
   const commandsDir = join8(claudeDir, "commands");
-  mkdirSync7(commandsDir, { recursive: true });
+  mkdirSync6(commandsDir, { recursive: true });
   const skillPath = join8(commandsDir, "spets.md");
   writeFileSync7(skillPath, getClaudeSkillContent());
   console.log("Installed Claude Code plugin.");
@@ -4406,8 +3697,6 @@ Parse JSON response \u2192 execute action from table below \u2192 loop until \`t
 | \`clarify\` | [ACTION_CLARIFY](#action_clarify) |
 | \`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) |
 
@@ -4515,65 +3804,6 @@ This ensures identical behavior across CLI, Claude Code, and GitHub modes.
 5. Parse response \u2192 next action
 \`\`\`
 
-### ACTION_PARALLEL_SECTIONS
-
-**PARALLEL EXECUTION (FOREGROUND)**
-
-\`\`\`
-1. FOR EACH section IN parallelSections:
-   Task(
-     subagent_type: "general-purpose",
-     prompt: "
-       Generate section and save to file. Return ONLY the path.
-
-       Path: {section.outputPath}
-       Title: {section.title}
-       Instruction: {section.instruction}
-       Context: {sharedContext.description}
-
-       1. Generate content for this section
-       2. Write to the path using Write tool
-       3. Return ONLY: {section.outputPath}
-          (no explanations, no content, just the path)
-     "
-   )
-
-2. ALL Task calls MUST be in SINGLE message (parallel execution)
-
-3. Bash: npx spets orchestrate sections-done {taskId}
-
-4. Parse response \u2192 next action
-\`\`\`
-
-### ACTION_PARALLEL_CONSOLIDATE
-
-**PARALLEL EXECUTION (FOREGROUND)**
-
-\`\`\`
-1. FOR EACH group IN parallelGroups:
-   Task(
-     subagent_type: "general-purpose",
-     prompt: "
-       Merge children into parent. Return ONLY the path.
-
-       Output: {group.outputPath}
-       Children: {group.childPaths}
-
-       1. Read each child file
-       2. Merge preserving hierarchy
-       3. Write to output using Write tool
-       4. Return ONLY: {group.outputPath}
-          (no explanations, no content, just the path)
-     "
-   )
-
-2. ALL Task calls MUST be in SINGLE message (parallel execution)
-
-3. Bash: npx spets orchestrate consolidate-level-done {taskId} {level}
-
-4. Parse response \u2192 next action
-\`\`\`
-
 ### ACTION_ASK_QUESTIONS
 
 \`\`\`
@@ -4645,10 +3875,6 @@ 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>
@@ -5388,35 +4614,8 @@ async function orchestrateCommand(action, args) {
         outputJSON(result);
         break;
       }
-      // Section-based workflow commands
-      case "sections-done": {
-        const taskId = args[0];
-        if (!taskId) {
-          outputError("Task ID is required for sections-done");
-          return;
-        }
-        const result = orchestrator.cmdSectionsDone(taskId);
-        outputJSON(result);
-        break;
-      }
-      case "consolidate-level-done": {
-        const taskId = args[0];
-        const levelStr = args[1];
-        if (!taskId || !levelStr) {
-          outputError("Task ID and level are required for consolidate-level-done");
-          return;
-        }
-        const level = parseInt(levelStr, 10);
-        if (isNaN(level)) {
-          outputError("Level must be a number");
-          return;
-        }
-        const result = orchestrator.cmdConsolidateLevelDone(taskId, level);
-        outputJSON(result);
-        break;
-      }
       default:
-        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)`);
+        outputError(`Unknown action: ${action}. Valid actions: init, explore-done, clarify-done, execute-done, verify-done, clarified, approve, revise, reject, stop, status (legacy: context-done, generate-done, draft-done, done)`);
     }
   } catch (e) {
     outputError(e.message);
@@ -5424,7 +4623,7 @@ async function orchestrateCommand(action, args) {
 }
 
 // src/index.ts
-var __dirname2 = dirname6(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname5(fileURLToPath2(import.meta.url));
 var pkg = JSON.parse(readFileSync11(join11(__dirname2, "..", "package.json"), "utf-8"));
 var program = new Command();
 program.name("spets").description("Spec Driven Development Execution Framework").version(pkg.version);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spets",
-  "version": "0.1.40",
+  "version": "0.1.42",
   "description": "Spec Driven Development Execution Framework",
   "type": "module",
   "main": "dist/index.js",