spets 0.1.87 → 0.1.89

package/dist/{chunk-FRBU44MW.js → chunk-DVDS7BTW.js}

@@ -80,68 +80,11 @@ function listTasks(cwd = process.cwd()) {
   }
   return readdirSync(outputsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
 }
-function getStateCachePath(taskId, cwd = process.cwd()) {
-  return join(getTaskDir(taskId, cwd), ".state-cache.json");
-}
-function loadStateCache(taskId, cwd = process.cwd()) {
-  const cachePath = getStateCachePath(taskId, cwd);
-  if (!existsSync(cachePath)) {
-    return null;
-  }
-  try {
-    const cached = JSON.parse(readFileSync(cachePath, "utf-8"));
-    return cached;
-  } catch {
-    return null;
-  }
-}
-function saveStateCache(taskId, state, cwd = process.cwd()) {
-  const cachePath = getStateCachePath(taskId, cwd);
-  const stepStatuses = {};
-  for (const [stepName, output] of state.outputs.entries()) {
-    stepStatuses[stepName] = output.status;
-  }
-  const cached = {
-    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-    taskId: state.taskId,
-    userQuery: state.userQuery,
-    currentStepIndex: state.currentStepIndex,
-    currentStepName: state.currentStepName,
-    status: state.status,
-    stepStatuses
-  };
-  try {
-    writeFileSync(cachePath, JSON.stringify(cached, null, 2));
-  } catch {
-  }
-}
-function isStateCacheValid(cached, maxAgeMs = 5e3) {
-  const age = Date.now() - new Date(cached.lastUpdated).getTime();
-  return age < maxAgeMs;
-}
 function getWorkflowState(taskId, config, cwd = process.cwd()) {
   const taskDir = getTaskDir(taskId, cwd);
   if (!existsSync(taskDir)) {
     return null;
   }
-  const cached = loadStateCache(taskId, cwd);
-  if (cached && isStateCacheValid(cached)) {
-    const outputs2 = /* @__PURE__ */ new Map();
-    for (const [stepName, status] of Object.entries(cached.stepStatuses)) {
-      outputs2.set(stepName, {
-        path: getOutputPath(taskId, stepName, cwd),
-        status
-      });
-    }
-    return {
-      taskId: cached.taskId,
-      userQuery: cached.userQuery,
-      currentStepIndex: cached.currentStepIndex,
-      currentStepName: cached.currentStepName,
-      status: cached.status,
-      outputs: outputs2
-    };
-  }
   const outputs = /* @__PURE__ */ new Map();
   let lastApprovedIndex = -1;
   let currentStatus = "in_progress";
@@ -176,7 +119,7 @@ function getWorkflowState(taskId, config, cwd = process.cwd()) {
   if (currentDoc?.frontmatter.status === "draft" && currentDoc.frontmatter.open_questions?.length) {
     currentStatus = "paused";
   }
-  const state = {
+  return {
     taskId,
     userQuery,
     currentStepIndex,
@@ -184,8 +127,6 @@ function getWorkflowState(taskId, config, cwd = process.cwd()) {
     status: currentStatus,
     outputs
   };
-  saveStateCache(taskId, state, cwd);
-  return state;
 }
 function loadTaskMetadata(taskId, cwd = process.cwd()) {
   const metaPath = join(getTaskDir(taskId, cwd), ".meta.json");

package/dist/index.js

@@ -15,7 +15,7 @@ import {
   loadTaskMetadata,
   renderTasksJSON,
   runTasksInteractive
-} from "./chunk-FRBU44MW.js";
+} from "./chunk-DVDS7BTW.js";
 import {
   renderDocsJSON,
   runDocsInteractive
@@ -1263,6 +1263,100 @@ function buildVerifyPrompt(params) {
   parts.push("");
   return parts.join("\n");
 }
+function buildKnowledgeExtractPrompt(params) {
+  const parts = [];
+  parts.push("# Knowledge Extraction Phase");
+  parts.push("");
+  parts.push("Your task is to extract reusable knowledge from this workflow.");
+  parts.push("This knowledge will be saved and used to improve future workflows.");
+  parts.push("");
+  parts.push("## Task Information");
+  parts.push("");
+  parts.push(`- **Task ID**: ${params.taskId}`);
+  parts.push(`- **Description**: ${params.description}`);
+  parts.push("");
+  if (params.guide) {
+    parts.push("## Knowledge Guide");
+    parts.push("");
+    parts.push(params.guide);
+    parts.push("");
+  }
+  if (params.decisionHistory && params.decisionHistory.length > 0) {
+    parts.push("## Decisions Made");
+    parts.push("");
+    for (const entry of params.decisionHistory) {
+      const selectedOption = entry.decision.options.find((o) => o.id === entry.answer.selectedOptionId);
+      parts.push(`### ${entry.decision.decision}`);
+      parts.push(`**Why asked:** ${entry.decision.why}`);
+      parts.push(`**Selected:** ${selectedOption?.label || entry.answer.selectedOptionId}`);
+      if (entry.answer.customInput) {
+        parts.push(`**User note:** ${entry.answer.customInput}`);
+      }
+      parts.push("");
+    }
+  }
+  if (params.exploreOutputs && params.exploreOutputs.length > 0) {
+    parts.push("## Patterns and Constraints Found");
+    parts.push("");
+    for (const explore of params.exploreOutputs) {
+      parts.push(`### Step: ${explore.step}`);
+      if (explore.output.patterns.length > 0) {
+        parts.push("**Patterns:**");
+        for (const pattern of explore.output.patterns) {
+          parts.push(`- ${pattern}`);
+        }
+      }
+      if (explore.output.constraints.length > 0) {
+        parts.push("**Constraints:**");
+        for (const constraint of explore.output.constraints) {
+          parts.push(`- ${constraint}`);
+        }
+      }
+      parts.push("");
+    }
+  }
+  parts.push("## Your Task");
+  parts.push("");
+  parts.push("Extract knowledge that would be useful for future workflows:");
+  parts.push("");
+  parts.push("**What to extract:**");
+  parts.push("- User preferences and decisions that apply broadly");
+  parts.push("- Codebase patterns that should be followed");
+  parts.push("- Constraints that must be respected");
+  parts.push("- Architecture decisions and their rationale");
+  parts.push("");
+  parts.push("**What NOT to extract:**");
+  parts.push("- Task-specific implementation details");
+  parts.push("- One-time decisions");
+  parts.push("- Temporary workarounds");
+  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('  "entries": [');
+  parts.push("    {");
+  parts.push('      "filename": "pattern--error-handling",');
+  parts.push('      "content": "The knowledge content in markdown format...",');
+  parts.push('      "reason": "Why this is worth saving"');
+  parts.push("    }");
+  parts.push("  ]");
+  parts.push("}");
+  parts.push("```");
+  parts.push("");
+  parts.push("**Filename tips:**");
+  parts.push("- Use kebab-case");
+  parts.push("- Optional prefixes: `pref--` (preference), `rule--` (rule), `pattern--` (pattern)");
+  parts.push("- Put key terms first for easier discovery");
+  parts.push("");
+  parts.push('If there is no meaningful knowledge to extract, return: `{"entries": []}`');
+  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 {
@@ -1479,6 +1573,35 @@ ${issues}`;
       onComplete: `npx spets orchestrate verify-done ${state.taskId}`
     };
   }
+  /**
+   * Phase 5: Knowledge extraction
+   * AI automatically extracts and saves knowledge from the workflow
+   */
+  responsePhaseKnowledge(state) {
+    const guide = loadGuide(this.cwd);
+    const prompt = buildKnowledgeExtractPrompt({
+      taskId: state.taskId,
+      description: state.description,
+      decisionHistory: state.decisionHistory,
+      exploreOutputs: state.exploreOutput ? [{ step: state.currentStep, output: state.exploreOutput }] : void 0,
+      guide,
+      cwd: this.cwd
+    });
+    return {
+      type: "phase",
+      phase: "knowledge",
+      taskId: state.taskId,
+      description: state.description,
+      prompt,
+      workflowSummary: {
+        decisionHistory: state.decisionHistory,
+        exploreOutputs: state.exploreOutput ? [{ step: state.currentStep, output: state.exploreOutput }] : void 0,
+        totalSteps: state.totalSteps
+      },
+      guide,
+      onComplete: `npx spets orchestrate knowledge-extract-done ${state.taskId}`
+    };
+  }
   /**
    * Checkpoint: Decisions need user input
    */
@@ -1754,9 +1877,10 @@ ${entry.answer.customInput ? `**User note:** ${entry.answer.customInput}` : ""}`
     } else {
       const config = loadConfig(this.cwd);
       if (config.knowledge?.enabled) {
-        state.status = "knowledge_pending";
+        state.status = "phase_knowledge";
+        state.phase = "review";
         this.saveState(state);
-        return this.responseCheckpointKnowledge(state);
+        return this.responsePhaseKnowledge(state);
       }
       state.status = "completed";
       this.saveState(state);
@@ -1795,6 +1919,26 @@ ${entry.answer.customInput ? `**User note:** ${entry.answer.customInput}` : ""}`
     this.saveState(state);
     return this.responseComplete(state, "completed");
   }
+  /**
+   * AI completed knowledge extraction - save entries and finish
+   */
+  cmdKnowledgeExtractDone(taskId, output) {
+    const state = this.loadState(taskId);
+    if (!state) {
+      return this.responseError(`No workflow found: ${taskId}`, taskId);
+    }
+    for (const entry of output.entries) {
+      saveKnowledge(
+        entry.filename,
+        entry.content,
+        { taskId: state.taskId, step: state.currentStep },
+        this.cwd
+      );
+    }
+    state.status = "completed";
+    this.saveState(state);
+    return this.responseComplete(state, "completed");
+  }
   /**
    * Request revision with feedback - goes back to execute phase
    */
@@ -1890,8 +2034,8 @@ ${entry.answer.customInput ? `**User note:** ${entry.answer.customInput}` : ""}`
         return this.responsePhaseVerify(state);
       case "approve_pending":
         return this.responseCheckpointApprove(state);
-      case "knowledge_pending":
-        return this.responseCheckpointKnowledge(state);
+      case "phase_knowledge":
+        return this.responsePhaseKnowledge(state);
       case "completed":
       case "stopped":
       case "rejected":
@@ -2148,6 +2292,38 @@ var StepExecutor = class {
     };
   }
   // ==========================================================================
+  // Knowledge Extraction Phase
+  // ==========================================================================
+  /**
+   * Execute knowledge extraction phase - AI extracts knowledge from workflow
+   */
+  async executeKnowledgePhase(phaseResponse) {
+    this.adapter.io.notify("Extracting knowledge from workflow...", "info");
+    const prompt = buildKnowledgeExtractPrompt({
+      taskId: phaseResponse.taskId,
+      description: phaseResponse.description,
+      decisionHistory: phaseResponse.workflowSummary.decisionHistory,
+      exploreOutputs: phaseResponse.workflowSummary.exploreOutputs,
+      guide: phaseResponse.guide,
+      cwd: this.cwd
+    });
+    const response = await this.adapter.ai.execute({
+      prompt,
+      outputPath: ""
+      // No file output needed
+    });
+    const knowledgeOutput = this.parseKnowledgeOutput(response || "");
+    if (knowledgeOutput.entries.length > 0) {
+      this.adapter.io.notify(`Extracted ${knowledgeOutput.entries.length} knowledge entries`, "success");
+    } else {
+      this.adapter.io.notify("No knowledge entries to save", "info");
+    }
+    return {
+      phase: "knowledge",
+      knowledgeOutput
+    };
+  }
+  // ==========================================================================
   // Phase 4: Review (Approval)
   // ==========================================================================
   /**
@@ -2338,6 +2514,40 @@ var StepExecutor = class {
       summary: "Verification parsing failed"
     };
   }
+  /**
+   * Parse knowledge extraction output (JSON)
+   */
+  parseKnowledgeOutput(response) {
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        const entries = Array.isArray(parsed.entries) ? parsed.entries : [];
+        return {
+          entries: entries.map((e) => ({
+            filename: e.filename || "",
+            content: e.content || "",
+            reason: e.reason || ""
+          }))
+        };
+      }
+      const arrayMatch = response.match(/\[[\s\S]*\]/);
+      if (arrayMatch) {
+        const parsed = JSON.parse(arrayMatch[0]);
+        if (Array.isArray(parsed)) {
+          return {
+            entries: parsed.map((e) => ({
+              filename: e.filename || "",
+              content: e.content || "",
+              reason: e.reason || ""
+            }))
+          };
+        }
+      }
+    } catch {
+    }
+    return { entries: [] };
+  }
   /**
    * Update document status in frontmatter
    */
@@ -2980,37 +3190,37 @@ var GitHubIOAdapter = class {
     ];
     for (let i = 0; i < decisions.length; i++) {
       const d = decisions[i];
-      lines.push(`### D${i + 1}: ${d.decision}`);
+      lines.push(`### Q${i + 1}: ${d.decision}`);
       lines.push(`> ${d.why}`);
       lines.push("");
       lines.push("**Options:**");
+      let optNum = 1;
       for (const opt of d.options) {
         if (opt.id === "ai") {
-          lines.push(`- **Recommended**${opt.reason ? ` (${opt.reason})` : ""}`);
+          lines.push(`- **Recommended:** ${opt.recommendation || "AI choice"}${opt.reason ? ` (${opt.reason})` : ""}`);
         } else {
-          lines.push(`- ${opt.label}${opt.tradeoffs ? ` - ${opt.tradeoffs}` : ""}`);
+          lines.push(`${optNum}. ${opt.label}${opt.tradeoffs ? ` - ${opt.tradeoffs}` : ""}`);
+          optNum++;
         }
       }
       lines.push("");
     }
     lines.push("---");
     lines.push("");
-    lines.push("**How to decide:**");
+    lines.push("**Respond naturally:**");
     lines.push("");
     lines.push("```");
     lines.push("/decide");
     for (let i = 0; i < decisions.length; i++) {
-      const d = decisions[i];
-      lines.push(`D${i + 1}: ${d.decision}`);
-      for (const opt of d.options) {
-        if (opt.id === "ai") {
-          lines.push(`  - AI Recommended`);
-        } else {
-          lines.push(`  - ${opt.label}`);
-        }
-      }
+      lines.push(`Q${i + 1}: <your choice or thoughts>`);
     }
     lines.push("```");
+    lines.push("");
+    lines.push("Examples:");
+    lines.push("- `Q1: I like the first option`");
+    lines.push("- `Q1: go with the recommended`");
+    lines.push("- `Q1: elaborate on option 2`");
+    lines.push("- `Q1: something else - I want to use X instead`");
     return lines.join("\n");
   }
   formatApprovalComment(doc, stepName, stepIndex, totalSteps, specPath) {
@@ -3659,6 +3869,11 @@ async function startCommand(query, options) {
           };
           const result = await stepExecutor.executeVerifyPhase(verifyResp.step, stepContext);
           response = orchestrator.cmdVerifyDone(taskId, result.verifyOutput);
+        } else if (phaseResponse.phase === "knowledge") {
+          const knowledgeResp = phaseResponse;
+          console.log("\n\u{1F4DA} Extracting knowledge...\n");
+          const result = await stepExecutor.executeKnowledgePhase(knowledgeResp);
+          response = orchestrator.cmdKnowledgeExtractDone(taskId, result.knowledgeOutput);
         }
       } else if (response.type === "checkpoint") {
         taskId = response.taskId;
@@ -4127,9 +4342,10 @@ function parseGitHubCommand(comment) {
     const decisions = {};
     const decisionLines = decisionsText.split("\n");
     for (const line of decisionLines) {
-      const match = line.match(/^(D\d+)[:.]\s*([^#]+)/i);
+      const match = line.match(/^([QD]\d+)[:.]\s*(.+)$/i);
       if (match) {
-        decisions[match[1].toLowerCase()] = match[2].trim();
+        const key = match[1].toLowerCase().replace("d", "q");
+        decisions[key] = match[2].trim();
       }
     }
     return { command: "decide", decisions };
@@ -4272,13 +4488,30 @@ async function githubCommand(options) {
       break;
     }
     case "decide": {
-      console.log("Processing decisions");
-      const decisionAnswers = Object.entries(parsed.decisions || {}).sort(([a], [b]) => a.localeCompare(b)).map(([id, value]) => ({
-        decisionId: id,
-        selectedOptionId: value,
-        // Will be matched against option IDs, or used as custom input
-        customInput: value
-        // Also provide as custom input in case it doesn't match an option
+      console.log("Processing decisions with AI interpretation...");
+      const currentState = orchestrator.cmdStatus(taskId);
+      if (currentState.type !== "checkpoint" || currentState.checkpoint !== "clarify") {
+        console.error("No pending decisions found. Task may not be in clarify state.");
+        process.exit(1);
+      }
+      const pendingDecisions = currentState.decisions;
+      const userResponses = parsed.decisions || {};
+      const interpretedAnswers = await interpretDecisionResponses(pendingDecisions, userResponses, githubConfig);
+      const followUps = interpretedAnswers.filter((a) => a.followUp);
+      if (followUps.length > 0) {
+        for (const followUp of followUps) {
+          const decision = pendingDecisions.find((d) => d.id === followUp.decisionId);
+          if (decision && followUp.followUp) {
+            await postFollowUpComment(githubConfig, decision, followUp.followUp, taskId);
+          }
+        }
+        console.log("\n\u23F8\uFE0F  Follow-up questions posted. Waiting for /decide response.");
+        return;
+      }
+      const decisionAnswers = interpretedAnswers.map((a) => ({
+        decisionId: a.decisionId,
+        selectedOptionId: a.selectedOptionId,
+        customInput: a.customInput
       }));
       response = orchestrator.cmdClarified(taskId, decisionAnswers);
       break;
@@ -4532,6 +4765,150 @@ Closes #${issueNumber}`;
   }
   return { title, body };
 }
+async function interpretDecisionResponses(decisions, userResponses, config) {
+  const results = [];
+  for (let i = 0; i < decisions.length; i++) {
+    const decision = decisions[i];
+    const key = `q${i + 1}`;
+    const userResponse = userResponses[key] || "";
+    if (!userResponse) {
+      results.push({
+        decisionId: decision.id,
+        selectedOptionId: "ai"
+      });
+      continue;
+    }
+    const optionsText = decision.options.filter((o) => o.id !== "ai").map((o, idx) => `${idx + 1}. ${o.label}: ${o.description || ""}`).join("\n");
+    const aiOption = decision.options.find((o) => o.id === "ai");
+    const prompt = `You are interpreting a user's decision response.
+
+Decision: ${decision.decision}
+Why: ${decision.why}
+
+Options:
+${optionsText}
+${aiOption ? `AI Recommended: ${aiOption.recommendation || "AI choice"} (${aiOption.reason || ""})` : ""}
+
+User's response: "${userResponse}"
+
+Interpret the user's intent and respond with ONLY a JSON object:
+{
+  "action": "select" | "elaborate" | "alternative",
+  "optionId": "<option id if selecting, or which option to elaborate on>",
+  "customInput": "<any custom input if alternative>"
+}
+
+Examples:
+- "I like the first option" \u2192 {"action": "select", "optionId": "opt1"}
+- "go with recommended" \u2192 {"action": "select", "optionId": "ai"}
+- "elaborate on option 2" \u2192 {"action": "elaborate", "optionId": "opt2"}
+- "something else - use gRPC" \u2192 {"action": "alternative", "customInput": "use gRPC"}
+- "the second one" \u2192 {"action": "select", "optionId": "opt2"}
+
+Output ONLY the JSON, no explanation.`;
+    try {
+      const response = await callClaude(prompt);
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        if (parsed.action === "elaborate") {
+          results.push({
+            decisionId: decision.id,
+            selectedOptionId: "",
+            followUp: "elaborate",
+            followUpTarget: parsed.optionId
+          });
+        } else if (parsed.action === "alternative") {
+          results.push({
+            decisionId: decision.id,
+            selectedOptionId: "_custom_",
+            customInput: parsed.customInput || userResponse
+          });
+        } else {
+          const optionId = parsed.optionId || "ai";
+          let finalOptionId = optionId;
+          if (/^opt\d+$/.test(optionId)) {
+            finalOptionId = optionId;
+          } else if (/^\d+$/.test(optionId)) {
+            const idx = parseInt(optionId, 10) - 1;
+            const nonAiOptions = decision.options.filter((o) => o.id !== "ai");
+            if (idx >= 0 && idx < nonAiOptions.length) {
+              finalOptionId = nonAiOptions[idx].id;
+            }
+          }
+          results.push({
+            decisionId: decision.id,
+            selectedOptionId: finalOptionId
+          });
+        }
+      } else {
+        results.push({
+          decisionId: decision.id,
+          selectedOptionId: "_custom_",
+          customInput: userResponse
+        });
+      }
+    } catch (error) {
+      console.error(`Failed to interpret response for ${decision.id}:`, error);
+      results.push({
+        decisionId: decision.id,
+        selectedOptionId: "_custom_",
+        customInput: userResponse
+      });
+    }
+  }
+  return results;
+}
+async function postFollowUpComment(config, decision, followUpType, taskId, targetOptionId) {
+  const { owner, repo, prNumber, issueNumber } = config;
+  let body;
+  if (followUpType === "elaborate") {
+    const targetOption = decision.options.find((o) => o.id === targetOptionId);
+    body = `## \u{1F4DD} Spets: More Details
+
+> Task ID: \`${taskId}\`
+> Question: ${decision.decision}
+
+### ${targetOption?.label || "Option"}
+
+${targetOption?.description || "No additional description available."}
+
+${targetOption?.tradeoffs ? `**Tradeoffs:** ${targetOption.tradeoffs}` : ""}
+
+---
+
+Please respond with your decision:
+\`\`\`
+/decide
+Q1: <your choice after seeing the details>
+\`\`\``;
+  } else {
+    body = `## \u{1F4A1} Spets: Custom Input Needed
+
+> Task ID: \`${taskId}\`
+> Question: ${decision.decision}
+
+You indicated you'd like a different approach. Please describe what you want:
+
+\`\`\`
+/decide
+Q1: <describe your preferred approach>
+\`\`\``;
+  }
+  const args = prNumber ? ["pr", "comment", String(prNumber), "--body", body, "-R", `${owner}/${repo}`] : ["issue", "comment", String(issueNumber), "--body", body, "-R", `${owner}/${repo}`];
+  return new Promise((resolve, reject) => {
+    const proc = spawn7("gh", args, { stdio: ["pipe", "pipe", "pipe"] });
+    let stderr = "";
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) reject(new Error(`Failed to post follow-up: ${stderr}`));
+      else resolve();
+    });
+    proc.on("error", reject);
+  });
+}
 async function callClaude(prompt) {
   return new Promise((resolve, reject) => {
     const proc = spawn7("claude", ["--print"], { stdio: ["pipe", "pipe", "pipe"] });
@@ -4851,8 +5228,32 @@ async function orchestrateCommand(action, args) {
         outputJSON(result);
         break;
       }
+      case "knowledge-extract-done": {
+        const taskId = args[0];
+        const entriesJson = args[1];
+        if (!taskId) {
+          outputError("Task ID is required for knowledge-extract-done");
+          return;
+        }
+        let output = { entries: [] };
+        if (entriesJson) {
+          const parsed = parseFlexibleJSON(entriesJson, {
+            arrayKeys: ["entries"]
+          });
+          if (parsed.success) {
+            if (Array.isArray(parsed.data)) {
+              output = { entries: parsed.data };
+            } else {
+              output = { entries: parsed.data.entries || [] };
+            }
+          }
+        }
+        const result = orchestrator.cmdKnowledgeExtractDone(taskId, output);
+        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, knowledge-save, knowledge-skip`);
+        outputError(`Unknown action: ${action}. Valid actions: init, explore-done, clarify-done, execute-done, verify-done, clarified, approve, revise, reject, stop, status, knowledge-save, knowledge-skip, knowledge-extract-done`);
     }
   } catch (e) {
     outputError(e.message);
@@ -5045,7 +5446,7 @@ async function uiTasksCommand(taskId, options) {
     console.log(renderTasksJSON(taskId, cwd));
     return;
   }
-  const { runTasksInteractive: runTasksInteractive2 } = await import("./tasks-CFMYWYED.js");
+  const { runTasksInteractive: runTasksInteractive2 } = await import("./tasks-3SJVPAZR.js");
   await runTasksInteractive2(cwd);
 }
 async function uiDocsCommand(docName, options) {

package/dist/{tasks-CFMYWYED.js → tasks-3SJVPAZR.js}

@@ -1,7 +1,7 @@
 import {
   renderTasksJSON,
   runTasksInteractive
-} from "./chunk-FRBU44MW.js";
+} from "./chunk-DVDS7BTW.js";
 import "./chunk-VQV22N3Y.js";
 export {
   renderTasksJSON,

package/package.json

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