spets 0.1.78 → 0.1.80

package/dist/index.js

@@ -2,8 +2,8 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { readFileSync as readFileSync13 } from "fs";
-import { dirname as dirname7, join as join11 } from "path";
+import { readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname8, join as join12 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/commands/init.ts
@@ -407,6 +407,7 @@ async function initCommand(options) {
   mkdirSync2(join3(spetsDir, "steps"), { recursive: true });
   mkdirSync2(join3(spetsDir, "outputs"), { recursive: true });
   mkdirSync2(join3(spetsDir, "hooks"), { recursive: true });
+  mkdirSync2(join3(spetsDir, "knowledge"), { recursive: true });
   const templatesDir = join3(__dirname, "..", "templates");
   const hookTemplate = join3(__dirname, "..", "templates", "hooks", "cleanup-branch.sh");
   if (existsSync3(hookTemplate)) {
@@ -417,6 +418,11 @@ async function initCommand(options) {
     } catch {
     }
   }
+  const knowledgeGuideTemplate = join3(__dirname, "..", "templates", "knowledge", "guide.md");
+  if (existsSync3(knowledgeGuideTemplate)) {
+    const guideDest = join3(spetsDir, "knowledge", "guide.md");
+    cpSync(knowledgeGuideTemplate, guideDest);
+  }
   const githubInfo = getGitHubInfoFromRemote();
   writeFileSync2(join3(spetsDir, "config.yml"), getDefaultConfig(githubInfo));
   createDefaultSteps(spetsDir);
@@ -428,6 +434,7 @@ async function initCommand(options) {
   console.log("  .spets/steps/01-plan/template.md  - Planning step template");
   console.log("  .spets/steps/02-implement/template.md - Implementation step template");
   console.log("  .spets/hooks/cleanup-branch.sh    - Example branch cleanup hook");
+  console.log("  .spets/knowledge/guide.md         - Knowledge extraction guide");
   console.log("  .claude/commands/spets.md         - Claude Code command");
   if (options.github) {
     createGitHubWorkflow(cwd);
@@ -467,6 +474,11 @@ steps:
 # Output configuration
 output:
   path: .spets/outputs
+
+# Knowledge base configuration
+knowledge:
+  enabled: true   # Save knowledge from completed workflows
+  inject: true    # Inject available knowledge into explore prompts
 ${githubSection}
 # Optional hooks (shell scripts)
 # hooks:
@@ -797,13 +809,102 @@ function formatDocStatus(status) {
 import { execSync as execSync2 } from "child_process";
 
 // src/orchestrator/index.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
-import { join as join6, dirname as dirname2 } from "path";
-import matter2 from "gray-matter";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync7, mkdirSync as mkdirSync5 } from "fs";
+import { join as join7, dirname as dirname2 } from "path";
+import matter3 from "gray-matter";
 
 // src/core/prompt-builder.ts
-import { readFileSync as readFileSync4, existsSync as existsSync5 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+
+// src/core/knowledge.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync5, mkdirSync as mkdirSync4, readdirSync as readdirSync3 } from "fs";
 import { join as join5 } from "path";
+import matter2 from "gray-matter";
+var KNOWLEDGE_DIR = "knowledge";
+var GUIDE_FILE = "guide.md";
+function getKnowledgeDir(cwd = process.cwd()) {
+  return join5(getSpetsDir(cwd), KNOWLEDGE_DIR);
+}
+function ensureKnowledgeDir(cwd = process.cwd()) {
+  const knowledgeDir = getKnowledgeDir(cwd);
+  if (!existsSync5(knowledgeDir)) {
+    mkdirSync4(knowledgeDir, { recursive: true });
+  }
+}
+function listKnowledgeFiles(cwd = process.cwd()) {
+  const knowledgeDir = getKnowledgeDir(cwd);
+  if (!existsSync5(knowledgeDir)) {
+    return [];
+  }
+  const files = readdirSync3(knowledgeDir).filter((f) => f.endsWith(".md") && f !== GUIDE_FILE).map((f) => f.replace(/\.md$/, "")).sort();
+  return files;
+}
+function loadKnowledgeFile(filename, cwd = process.cwd()) {
+  const knowledgeDir = getKnowledgeDir(cwd);
+  const filePath = join5(knowledgeDir, `${filename}.md`);
+  if (!existsSync5(filePath)) {
+    return null;
+  }
+  const fileContent = readFileSync4(filePath, "utf-8");
+  const { data, content } = matter2(fileContent);
+  return {
+    filename,
+    content: content.trim(),
+    source: data.source || { taskId: "unknown", step: "unknown" },
+    createdAt: data.createdAt || (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function loadKnowledgeFiles(filenames, cwd = process.cwd()) {
+  const entries = [];
+  for (const filename of filenames) {
+    const entry = loadKnowledgeFile(filename, cwd);
+    if (entry) {
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+function saveKnowledge(filename, content, source, cwd = process.cwd()) {
+  ensureKnowledgeDir(cwd);
+  const knowledgeDir = getKnowledgeDir(cwd);
+  const filePath = join5(knowledgeDir, `${filename}.md`);
+  const frontmatter = {
+    source,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const fileContent = matter2.stringify(content, frontmatter);
+  writeFileSync4(filePath, fileContent);
+}
+function loadGuide(cwd = process.cwd()) {
+  const knowledgeDir = getKnowledgeDir(cwd);
+  const guidePath = join5(knowledgeDir, GUIDE_FILE);
+  if (!existsSync5(guidePath)) {
+    return null;
+  }
+  const fileContent = readFileSync4(guidePath, "utf-8");
+  const { content } = matter2(fileContent);
+  return content.trim();
+}
+function buildAvailableKnowledgeSection(cwd = process.cwd()) {
+  const files = listKnowledgeFiles(cwd);
+  if (files.length === 0) {
+    return "";
+  }
+  const parts = [];
+  parts.push("## Available Knowledge");
+  parts.push("");
+  parts.push("\uB2E4\uC74C \uC9C0\uC2DD \uD30C\uC77C\uB4E4\uC774 \uC774 \uD504\uB85C\uC81D\uD2B8\uC5D0 \uC800\uC7A5\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4:");
+  for (const file of files) {
+    parts.push(`- ${file}`);
+  }
+  parts.push("");
+  parts.push("\uD604\uC7AC \uD0DC\uC2A4\uD06C\uC5D0 \uCC38\uACE0\uD560 \uC9C0\uC2DD\uC774 \uC788\uB2E4\uBA74 JSON \uCD9C\uB825\uC758 `knowledgeRequests` \uD544\uB4DC\uC5D0 \uD30C\uC77C\uBA85\uC744 \uCD94\uAC00\uD558\uC138\uC694.");
+  parts.push("");
+  return parts.join("\n");
+}
+
+// src/core/prompt-builder.ts
 function buildContextPrompt(params) {
   const cwd = params.cwd || process.cwd();
   const isFirstStep = params.stepIndex === 1;
@@ -826,8 +927,8 @@ function buildContextPrompt(params) {
   } else if (params.previousOutput) {
     parts.push("## Previous Step Output");
     parts.push("");
-    if (existsSync5(params.previousOutput)) {
-      parts.push(readFileSync4(params.previousOutput, "utf-8"));
+    if (existsSync6(params.previousOutput)) {
+      parts.push(readFileSync5(params.previousOutput, "utf-8"));
     }
     parts.push("");
   }
@@ -878,8 +979,8 @@ function buildExplorePrompt(params) {
   } else if (params.previousOutput) {
     parts.push("## Previous Step Output");
     parts.push("");
-    if (existsSync5(params.previousOutput)) {
-      parts.push(readFileSync4(params.previousOutput, "utf-8"));
+    if (existsSync6(params.previousOutput)) {
+      parts.push(readFileSync5(params.previousOutput, "utf-8"));
     }
     parts.push("");
   }
@@ -893,6 +994,13 @@ function buildExplorePrompt(params) {
   parts.push("");
   parts.push("**Key difference from context phase:** You must READ file contents, not just list them.");
   parts.push("");
+  const config = loadConfig(cwd);
+  if (config.knowledge?.inject !== false) {
+    const knowledgeSection = buildAvailableKnowledgeSection(cwd);
+    if (knowledgeSection) {
+      parts.push(knowledgeSection);
+    }
+  }
   parts.push("## Output Format");
   parts.push("");
   parts.push("Output a JSON object with this structure:");
@@ -918,7 +1026,8 @@ function buildExplorePrompt(params) {
   parts.push('  "dependencies": [');
   parts.push('    "gray-matter for frontmatter parsing",');
   parts.push('    "Internal: uses ../core/config.js"');
-  parts.push("  ]");
+  parts.push("  ],");
+  parts.push('  "knowledgeRequests": ["filename1", "filename2"]');
   parts.push("}");
   parts.push("```");
   parts.push("");
@@ -943,6 +1052,16 @@ function buildClarifyPrompt(params) {
   parts.push("");
   parts.push(params.gatheredContext);
   parts.push("");
+  if (params.loadedKnowledge && params.loadedKnowledge.length > 0) {
+    parts.push("## Requested Knowledge");
+    parts.push("");
+    for (const entry of params.loadedKnowledge) {
+      parts.push(`### ${entry.filename}`);
+      parts.push("");
+      parts.push(entry.content);
+      parts.push("");
+    }
+  }
   const hasPreviousDecisions = params.previousDecisions && params.previousDecisions.length > 0;
   if (hasPreviousDecisions) {
     parts.push("## Previous Decisions (All Resolved)");
@@ -1043,16 +1162,16 @@ function buildGeneratePrompt(params) {
   const outputsDir = getOutputsDir(cwd);
   const isFirstStep = params.stepIndex === 1;
   const prevStep = params.stepIndex > 1 ? config.steps[params.stepIndex - 2] : null;
-  const templatePath = join5(stepsDir, params.step, "template.md");
-  const outputPath = join5(outputsDir, params.taskId, `${params.step}.md`);
-  const template = existsSync5(templatePath) ? readFileSync4(templatePath, "utf-8") : null;
+  const templatePath = join6(stepsDir, params.step, "template.md");
+  const outputPath = join6(outputsDir, params.taskId, `${params.step}.md`);
+  const template = existsSync6(templatePath) ? readFileSync5(templatePath, "utf-8") : null;
   let previousSpec = null;
   if (prevStep) {
-    const prevPath = join5(outputsDir, params.taskId, `${prevStep}.md`);
-    if (existsSync5(prevPath)) {
+    const prevPath = join6(outputsDir, params.taskId, `${prevStep}.md`);
+    if (existsSync6(prevPath)) {
       previousSpec = {
         step: prevStep,
-        content: readFileSync4(prevPath, "utf-8")
+        content: readFileSync5(prevPath, "utf-8")
       };
     }
   }
@@ -1130,16 +1249,16 @@ function buildExecutePrompt(params) {
   const outputsDir = getOutputsDir(cwd);
   const isFirstStep = params.stepIndex === 1;
   const prevStep = params.stepIndex > 1 ? config.steps[params.stepIndex - 2] : null;
-  const templatePath = join5(stepsDir, params.step, "template.md");
-  const outputPath = join5(outputsDir, params.taskId, `${params.step}.md`);
-  const template = existsSync5(templatePath) ? readFileSync4(templatePath, "utf-8") : null;
+  const templatePath = join6(stepsDir, params.step, "template.md");
+  const outputPath = join6(outputsDir, params.taskId, `${params.step}.md`);
+  const template = existsSync6(templatePath) ? readFileSync5(templatePath, "utf-8") : null;
   let previousSpec = null;
   if (prevStep) {
-    const prevPath = join5(outputsDir, params.taskId, `${prevStep}.md`);
-    if (existsSync5(prevPath)) {
+    const prevPath = join6(outputsDir, params.taskId, `${prevStep}.md`);
+    if (existsSync6(prevPath)) {
       previousSpec = {
         step: prevStep,
-        content: readFileSync4(prevPath, "utf-8")
+        content: readFileSync5(prevPath, "utf-8")
       };
     }
   }
@@ -1194,6 +1313,16 @@ function buildExecutePrompt(params) {
     }
     parts.push("");
   }
+  if (params.loadedKnowledge && params.loadedKnowledge.length > 0) {
+    parts.push("### Referenced Knowledge");
+    parts.push("");
+    for (const entry of params.loadedKnowledge) {
+      parts.push(`#### ${entry.filename}`);
+      parts.push("");
+      parts.push(entry.content);
+      parts.push("");
+    }
+  }
   if (params.answers && params.answers.length > 0) {
     parts.push("## User Answers");
     parts.push("");
@@ -1255,9 +1384,9 @@ function buildExecutePrompt(params) {
 function buildVerifyPrompt(params) {
   const cwd = params.cwd || process.cwd();
   const stepsDir = getStepsDir(cwd);
-  const templatePath = join5(stepsDir, params.step, "template.md");
-  const template = existsSync5(templatePath) ? readFileSync4(templatePath, "utf-8") : "";
-  const document = existsSync5(params.documentPath) ? readFileSync4(params.documentPath, "utf-8") : "";
+  const templatePath = join6(stepsDir, params.step, "template.md");
+  const template = existsSync6(templatePath) ? readFileSync5(templatePath, "utf-8") : "";
+  const document = existsSync6(params.documentPath) ? readFileSync5(params.documentPath, "utf-8") : "";
   const parts = [];
   parts.push("# Verify Phase - Self-Validation");
   parts.push("");
@@ -1361,33 +1490,33 @@ var Orchestrator = class {
     return getOutputsDir(this.cwd);
   }
   getStatePath(taskId) {
-    return join6(this.getOutputPath(), taskId, ".state.json");
+    return join7(this.getOutputPath(), taskId, ".state.json");
   }
   getSpecPath(taskId, step) {
-    return join6(this.getOutputPath(), taskId, `${step}.md`);
+    return join7(this.getOutputPath(), taskId, `${step}.md`);
   }
   getStepTemplatePath(step) {
-    return join6(getStepsDir(this.cwd), step, "template.md");
+    return join7(getStepsDir(this.cwd), step, "template.md");
   }
   // ===========================================================================
   // State Management
   // ===========================================================================
   loadState(taskId) {
     const statePath = this.getStatePath(taskId);
-    if (!existsSync6(statePath)) {
+    if (!existsSync7(statePath)) {
       return null;
     }
-    const data = JSON.parse(readFileSync5(statePath, "utf-8"));
+    const data = JSON.parse(readFileSync6(statePath, "utf-8"));
     return data;
   }
   saveState(state) {
     state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     const statePath = this.getStatePath(state.taskId);
     const dir = dirname2(statePath);
-    if (!existsSync6(dir)) {
-      mkdirSync4(dir, { recursive: true });
+    if (!existsSync7(dir)) {
+      mkdirSync5(dir, { recursive: true });
     }
-    writeFileSync4(statePath, JSON.stringify(state, null, 2));
+    writeFileSync5(statePath, JSON.stringify(state, null, 2));
   }
   // ===========================================================================
   // Protocol Response Builders
@@ -1401,8 +1530,8 @@ var Orchestrator = class {
     let previousOutput;
     if (state.stepIndex > 1) {
       const prevStep = steps[state.stepIndex - 2];
-      const prevPath = join6(outputPath, state.taskId, `${prevStep}.md`);
-      if (existsSync6(prevPath)) {
+      const prevPath = join7(outputPath, state.taskId, `${prevStep}.md`);
+      if (existsSync7(prevPath)) {
         previousOutput = prevPath;
       }
     }
@@ -1439,6 +1568,7 @@ var Orchestrator = class {
       step: state.currentStep,
       description: state.description,
       gatheredContext: state.exploreOutput ? JSON.stringify(state.exploreOutput) : "",
+      loadedKnowledge: state.loadedKnowledge,
       previousDecisions: state.decisionHistory,
       previousQA: state.qaHistory,
       // Legacy support
@@ -1467,13 +1597,13 @@ var Orchestrator = class {
     let previousOutput;
     if (state.stepIndex > 1) {
       const prevStep = steps[state.stepIndex - 2];
-      const prevPath = join6(outputPath, state.taskId, `${prevStep}.md`);
-      if (existsSync6(prevPath)) {
+      const prevPath = join7(outputPath, state.taskId, `${prevStep}.md`);
+      if (existsSync7(prevPath)) {
         previousOutput = prevPath;
       }
     }
     const templatePath = this.getStepTemplatePath(state.currentStep);
-    const hasTemplate = existsSync6(templatePath);
+    const hasTemplate = existsSync7(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");
@@ -1495,6 +1625,7 @@ ${issues}`;
       stepIndex: state.stepIndex,
       totalSteps: state.totalSteps,
       exploreOutput,
+      loadedKnowledge: state.loadedKnowledge,
       answers: state.answers,
       revisionFeedback: state.revisionFeedback,
       verifyFeedback,
@@ -1514,7 +1645,7 @@ ${issues}`;
       context: {
         template: hasTemplate ? templatePath : void 0,
         previousOutput,
-        output: join6(outputPath, state.taskId, `${state.currentStep}.md`),
+        output: join7(outputPath, state.taskId, `${state.currentStep}.md`),
         revisionFeedback: state.revisionFeedback,
         verifyFeedback
       },
@@ -1527,8 +1658,8 @@ ${issues}`;
   responsePhaseVerify(state) {
     const outputPath = this.getOutputPath();
     const templatePath = this.getStepTemplatePath(state.currentStep);
-    const hasTemplate = existsSync6(templatePath);
-    const documentPath = join6(outputPath, state.taskId, `${state.currentStep}.md`);
+    const hasTemplate = existsSync7(templatePath);
+    const documentPath = join7(outputPath, state.taskId, `${state.currentStep}.md`);
     const prompt = buildVerifyPrompt({
       taskId: state.taskId,
       step: state.currentStep,
@@ -1582,7 +1713,7 @@ ${issues}`;
       step: state.currentStep,
       stepIndex: state.stepIndex,
       totalSteps: state.totalSteps,
-      specPath: join6(outputPath, state.taskId, `${state.currentStep}.md`),
+      specPath: join7(outputPath, state.taskId, `${state.currentStep}.md`),
       options: ["approve", "revise", "reject", "stop"],
       onComplete: {
         approve: `npx spets orchestrate approve ${state.taskId}`,
@@ -1592,13 +1723,49 @@ ${issues}`;
       }
     };
   }
+  /**
+   * Checkpoint: Knowledge extraction after workflow completion
+   */
+  responseCheckpointKnowledge(state) {
+    const guide = loadGuide(this.cwd);
+    const suggestedKnowledge = [];
+    if (state.decisionHistory && state.decisionHistory.length > 0) {
+      for (const entry of state.decisionHistory) {
+        const selectedOption = entry.decision.options.find((o) => o.id === entry.answer.selectedOptionId);
+        if (selectedOption && entry.answer.selectedOptionId !== "ai") {
+          const filename = `decision--${entry.decision.id}-${entry.decision.decision.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 30)}`;
+          const content = `**Decision:** ${entry.decision.decision}
+
+**Selected:** ${selectedOption.label}
+
+**Why:** ${entry.decision.why}
+
+${entry.answer.customInput ? `**User note:** ${entry.answer.customInput}` : ""}`;
+          suggestedKnowledge.push({
+            filename,
+            content,
+            reason: "\uC6CC\uD06C\uD50C\uB85C\uC6B0\uC5D0\uC11C \uC0AC\uC6A9\uC790\uAC00 \uACB0\uC815\uD55C \uC120\uD0DD"
+          });
+        }
+      }
+    }
+    return {
+      type: "checkpoint",
+      checkpoint: "knowledge",
+      taskId: state.taskId,
+      guide,
+      suggestedKnowledge,
+      onComplete: `npx spets orchestrate knowledge-save ${state.taskId} '<entries_json>'`,
+      onSkip: `npx spets orchestrate knowledge-skip ${state.taskId}`
+    };
+  }
   responseComplete(state, status) {
     const steps = this.getSteps();
     const outputPath = this.getOutputPath();
     const outputs = [];
     for (let i = 0; i < state.stepIndex; i++) {
-      const specPath = join6(outputPath, state.taskId, `${steps[i]}.md`);
-      if (existsSync6(specPath)) {
+      const specPath = join7(outputPath, state.taskId, `${steps[i]}.md`);
+      if (existsSync7(specPath)) {
         outputs.push(specPath);
       }
     }
@@ -1656,6 +1823,12 @@ ${issues}`;
       return this.responseError(`No workflow found: ${taskId}`, taskId);
     }
     state.exploreOutput = exploreOutput;
+    if (exploreOutput.knowledgeRequests && exploreOutput.knowledgeRequests.length > 0) {
+      const entries = loadKnowledgeFiles(exploreOutput.knowledgeRequests, this.cwd);
+      if (entries.length > 0) {
+        state.loadedKnowledge = entries;
+      }
+    }
     state.status = "phase_clarify";
     state.phase = "clarify";
     this.saveState(state);
@@ -1717,7 +1890,7 @@ ${issues}`;
       return this.responseError(`No workflow found: ${taskId}`, taskId);
     }
     const specPath = this.getSpecPath(taskId, state.currentStep);
-    if (!existsSync6(specPath)) {
+    if (!existsSync7(specPath)) {
       return this.responseError(`Document not found: ${specPath}`, taskId, state.currentStep);
     }
     state.status = "phase_verify";
@@ -1766,12 +1939,12 @@ ${issues}`;
     }
     const steps = this.getSteps();
     const specPath = this.getSpecPath(taskId, state.currentStep);
-    if (existsSync6(specPath)) {
-      const content = readFileSync5(specPath, "utf-8");
-      const { content: body, data } = matter2(content);
+    if (existsSync7(specPath)) {
+      const content = readFileSync6(specPath, "utf-8");
+      const { content: body, data } = matter3(content);
       data.status = "approved";
       data.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-      writeFileSync4(specPath, matter2.stringify(body, data));
+      writeFileSync5(specPath, matter3.stringify(body, data));
     }
     if (state.stepIndex < state.totalSteps) {
       state.currentStep = steps[state.stepIndex];
@@ -1788,11 +1961,49 @@ ${issues}`;
       this.saveState(state);
       return this.responsePhaseExplore(state);
     } else {
+      const config = loadConfig(this.cwd);
+      if (config.knowledge?.enabled) {
+        state.status = "knowledge_pending";
+        this.saveState(state);
+        return this.responseCheckpointKnowledge(state);
+      }
       state.status = "completed";
       this.saveState(state);
       return this.responseComplete(state, "completed");
     }
   }
+  /**
+   * Save knowledge entries and complete workflow
+   */
+  cmdKnowledgeSave(taskId, entries) {
+    const state = this.loadState(taskId);
+    if (!state) {
+      return this.responseError(`No workflow found: ${taskId}`, taskId);
+    }
+    for (const entry of 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");
+  }
+  /**
+   * Skip knowledge extraction and complete workflow
+   */
+  cmdKnowledgeSkip(taskId) {
+    const state = this.loadState(taskId);
+    if (!state) {
+      return this.responseError(`No workflow found: ${taskId}`, taskId);
+    }
+    state.status = "completed";
+    this.saveState(state);
+    return this.responseComplete(state, "completed");
+  }
   /**
    * Request revision with feedback - goes back to execute phase
    */
@@ -1818,12 +2029,12 @@ ${issues}`;
       return this.responseError(`No workflow found: ${taskId}`, taskId);
     }
     const specPath = this.getSpecPath(taskId, state.currentStep);
-    if (existsSync6(specPath)) {
-      const content = readFileSync5(specPath, "utf-8");
-      const { content: body, data } = matter2(content);
+    if (existsSync7(specPath)) {
+      const content = readFileSync6(specPath, "utf-8");
+      const { content: body, data } = matter3(content);
       data.status = "rejected";
       data.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-      writeFileSync4(specPath, matter2.stringify(body, data));
+      writeFileSync5(specPath, matter3.stringify(body, data));
     }
     state.status = "rejected";
     this.saveState(state);
@@ -1888,6 +2099,8 @@ ${issues}`;
         return this.responsePhaseVerify(state);
       case "approve_pending":
         return this.responseCheckpointApprove(state);
+      case "knowledge_pending":
+        return this.responseCheckpointKnowledge(state);
       case "completed":
       case "stopped":
       case "rejected":
@@ -1899,9 +2112,9 @@ ${issues}`;
 };
 
 // src/core/step-executor.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
-import { join as join7 } from "path";
-import matter3 from "gray-matter";
+import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { join as join8 } from "path";
+import matter4 from "gray-matter";
 var StepExecutor = class {
   adapter;
   config;
@@ -1992,6 +2205,7 @@ var StepExecutor = class {
       step,
       description: context.description,
       gatheredContext: context.gatheredContext,
+      previousDecisions: context.previousDecisions,
       previousQA: context.previousQA,
       cwd: this.cwd
     };
@@ -2048,7 +2262,7 @@ var StepExecutor = class {
     };
     const { prompt, outputPath } = buildGeneratePrompt(params);
     await this.adapter.ai.execute({ prompt, outputPath });
-    if (!existsSync7(outputPath)) {
+    if (!existsSync8(outputPath)) {
       throw new Error(`AI did not create document at ${outputPath}`);
     }
     this.adapter.io.notify(`Document created: ${outputPath}`, "success");
@@ -2087,7 +2301,7 @@ var StepExecutor = class {
     };
     const { prompt, outputPath } = buildExecutePrompt(params);
     await this.adapter.ai.execute({ prompt, outputPath });
-    if (!existsSync7(outputPath)) {
+    if (!existsSync8(outputPath)) {
       throw new Error(`AI did not create document at ${outputPath}`);
     }
     this.adapter.io.notify(`Document created: ${outputPath}`, "success");
@@ -2109,8 +2323,8 @@ var StepExecutor = class {
     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 = join7(outputsDir, context.taskId, `${step}.md`);
-    if (!existsSync7(documentPath)) {
+    const documentPath = join8(outputsDir, context.taskId, `${step}.md`);
+    if (!existsSync8(documentPath)) {
       throw new Error(`Document not found: ${documentPath}`);
     }
     const params = {
@@ -2151,8 +2365,8 @@ var StepExecutor = class {
   async executeReviewPhase(step, context) {
     this.adapter.io.notify(`Phase 4/4: Review for ${step}`, "info");
     const outputsDir = getOutputsDir(this.cwd);
-    const outputPath = join7(outputsDir, context.taskId, `${step}.md`);
-    if (!existsSync7(outputPath)) {
+    const outputPath = join8(outputsDir, context.taskId, `${step}.md`);
+    if (!existsSync8(outputPath)) {
       throw new Error(`Document not found: ${outputPath}`);
     }
     const approval = await this.adapter.io.approve(
@@ -2337,17 +2551,17 @@ var StepExecutor = class {
    * Update document status in frontmatter
    */
   updateDocumentStatus(docPath, status) {
-    const content = readFileSync6(docPath, "utf-8");
-    const { content: body, data } = matter3(content);
+    const content = readFileSync7(docPath, "utf-8");
+    const { content: body, data } = matter4(content);
     data.status = status;
     data.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    writeFileSync5(docPath, matter3.stringify(body, data));
+    writeFileSync6(docPath, matter4.stringify(body, data));
   }
 };
 
 // src/adapters/cli.ts
 import { spawn, spawnSync } from "child_process";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
 import { dirname as dirname3 } from "path";
 import { input, select, confirm } from "@inquirer/prompts";
 var CLIAIAdapter = class {
@@ -2360,13 +2574,13 @@ var CLIAIAdapter = class {
 \u{1F4DD} Generating...`);
     if (params.outputPath) {
       const outputDir = dirname3(params.outputPath);
-      if (!existsSync8(outputDir)) {
-        mkdirSync5(outputDir, { recursive: true });
+      if (!existsSync9(outputDir)) {
+        mkdirSync6(outputDir, { recursive: true });
       }
     }
     const stdout = await this.callClaude(params.prompt);
-    if (params.outputPath && existsSync8(params.outputPath)) {
-      return readFileSync7(params.outputPath, "utf-8");
+    if (params.outputPath && existsSync9(params.outputPath)) {
+      return readFileSync8(params.outputPath, "utf-8");
     }
     return stdout;
   }
@@ -2443,14 +2657,14 @@ var CLIAIAdapter = class {
         try {
           if (p.outputPath) {
             const outputDir = dirname3(p.outputPath);
-            if (!existsSync8(outputDir)) {
-              mkdirSync5(outputDir, { recursive: true });
+            if (!existsSync9(outputDir)) {
+              mkdirSync6(outputDir, { recursive: true });
             }
           }
           await this.callClaude(p.prompt, false);
           let result = "";
-          if (p.outputPath && existsSync8(p.outputPath)) {
-            result = readFileSync7(p.outputPath, "utf-8");
+          if (p.outputPath && existsSync9(p.outputPath)) {
+            result = readFileSync8(p.outputPath, "utf-8");
           }
           completed++;
           results.set(id, { id, success: true, result });
@@ -2540,8 +2754,8 @@ Context: ${question.context}`);
     return answers;
   }
   async approve(specPath, stepName, stepIndex, totalSteps) {
-    if (existsSync8(specPath)) {
-      const doc = readFileSync7(specPath, "utf-8");
+    if (existsSync9(specPath)) {
+      const doc = readFileSync8(specPath, "utf-8");
       console.log("\n" + "=".repeat(60));
       console.log(`\u{1F4C4} ${stepName} Document (Step ${stepIndex}/${totalSteps})`);
       console.log("=".repeat(60));
@@ -2586,17 +2800,17 @@ Context: ${question.context}`);
 };
 var CLISystemAdapter = class {
   readFile(path) {
-    return readFileSync7(path, "utf-8");
+    return readFileSync8(path, "utf-8");
   }
   writeFile(path, content) {
     const dir = dirname3(path);
-    if (!existsSync8(dir)) {
-      mkdirSync5(dir, { recursive: true });
+    if (!existsSync9(dir)) {
+      mkdirSync6(dir, { recursive: true });
     }
-    writeFileSync6(path, content);
+    writeFileSync7(path, content);
   }
   fileExists(path) {
-    return existsSync8(path);
+    return existsSync9(path);
   }
   exec(command) {
     try {
@@ -2627,7 +2841,7 @@ function createCLIAdapter(claudeCommand = "claude") {
 
 // src/adapters/github.ts
 import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync8, existsSync as existsSync10, mkdirSync as mkdirSync7 } from "fs";
 import { dirname as dirname4 } from "path";
 var GitHubAIAdapter = class {
   claudeCommand;
@@ -2639,13 +2853,13 @@ var GitHubAIAdapter = class {
 \u{1F4DD} Generating...`);
     if (params.outputPath) {
       const outputDir = dirname4(params.outputPath);
-      if (!existsSync9(outputDir)) {
-        mkdirSync6(outputDir, { recursive: true });
+      if (!existsSync10(outputDir)) {
+        mkdirSync7(outputDir, { recursive: true });
       }
     }
     const stdout = await this.callClaude(params.prompt);
-    if (params.outputPath && existsSync9(params.outputPath)) {
-      return readFileSync8(params.outputPath, "utf-8");
+    if (params.outputPath && existsSync10(params.outputPath)) {
+      return readFileSync9(params.outputPath, "utf-8");
     }
     return stdout;
   }
@@ -2697,14 +2911,14 @@ var GitHubAIAdapter = class {
         try {
           if (p.outputPath) {
             const outputDir = dirname4(p.outputPath);
-            if (!existsSync9(outputDir)) {
-              mkdirSync6(outputDir, { recursive: true });
+            if (!existsSync10(outputDir)) {
+              mkdirSync7(outputDir, { recursive: true });
             }
           }
           await this.callClaude(p.prompt);
           let result = "";
-          if (p.outputPath && existsSync9(p.outputPath)) {
-            result = readFileSync8(p.outputPath, "utf-8");
+          if (p.outputPath && existsSync10(p.outputPath)) {
+            result = readFileSync9(p.outputPath, "utf-8");
           }
           completed++;
           console.log(`\u2713 [${completed}/${total}] ${id}`);
@@ -2757,7 +2971,7 @@ var GitHubIOAdapter = class {
     return [];
   }
   async approve(specPath, stepName, stepIndex, totalSteps) {
-    const doc = existsSync9(specPath) ? readFileSync8(specPath, "utf-8") : "";
+    const doc = existsSync10(specPath) ? readFileSync9(specPath, "utf-8") : "";
     const comment = this.formatApprovalComment(doc, stepName, stepIndex, totalSteps, specPath);
     await this.postComment(comment);
     console.log("\n\u23F8\uFE0F  Approval request posted to GitHub.");
@@ -2843,11 +3057,13 @@ var GitHubIOAdapter = class {
       lines.push(`> ${d.why}`);
       lines.push("");
       lines.push("**Options:**");
+      let optionNumber = 1;
       for (const opt of d.options) {
         if (opt.id === "ai") {
-          lines.push(`- \`${opt.id}\`: ${opt.label} \u2192 recommends \`${opt.recommendation}\` (${opt.reason})`);
+          lines.push(`- **Recommended**: ${opt.label} \u2192 recommends \`${opt.recommendation}\` (${opt.reason})`);
         } else {
-          lines.push(`- \`${opt.id}\`: ${opt.label}${opt.tradeoffs ? ` - ${opt.tradeoffs}` : ""}`);
+          lines.push(`- **Option ${optionNumber}**: ${opt.label}${opt.tradeoffs ? ` - ${opt.tradeoffs}` : ""}`);
+          optionNumber++;
         }
       }
       lines.push("");
@@ -2928,17 +3144,17 @@ var GitHubIOAdapter = class {
 };
 var GitHubSystemAdapter = class {
   readFile(path) {
-    return readFileSync8(path, "utf-8");
+    return readFileSync9(path, "utf-8");
   }
   writeFile(path, content) {
     const dir = dirname4(path);
-    if (!existsSync9(dir)) {
-      mkdirSync6(dir, { recursive: true });
+    if (!existsSync10(dir)) {
+      mkdirSync7(dir, { recursive: true });
     }
-    writeFileSync7(path, content);
+    writeFileSync8(path, content);
   }
   fileExists(path) {
-    return existsSync9(path);
+    return existsSync10(path);
   }
   exec(command) {
     try {
@@ -2969,8 +3185,193 @@ function createGitHubAdapter(config, claudeCommand = "claude") {
 
 // src/adapters/codex.ts
 import { spawn as spawn3 } from "child_process";
-import { readFileSync as readFileSync9, existsSync as existsSync10, mkdirSync as mkdirSync7 } from "fs";
+import { readFileSync as readFileSync10, existsSync as existsSync11, mkdirSync as mkdirSync8 } from "fs";
 import { dirname as dirname5 } from "path";
+
+// src/dashboard/client.ts
+var DashboardClient = class {
+  cwd;
+  config = null;
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  /**
+   * Check if spets is initialized in the working directory
+   */
+  isInitialized() {
+    return spetsExists(this.cwd);
+  }
+  /**
+   * Get config, loading if necessary
+   */
+  getConfig() {
+    if (!this.config) {
+      this.config = loadConfig(this.cwd);
+    }
+    return this.config;
+  }
+  /**
+   * List all tasks with summary data
+   */
+  listTasks(options = {}) {
+    const limit = options.limit ?? 20;
+    const allTaskIds = listTasks(this.cwd);
+    const config = this.getConfig();
+    const tasks = [];
+    const taskIds = allTaskIds.slice(0, limit);
+    for (const taskId of taskIds) {
+      const summary = this.getTaskSummary(taskId, config);
+      if (summary) {
+        tasks.push(summary);
+      }
+    }
+    const metadata = {
+      totalTasks: allTaskIds.length,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      truncated: allTaskIds.length > limit,
+      limit
+    };
+    return { tasks, metadata };
+  }
+  /**
+   * Get detailed data for a single task
+   */
+  getTaskDetail(taskId) {
+    const config = this.getConfig();
+    const state = getWorkflowState(taskId, config, this.cwd);
+    const meta = loadTaskMetadata(taskId, this.cwd);
+    if (!state) {
+      return null;
+    }
+    const query = meta?.userQuery || state.userQuery || "(no query)";
+    const status = this.mapWorkflowStatus(state.status);
+    const progress = this.buildProgress(state, config);
+    const steps = config.steps.map((stepName, index) => {
+      const output = state.outputs.get(stepName);
+      const isCurrent = index === state.currentStepIndex;
+      let stepStatus = "pending";
+      if (output) {
+        stepStatus = output.status;
+      }
+      return {
+        name: stepName,
+        index: index + 1,
+        status: stepStatus,
+        isCurrent,
+        outputPath: output ? getOutputPath(taskId, stepName, this.cwd) : void 0
+      };
+    });
+    const task = {
+      taskId,
+      query,
+      status,
+      progress,
+      createdAt: meta?.createdAt || "",
+      steps
+    };
+    return {
+      task,
+      metadata: {
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  /**
+   * Build summary for a single task
+   */
+  getTaskSummary(taskId, config) {
+    const state = getWorkflowState(taskId, config, this.cwd);
+    const meta = loadTaskMetadata(taskId, this.cwd);
+    if (!state) {
+      return null;
+    }
+    const query = meta?.userQuery || state.userQuery || "(no query)";
+    const status = this.mapWorkflowStatus(state.status);
+    const progress = this.buildProgress(state, config);
+    return {
+      taskId,
+      query,
+      status,
+      progress,
+      createdAt: meta?.createdAt || ""
+    };
+  }
+  /**
+   * Build progress object from workflow state
+   */
+  buildProgress(state, config) {
+    const totalSteps = config.steps.length;
+    const currentStepIndex = state.currentStepIndex + 1;
+    const completionPercent = Math.round(state.currentStepIndex / totalSteps * 100);
+    return {
+      currentStep: state.currentStepName,
+      currentStepIndex,
+      totalSteps,
+      completionPercent
+    };
+  }
+  /**
+   * Map internal workflow status to dashboard status
+   */
+  mapWorkflowStatus(status) {
+    switch (status) {
+      case "completed":
+        return "completed";
+      case "rejected":
+        return "rejected";
+      case "paused":
+        return "paused";
+      default:
+        return "in_progress";
+    }
+  }
+  /**
+   * Export dashboard data as JSON string
+   */
+  toJSON(options = {}) {
+    const response = this.listTasks(options);
+    return JSON.stringify(response, null, 2);
+  }
+  /**
+   * Export task detail as JSON string
+   */
+  taskToJSON(taskId) {
+    const response = this.getTaskDetail(taskId);
+    if (!response) return null;
+    return JSON.stringify(response, null, 2);
+  }
+};
+
+// src/dashboard/renderers/json.ts
+var JSONDashboardRenderer = class {
+  prettyPrint;
+  constructor(options = {}) {
+    this.prettyPrint = options.prettyPrint ?? true;
+  }
+  /**
+   * Render dashboard response as JSON string
+   */
+  render(response) {
+    return this.stringify(response);
+  }
+  /**
+   * Render task detail as JSON string
+   */
+  renderDetail(response) {
+    return this.stringify(response);
+  }
+  /**
+   * Render any data as JSON string
+   */
+  stringify(data) {
+    if (this.prettyPrint) {
+      return JSON.stringify(data, null, 2);
+    }
+    return JSON.stringify(data);
+  }
+};
+
+// src/adapters/codex.ts
 var CodexAIAdapter = class {
   codexCommand;
   constructor(codexCommand = "codex") {
@@ -2981,13 +3382,13 @@ var CodexAIAdapter = class {
 \u{1F4DD} Generating...`);
     if (params.outputPath) {
       const outputDir = dirname5(params.outputPath);
-      if (!existsSync10(outputDir)) {
-        mkdirSync7(outputDir, { recursive: true });
+      if (!existsSync11(outputDir)) {
+        mkdirSync8(outputDir, { recursive: true });
       }
     }
     const stdout = await this.callCodex(params.prompt);
-    if (params.outputPath && existsSync10(params.outputPath)) {
-      return readFileSync9(params.outputPath, "utf-8");
+    if (params.outputPath && existsSync11(params.outputPath)) {
+      return readFileSync10(params.outputPath, "utf-8");
     }
     return stdout;
   }
@@ -3064,14 +3465,14 @@ var CodexAIAdapter = class {
         try {
           if (p.outputPath) {
             const outputDir = dirname5(p.outputPath);
-            if (!existsSync10(outputDir)) {
-              mkdirSync7(outputDir, { recursive: true });
+            if (!existsSync11(outputDir)) {
+              mkdirSync8(outputDir, { recursive: true });
             }
           }
           await this.callCodex(p.prompt, false);
           let result = "";
-          if (p.outputPath && existsSync10(p.outputPath)) {
-            result = readFileSync9(p.outputPath, "utf-8");
+          if (p.outputPath && existsSync11(p.outputPath)) {
+            result = readFileSync10(p.outputPath, "utf-8");
           }
           completed++;
           results.set(id, { id, success: true, result });
@@ -3099,7 +3500,7 @@ function createCodexAdapter(codexCommand = "codex") {
 
 // src/adapters/opencode.ts
 import { spawn as spawn4 } from "child_process";
-import { readFileSync as readFileSync10, existsSync as existsSync11, mkdirSync as mkdirSync8 } from "fs";
+import { readFileSync as readFileSync11, existsSync as existsSync12, mkdirSync as mkdirSync9 } from "fs";
 import { dirname as dirname6 } from "path";
 var OpenCodeAIAdapter = class {
   opencodeCommand;
@@ -3111,13 +3512,13 @@ var OpenCodeAIAdapter = class {
 \u{1F4DD} Generating...`);
     if (params.outputPath) {
       const outputDir = dirname6(params.outputPath);
-      if (!existsSync11(outputDir)) {
-        mkdirSync8(outputDir, { recursive: true });
+      if (!existsSync12(outputDir)) {
+        mkdirSync9(outputDir, { recursive: true });
       }
     }
     const stdout = await this.callOpenCode(params.prompt);
-    if (params.outputPath && existsSync11(params.outputPath)) {
-      return readFileSync10(params.outputPath, "utf-8");
+    if (params.outputPath && existsSync12(params.outputPath)) {
+      return readFileSync11(params.outputPath, "utf-8");
     }
     return stdout;
   }
@@ -3193,14 +3594,14 @@ var OpenCodeAIAdapter = class {
         try {
           if (p.outputPath) {
             const outputDir = dirname6(p.outputPath);
-            if (!existsSync11(outputDir)) {
-              mkdirSync8(outputDir, { recursive: true });
+            if (!existsSync12(outputDir)) {
+              mkdirSync9(outputDir, { recursive: true });
             }
           }
           await this.callOpenCode(p.prompt, false);
           let result = "";
-          if (p.outputPath && existsSync11(p.outputPath)) {
-            result = readFileSync10(p.outputPath, "utf-8");
+          if (p.outputPath && existsSync12(p.outputPath)) {
+            result = readFileSync11(p.outputPath, "utf-8");
           }
           completed++;
           results.set(id, { id, success: true, result });
@@ -3226,6 +3627,135 @@ function createOpenCodeAdapter(opencodeCommand = "opencode") {
   };
 }
 
+// src/adapters/gemini.ts
+import { spawn as spawn5 } from "child_process";
+import { readFileSync as readFileSync12, existsSync as existsSync13, mkdirSync as mkdirSync10 } from "fs";
+import { dirname as dirname7 } from "path";
+var GeminiAIAdapter = class {
+  geminiCommand;
+  constructor(geminiCommand = "gemini") {
+    this.geminiCommand = geminiCommand;
+  }
+  async execute(params) {
+    console.log(`
+\u{1F4DD} Generating...`);
+    if (params.outputPath) {
+      const outputDir = dirname7(params.outputPath);
+      if (!existsSync13(outputDir)) {
+        mkdirSync10(outputDir, { recursive: true });
+      }
+    }
+    const stdout = await this.callGemini(params.prompt);
+    if (params.outputPath && existsSync13(params.outputPath)) {
+      return readFileSync12(params.outputPath, "utf-8");
+    }
+    return stdout;
+  }
+  async callGemini(prompt, showSpinner = true) {
+    return new Promise((resolve, reject) => {
+      const proc = spawn5(this.geminiCommand, [
+        "--prompt",
+        prompt,
+        "--yolo"
+      ], {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      let spinner;
+      if (showSpinner) {
+        const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+        let frameIndex = 0;
+        spinner = setInterval(() => {
+          process.stdout.write(`\r${frames[frameIndex++ % frames.length]} Gemini is working...`);
+        }, 100);
+      }
+      const stopSpinner = (success) => {
+        if (spinner) {
+          clearInterval(spinner);
+          process.stdout.write(`\r${success ? "\u2713" : "\u2717"} Gemini ${success ? "done" : "failed"}        
+`);
+        }
+      };
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        stopSpinner(code === 0);
+        if (code !== 0) {
+          reject(new Error(`Gemini CLI exited with code ${code}: ${stderr}`));
+        } else {
+          resolve(stdout);
+        }
+      });
+      proc.on("error", (err) => {
+        stopSpinner(false);
+        reject(new Error(`Failed to run Gemini CLI: ${err.message}`));
+      });
+    });
+  }
+  /**
+   * Execute multiple prompts in parallel with shared progress display
+   */
+  async executeParallel(params) {
+    const total = params.length;
+    let completed = 0;
+    const results = /* @__PURE__ */ new Map();
+    const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+    let frameIndex = 0;
+    const spinner = setInterval(() => {
+      const progress = `${completed}/${total}`;
+      process.stdout.write(`\r${frames[frameIndex++ % frames.length]} Generating sections in parallel... [${progress}]`);
+    }, 100);
+    const stopSpinner = (success) => {
+      clearInterval(spinner);
+      const status = success ? "\u2713" : "\u2717";
+      const message = success ? `All ${total} sections generated` : `Generation completed with errors`;
+      process.stdout.write(`\r${status} ${message}        
+`);
+    };
+    await Promise.all(
+      params.map(async (p) => {
+        const id = p.id || p.outputPath;
+        try {
+          if (p.outputPath) {
+            const outputDir = dirname7(p.outputPath);
+            if (!existsSync13(outputDir)) {
+              mkdirSync10(outputDir, { recursive: true });
+            }
+          }
+          await this.callGemini(p.prompt, false);
+          let result = "";
+          if (p.outputPath && existsSync13(p.outputPath)) {
+            result = readFileSync12(p.outputPath, "utf-8");
+          }
+          completed++;
+          results.set(id, { id, success: true, result });
+        } catch (error) {
+          completed++;
+          results.set(id, {
+            id,
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      })
+    );
+    stopSpinner(Array.from(results.values()).every((r) => r.success));
+    return params.map((p) => results.get(p.id || p.outputPath));
+  }
+};
+function createGeminiAdapter(geminiCommand = "gemini") {
+  return {
+    ai: new GeminiAIAdapter(geminiCommand),
+    io: new CLIIOAdapter(),
+    system: new CLISystemAdapter()
+  };
+}
+
 // src/commands/start.ts
 function getGitHubInfo(cwd) {
   const config = getGitHubConfig(cwd);
@@ -3300,6 +3830,9 @@ async function startCommand(query, options) {
     } else if (agentType === "opencode") {
       adapter = createOpenCodeAdapter();
       console.log("Platform: cli (opencode)");
+    } else if (agentType === "gemini") {
+      adapter = createGeminiAdapter();
+      console.log("Platform: cli (gemini)");
     } else {
       adapter = createCLIAdapter();
       console.log("Platform: cli (claude)");
@@ -3345,7 +3878,8 @@ async function startCommand(query, options) {
             description: clarifyResp.description,
             stepIndex: 0,
             totalSteps: 0,
-            gatheredContext: clarifyResp.gatheredContext
+            gatheredContext: clarifyResp.gatheredContext,
+            previousDecisions: clarifyResp.previousDecisions
           };
           const result = await stepExecutor.executeClarifyPhase(clarifyResp.step, stepContext);
           const clarifyOutput = result.clarifyOutput || { ready: true, decisions: [] };
@@ -3455,15 +3989,15 @@ Resume with: spets resume --task ${taskId}`);
 
 // src/commands/resume.ts
 import { select as select2 } from "@inquirer/prompts";
-import { existsSync as existsSync12, readdirSync as readdirSync3, readFileSync as readFileSync11 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync4, readFileSync as readFileSync13 } from "fs";
+import { join as join9 } from "path";
 import { spawnSync as spawnSync3 } from "child_process";
 async function createPR(cwd, taskId, outputs) {
   const outputContents = [];
   for (const outputPath of outputs) {
-    const fullPath = join8(cwd, outputPath);
-    if (existsSync12(fullPath)) {
-      const content = readFileSync11(fullPath, "utf-8");
+    const fullPath = join9(cwd, outputPath);
+    if (existsSync14(fullPath)) {
+      const content = readFileSync13(fullPath, "utf-8");
       outputContents.push(`## ${outputPath}
 
 ${content}`);
@@ -3485,15 +4019,15 @@ ${outputContents.join("\n\n---\n\n")}`;
 }
 function listResumableTasks(cwd) {
   const outputsDir = getOutputsDir(cwd);
-  if (!existsSync12(outputsDir)) {
+  if (!existsSync14(outputsDir)) {
     return [];
   }
   const tasks = [];
-  const taskDirs = readdirSync3(outputsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  const taskDirs = readdirSync4(outputsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   const orchestrator = new Orchestrator(cwd);
   for (const taskId of taskDirs) {
-    const stateFile = join8(outputsDir, taskId, ".state.json");
-    if (!existsSync12(stateFile)) continue;
+    const stateFile = join9(outputsDir, taskId, ".state.json");
+    if (!existsSync14(stateFile)) continue;
     try {
       const response = orchestrator.cmdStatus(taskId);
       if (response.type === "error") continue;
@@ -3549,7 +4083,16 @@ async function resumeCommand(options) {
     }
   }
   const agentType = options.agent || config.agent || "claude";
-  const adapter = agentType === "codex" ? createCodexAdapter() : createCLIAdapter();
+  let adapter;
+  if (agentType === "codex") {
+    adapter = createCodexAdapter();
+  } else if (agentType === "opencode") {
+    adapter = createOpenCodeAdapter();
+  } else if (agentType === "gemini") {
+    adapter = createGeminiAdapter();
+  } else {
+    adapter = createCLIAdapter();
+  }
   const orchestrator = new Orchestrator(cwd);
   const stepExecutor = new StepExecutor(adapter, config, cwd);
   let response = orchestrator.cmdStatus(taskId);
@@ -3607,7 +4150,8 @@ async function resumeCommand(options) {
             description: clarifyResp.description,
             stepIndex: 0,
             totalSteps: 0,
-            gatheredContext: clarifyResp.gatheredContext
+            gatheredContext: clarifyResp.gatheredContext,
+            previousDecisions: clarifyResp.previousDecisions
           };
           const result = await stepExecutor.executeClarifyPhase(clarifyResp.step, stepContext);
           const clarifyOutput = result.clarifyOutput || { ready: true, decisions: [] };
@@ -3717,17 +4261,17 @@ Resume with: spets resume --task ${taskId}`);
 }
 
 // src/commands/github.ts
-import { execSync as execSync4, spawn as spawn6, spawnSync as spawnSync4 } from "child_process";
-import { readdirSync as readdirSync4, readFileSync as readFileSync12, existsSync as existsSync14 } from "fs";
-import { join as join10 } from "path";
+import { execSync as execSync4, spawn as spawn7, spawnSync as spawnSync4 } from "child_process";
+import { readdirSync as readdirSync5, readFileSync as readFileSync14, existsSync as existsSync16 } from "fs";
+import { join as join11 } from "path";
 
 // src/hooks/runner.ts
-import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync13 } from "fs";
-import { join as join9, isAbsolute } from "path";
+import { spawn as spawn6 } from "child_process";
+import { existsSync as existsSync15 } from "fs";
+import { join as join10, isAbsolute } from "path";
 async function runHook(hookPath, context, cwd = process.cwd()) {
-  const resolvedPath = isAbsolute(hookPath) ? hookPath : join9(getSpetsDir(cwd), hookPath);
-  if (!existsSync13(resolvedPath)) {
+  const resolvedPath = isAbsolute(hookPath) ? hookPath : join10(getSpetsDir(cwd), hookPath);
+  if (!existsSync15(resolvedPath)) {
     console.warn(`Hook not found: ${resolvedPath}`);
     return;
   }
@@ -3741,7 +4285,7 @@ async function runHook(hookPath, context, cwd = process.cwd()) {
     SPETS_CWD: cwd
   };
   return new Promise((resolve, reject) => {
-    const proc = spawn5(resolvedPath, [], {
+    const proc = spawn6(resolvedPath, [], {
       cwd,
       env,
       stdio: "inherit",
@@ -3851,8 +4395,8 @@ function findTaskId(cwd, owner, repo, issueOrPr) {
     }
   }
   const outputsDir = getOutputsDir(cwd);
-  if (existsSync14(outputsDir)) {
-    const taskDirs = readdirSync4(outputsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
+  if (existsSync16(outputsDir)) {
+    const taskDirs = readdirSync5(outputsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
     if (taskDirs.length > 0) {
       return taskDirs[0];
     }
@@ -3991,7 +4535,8 @@ async function githubCommand(options) {
           description: clarifyResp.description,
           stepIndex: 0,
           totalSteps: 0,
-          gatheredContext: clarifyResp.gatheredContext
+          gatheredContext: clarifyResp.gatheredContext,
+          previousDecisions: clarifyResp.previousDecisions
         };
         const result = await stepExecutor.executeClarifyPhase(clarifyResp.step, stepContext);
         const clarifyOutput = result.clarifyOutput || { ready: true, decisions: [] };
@@ -4113,7 +4658,7 @@ async function postComment(config, body) {
   const { owner, repo, prNumber, issueNumber } = config;
   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 = spawn6("gh", args, { stdio: "inherit" });
+    const proc = spawn7("gh", args, { stdio: "inherit" });
     proc.on("close", (code) => {
       if (code !== 0) reject(new Error(`gh failed with code ${code}`));
       else resolve();
@@ -4123,12 +4668,12 @@ async function postComment(config, body) {
 }
 async function createPullRequestWithAI(config, taskId, userQuery, cwd) {
   const { owner, repo, issueNumber } = config;
-  const outputsDir = join10(getOutputsDir(cwd), taskId);
+  const outputsDir = join11(getOutputsDir(cwd), taskId);
   const outputs = [];
-  if (existsSync14(outputsDir)) {
-    const files = readdirSync4(outputsDir).filter((f) => f.endsWith(".md"));
+  if (existsSync16(outputsDir)) {
+    const files = readdirSync5(outputsDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync12(join10(outputsDir, file), "utf-8");
+      const content = readFileSync14(join11(outputsDir, file), "utf-8");
       outputs.push({ step: file.replace(".md", ""), content });
     }
   }
@@ -4214,7 +4759,7 @@ Closes #${issueNumber}`;
 }
 async function callClaude(prompt) {
   return new Promise((resolve, reject) => {
-    const proc = spawn6("claude", ["--print"], { stdio: ["pipe", "pipe", "pipe"] });
+    const proc = spawn7("claude", ["--print"], { stdio: ["pipe", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     proc.stdout.on("data", (data) => {
@@ -4500,17 +5045,229 @@ async function orchestrateCommand(action, args) {
         outputJSON(result);
         break;
       }
+      case "knowledge-save": {
+        const taskId = args[0];
+        const entriesJson = args[1];
+        if (!taskId) {
+          outputError("Task ID is required for knowledge-save");
+          return;
+        }
+        let entries = [];
+        if (entriesJson) {
+          const parsed = parseFlexibleJSON(entriesJson, {
+            expectArray: true,
+            arrayKeys: ["entries", "knowledge"]
+          });
+          if (parsed.success) {
+            entries = parsed.data;
+          }
+        }
+        const result = orchestrator.cmdKnowledgeSave(taskId, entries);
+        outputJSON(result);
+        break;
+      }
+      case "knowledge-skip": {
+        const taskId = args[0];
+        if (!taskId) {
+          outputError("Task ID is required for knowledge-skip");
+          return;
+        }
+        const result = orchestrator.cmdKnowledgeSkip(taskId);
+        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`);
+        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`);
     }
   } catch (e) {
     outputError(e.message);
   }
 }
 
+// src/dashboard/renderers/cli.ts
+import { select as select3 } from "@inquirer/prompts";
+var STATUS_ICONS = {
+  in_progress: "\u{1F504}",
+  completed: "\u2705",
+  paused: "\u23F8\uFE0F",
+  rejected: "\u274C"
+};
+var STEP_ICONS = {
+  pending: "\u25CB",
+  draft: "\u25D0",
+  approved: "\u25CF",
+  rejected: "\u2717"
+};
+var CLIDashboardRenderer = class {
+  /**
+   * Render task list in terminal format
+   */
+  renderList(response) {
+    const { tasks, metadata } = response;
+    const lines = [];
+    if (tasks.length === 0) {
+      lines.push("No tasks found.");
+      lines.push("");
+      lines.push('Start a new task with: spets start "your task description"');
+      return lines.join("\n");
+    }
+    lines.push("Tasks:");
+    lines.push("");
+    for (const task of tasks) {
+      const icon = STATUS_ICONS[task.status] || "\u2753";
+      const progress = `[${task.progress.currentStepIndex}/${task.progress.totalSteps}]`;
+      const truncatedQuery = task.query.length > 50 ? task.query.substring(0, 47) + "..." : task.query;
+      lines.push(`  ${task.taskId}  ${icon} ${task.status}  ${progress}`);
+      lines.push(`    ${truncatedQuery}`);
+      lines.push("");
+    }
+    if (metadata.truncated) {
+      lines.push(`  ... and ${metadata.totalTasks - metadata.limit} more tasks`);
+      lines.push("");
+    }
+    lines.push('Use "spets dashboard -t <taskId>" for details');
+    return lines.join("\n");
+  }
+  /**
+   * Render task detail in terminal format
+   */
+  renderDetail(response) {
+    const { task } = response;
+    const lines = [];
+    const icon = STATUS_ICONS[task.status] || "\u2753";
+    lines.push(`Task: ${task.taskId}`);
+    lines.push(`Query: ${task.query}`);
+    lines.push(`Status: ${icon} ${task.status}`);
+    lines.push(`Progress: ${task.progress.currentStepIndex}/${task.progress.totalSteps} (${task.progress.completionPercent}%)`);
+    lines.push("");
+    lines.push("Steps:");
+    for (const step of task.steps) {
+      const marker = step.isCurrent ? "\u2192" : " ";
+      const stepIcon = STEP_ICONS[step.status] || "\u25CB";
+      lines.push(`  ${marker} ${step.index}. ${step.name} ${stepIcon}`);
+    }
+    if (task.decisionHistory && task.decisionHistory.length > 0) {
+      lines.push("");
+      lines.push("Decision History:");
+      for (const entry of task.decisionHistory) {
+        lines.push(`  \u2022 ${entry.decision.decision}: ${entry.answer.selectedOptionId}`);
+      }
+    }
+    if (task.verifyOutput) {
+      lines.push("");
+      lines.push("Verification Scores:");
+      const scores = task.verifyOutput.score;
+      lines.push(`  Requirements: ${scores.requirementsCoverage}%`);
+      lines.push(`  Template: ${scores.templateCompliance}%`);
+      lines.push(`  Consistency: ${scores.consistency}%`);
+      lines.push(`  Completeness: ${scores.completeness}%`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Run interactive dashboard with drill-down navigation
+   */
+  async renderInteractive(client) {
+    while (true) {
+      const response = client.listTasks({ limit: 10 });
+      const { tasks } = response;
+      if (tasks.length === 0) {
+        console.log("\nNo tasks found.");
+        console.log('Start a new task with: spets start "your task description"');
+        break;
+      }
+      const choices = tasks.map((task) => {
+        const icon = STATUS_ICONS[task.status] || "\u2753";
+        const progress = `[${task.progress.currentStepIndex}/${task.progress.totalSteps}]`;
+        const truncatedQuery = task.query.length > 40 ? task.query.substring(0, 37) + "..." : task.query;
+        return {
+          value: task.taskId,
+          name: `${icon} ${task.taskId} ${progress} - ${truncatedQuery}`
+        };
+      });
+      choices.push({ value: "_exit_", name: "\u2190 Exit dashboard" });
+      const selected = await select3({
+        message: "Select a task to view details:",
+        choices
+      });
+      if (selected === "_exit_") {
+        break;
+      }
+      const detail = client.getTaskDetail(selected);
+      if (detail) {
+        console.log("\n" + "=".repeat(60));
+        console.log(this.renderDetail(detail));
+        console.log("=".repeat(60));
+        const action = await select3({
+          message: "What would you like to do?",
+          choices: [
+            { value: "back", name: "\u2190 Back to task list" },
+            { value: "resume", name: "\u25B6 Resume this task" },
+            { value: "exit", name: "\u2715 Exit dashboard" }
+          ]
+        });
+        if (action === "exit") {
+          break;
+        }
+        if (action === "resume") {
+          console.log(`
+To resume this task, run:`);
+          console.log(`  spets resume -t ${selected}`);
+          break;
+        }
+      }
+    }
+  }
+};
+
+// src/commands/dashboard.ts
+async function dashboardCommand(options) {
+  const cwd = process.cwd();
+  if (!spetsExists(cwd)) {
+    console.error('Spets not initialized. Run "spets init" first.');
+    process.exit(1);
+  }
+  const client = new DashboardClient(cwd);
+  const limit = options.limit ?? 20;
+  if (options.json) {
+    if (options.task) {
+      const detail = client.getTaskDetail(options.task);
+      if (!detail) {
+        console.error(JSON.stringify({ error: `Task '${options.task}' not found.` }));
+        process.exit(1);
+      }
+      const renderer2 = new JSONDashboardRenderer();
+      console.log(renderer2.renderDetail(detail));
+    } else {
+      const response = client.listTasks({ limit });
+      const renderer2 = new JSONDashboardRenderer();
+      console.log(renderer2.render(response));
+    }
+    return;
+  }
+  if (options.task) {
+    const detail = client.getTaskDetail(options.task);
+    if (!detail) {
+      console.error(`Task '${options.task}' not found.`);
+      process.exit(1);
+    }
+    const renderer2 = new CLIDashboardRenderer();
+    console.log(renderer2.renderDetail(detail));
+    return;
+  }
+  if (!process.stdout.isTTY) {
+    const response = client.listTasks({ limit });
+    const renderer2 = new JSONDashboardRenderer();
+    console.log(renderer2.render(response));
+    return;
+  }
+  const renderer = new CLIDashboardRenderer();
+  await renderer.renderInteractive(client);
+}
+
 // src/index.ts
-var __dirname2 = dirname7(fileURLToPath2(import.meta.url));
-var pkg = JSON.parse(readFileSync13(join11(__dirname2, "..", "package.json"), "utf-8"));
+var __dirname2 = dirname8(fileURLToPath2(import.meta.url));
+var pkg = JSON.parse(readFileSync15(join12(__dirname2, "..", "package.json"), "utf-8"));
 var program = new Command();
 program.name("spets").description("Spec Driven Development Execution Framework").version(pkg.version);
 program.command("init").description("Initialize spets in current directory").option("-f, --force", "Overwrite existing config").option("--github", "Add GitHub Actions workflow for PR/Issue integration").action(initCommand);
@@ -4519,5 +5276,6 @@ program.command("start").description("Start a new workflow").argument("<query>",
 program.command("resume").description("Resume paused workflow").option("-t, --task <taskId>", "Resume specific task").option("--approve", "Approve current document and proceed").option("--revise <feedback>", "Request revision with feedback").option("--pr", "Create PR on workflow completion (use with --approve)").option("--agent <agent>", "AI agent to use (claude or codex)").action(resumeCommand);
 program.command("github").description("Handle GitHub Action callback (internal)").option("--pr <number>", "PR number").option("--issue <number>", "Issue number").option("-t, --task <taskId>", "Task ID").requiredOption("--comment <comment>", "Comment body").action(githubCommand);
 program.command("plugin").description("Manage plugins").argument("<action>", "Action: install, uninstall, list").argument("[name]", "Plugin name").action(pluginCommand);
+program.command("dashboard").description("Interactive task dashboard with drill-down").option("-t, --task <taskId>", "Show details for specific task").option("--json", "Output as JSON (for external consumers)").option("-l, --limit <number>", "Limit number of tasks shown", "20").action(dashboardCommand);
 program.command("orchestrate").description("Workflow orchestration (JSON API for Claude Code)").argument("<action>", "Action: init, done, clarified, approve, revise, reject, stop, status").argument("[args...]", "Action arguments").action(orchestrateCommand);
 program.parse();