krenk 0.1.4 → 0.1.6

package/dist/index.js

@@ -18,8 +18,8 @@ var ContextManager = class {
   krenkDir;
   historyDir;
   runId;
-  constructor(projectDir) {
-    this.runId = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  constructor(projectDir, existingRunId) {
+    this.runId = existingRunId || (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     this.krenkDir = path.join(projectDir, ".krenk");
     this.historyDir = path.join(this.krenkDir, "history", this.runId);
     fs.mkdirSync(this.krenkDir, { recursive: true });
@@ -104,6 +104,52 @@ ${content}
   getRunId() {
     return this.runId;
   }
+  /** Load all <role>.md files from a history dir into memory */
+  async loadFromHistory(runId) {
+    const histDir = path.join(this.krenkDir, "history", runId);
+    try {
+      const files = await fs.promises.readdir(histDir);
+      for (const file of files) {
+        if (file.endsWith(".md")) {
+          const role = file.replace(/\.md$/, "");
+          const content = await fs.promises.readFile(
+            path.join(histDir, file),
+            "utf-8"
+          );
+          this.memory.set(role, content);
+        }
+      }
+    } catch {
+    }
+  }
+  /** Save state.json to both .krenk/ and .krenk/history/<runId>/ */
+  async saveStateToHistory(state) {
+    const json = JSON.stringify(state, null, 2);
+    await Promise.all([
+      fs.promises.writeFile(
+        path.join(this.krenkDir, "state.json"),
+        json,
+        "utf-8"
+      ),
+      fs.promises.writeFile(
+        path.join(this.historyDir, "state.json"),
+        json,
+        "utf-8"
+      )
+    ]);
+  }
+  /** Read state.json from a specific history dir */
+  static async loadRunState(projectDir, runId) {
+    try {
+      const data = await fs.promises.readFile(
+        path.join(projectDir, ".krenk", "history", runId, "state.json"),
+        "utf-8"
+      );
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
 };
 
 // src/agents/spawner.ts
@@ -902,9 +948,9 @@ import { EventEmitter as EventEmitter2 } from "events";
 import { execSync } from "child_process";
 var DEFAULT_LIMITS = {
   maxMemoryMB: 512,
-  maxTimeSeconds: 600,
-  hungWarningSeconds: 120,
-  hungKillSeconds: 300,
+  maxTimeSeconds: 900,
+  hungWarningSeconds: 180,
+  hungKillSeconds: 480,
   pollIntervalMs: 5e3
 };
 var ProcessSupervisor = class extends EventEmitter2 {
@@ -1800,7 +1846,7 @@ var OrchestrationEngine = class extends EventEmitter5 {
   constructor(opts) {
     super();
     this.opts = opts;
-    this.context = new ContextManager(opts.cwd);
+    this.context = new ContextManager(opts.cwd, opts.resumeRunId);
     this.scheduler = new Scheduler(opts.maxParallel);
     this.registry = new AgentRegistry();
     this.supervisor = new ProcessSupervisor(opts.supervisorLimits);
@@ -1846,8 +1892,32 @@ var OrchestrationEngine = class extends EventEmitter5 {
     this._startTime = Date.now();
     let stageCount = 0;
     let plan = null;
+    const completedStages = [];
+    const resumeCompleted = new Set(this.opts.resumeCompletedStages || []);
+    const isResume = resumeCompleted.size > 0;
+    if (isResume && this.opts.resumeRunId) {
+      await this.context.loadFromHistory(this.opts.resumeRunId);
+      const strategistOutput = this.context.get("strategist");
+      if (strategistOutput) {
+        plan = parsePlan(strategistOutput);
+        this.brain.setPlan(plan);
+      }
+    }
+    const saveProgress = async (status) => {
+      const state = {
+        prompt: userPrompt,
+        completedStages,
+        skipStages: this.opts.skipStages,
+        status,
+        runId: this.context.getRunId(),
+        stageCount,
+        duration: Math.round((Date.now() - this._startTime) / 1e3),
+        planAssignments: plan ? Array.from(plan.assignments.keys()) : []
+      };
+      await this.context.saveStateToHistory(state);
+    };
     try {
-      if (!this.shouldSkip("analyzing")) {
+      if (!this.shouldSkip("analyzing") && !resumeCompleted.has("analyzing")) {
         this.setStage("analyzing");
         const result = await this.runDirectedAgent(
           "analyst",
@@ -1857,8 +1927,10 @@ ${userPrompt}`
         );
         await this.context.save("analyst", result.output);
         stageCount++;
+        completedStages.push("analyzing");
+        await saveProgress("running");
       }
-      if (!this.shouldSkip("planning")) {
+      if (!this.shouldSkip("planning") && !resumeCompleted.has("planning")) {
         this.setStage("planning");
         const analysisContext = this.context.get("analyst");
         const planPrompt = analysisContext ? `${userPrompt}
@@ -1868,6 +1940,7 @@ ${analysisContext}` : userPrompt;
         const planResult = await this.runDirectedAgent("strategist", planPrompt);
         await this.context.save("strategist", planResult.output);
         stageCount++;
+        completedStages.push("planning");
         plan = parsePlan(planResult.output);
         this.brain.setPlan(plan);
         logger.info(
@@ -1877,53 +1950,65 @@ ${analysisContext}` : userPrompt;
           assignments: Array.from(plan.assignments.keys()),
           modules: plan.modules.length
         });
+        await saveProgress("running");
       }
-      if (!this.shouldSkip("designing") && this.needsDesign()) {
+      if (!this.shouldSkip("designing") && !resumeCompleted.has("designing") && this.needsDesign()) {
         this.setStage("designing");
         const prompt = plan ? getAgentTask(plan, "designer", userPrompt) : userPrompt;
         const result = await this.runDirectedAgent("designer", prompt);
         await this.context.save("designer", result.output);
         stageCount++;
+        completedStages.push("designing");
+        await saveProgress("running");
       }
-      if (!this.shouldSkip("architecting")) {
+      if (!this.shouldSkip("architecting") && !resumeCompleted.has("architecting")) {
         this.setStage("architecting");
         const prompt = plan ? getAgentTask(plan, "architect", userPrompt) : userPrompt;
         const result = await this.runDirectedAgent("architect", prompt);
         await this.context.save("architect", result.output);
         stageCount++;
+        completedStages.push("architecting");
         if (plan) {
           const archModules = this.extractModules(result.output);
           if (archModules.length > 0) {
             plan.modules = archModules;
           }
         }
+        await saveProgress("running");
       }
-      if (!this.shouldSkip("coding")) {
+      if (!this.shouldSkip("coding") && !resumeCompleted.has("coding")) {
         this.setStage("coding");
         const prompt = plan ? getAgentTask(plan, "builder", userPrompt) : userPrompt;
         await this.runCodingStage(prompt, plan);
         stageCount++;
+        completedStages.push("coding");
+        await saveProgress("running");
       }
-      if (!this.shouldSkip("qa-planning")) {
+      if (!this.shouldSkip("qa-planning") && !resumeCompleted.has("qa-planning")) {
         this.setStage("qa-planning");
         const prompt = plan ? getAgentTask(plan, "qa", "Create a comprehensive test strategy and detailed test plans.") : "Create a comprehensive test strategy and detailed test plans for the codebase.";
         const result = await this.runDirectedAgent("qa", prompt);
         await this.context.save("qa", result.output);
         stageCount++;
+        completedStages.push("qa-planning");
+        await saveProgress("running");
       }
-      if (!this.shouldSkip("testing")) {
+      if (!this.shouldSkip("testing") && !resumeCompleted.has("testing")) {
         this.setStage("testing");
         const prompt = plan ? getAgentTask(plan, "guardian", "Write and run comprehensive tests.") : "Analyze the codebase and write comprehensive tests. Run them and report results.";
         const result = await this.runDirectedAgent("guardian", prompt);
         await this.context.save("guardian", result.output);
         stageCount++;
+        completedStages.push("testing");
+        await saveProgress("running");
       }
-      if (!this.shouldSkip("reviewing")) {
+      if (!this.shouldSkip("reviewing") && !resumeCompleted.has("reviewing")) {
         this.setStage("reviewing");
         const prompt = plan ? getAgentTask(plan, "sentinel", "Review all code for bugs, security issues, and quality.") : "Review all code in this project for bugs, security issues, and quality.";
         const review = await this.runDirectedAgent("sentinel", prompt);
         await this.context.save("sentinel", review.output);
         stageCount++;
+        completedStages.push("reviewing");
         if (review.output.includes("NEEDS_REVISION") && this._revisionCount < this.MAX_REVISIONS) {
           this._revisionCount++;
           logger.info(`Revision ${this._revisionCount}/${this.MAX_REVISIONS} - fixing review issues`);
@@ -1936,13 +2021,15 @@ ${review.output}`
           await this.context.save("builder", fix.output);
           stageCount++;
         }
+        await saveProgress("running");
       }
-      if (!this.shouldSkip("securing")) {
+      if (!this.shouldSkip("securing") && !resumeCompleted.has("securing")) {
         this.setStage("securing");
         const prompt = plan ? getAgentTask(plan, "security", "Perform a thorough security audit.") : "Perform a thorough security audit of this project.";
         const secAudit = await this.runDirectedAgent("security", prompt);
         await this.context.save("security", secAudit.output);
         stageCount++;
+        completedStages.push("securing");
         if (secAudit.output.includes("NEEDS_REVISION") && this._revisionCount < this.MAX_REVISIONS) {
           this._revisionCount++;
           logger.info(`Security revision ${this._revisionCount}/${this.MAX_REVISIONS}`);
@@ -1955,36 +2042,37 @@ ${secAudit.output}`
           await this.context.save("builder", fix.output);
           stageCount++;
         }
+        await saveProgress("running");
       }
-      if (!this.shouldSkip("documenting")) {
+      if (!this.shouldSkip("documenting") && !resumeCompleted.has("documenting")) {
         this.setStage("documenting");
         const prompt = plan ? getAgentTask(plan, "scribe", "Write comprehensive documentation.") : "Write comprehensive documentation for this project.";
         const result = await this.runDirectedAgent("scribe", prompt);
         await this.context.save("scribe", result.output);
         stageCount++;
+        completedStages.push("documenting");
+        await saveProgress("running");
       }
-      if (!this.shouldSkip("deploying")) {
+      if (!this.shouldSkip("deploying") && !resumeCompleted.has("deploying")) {
         this.setStage("deploying");
         const prompt = plan ? getAgentTask(plan, "devops", "Set up CI/CD, Docker, and deployment.") : "Set up CI/CD pipeline, Docker configuration, and deployment setup.";
         const result = await this.runDirectedAgent("devops", prompt);
         await this.context.save("devops", result.output);
         stageCount++;
+        completedStages.push("deploying");
+        await saveProgress("running");
       }
       this.setStage("complete");
       this.supervisor.stop();
       const duration = Math.round((Date.now() - this._startTime) / 1e3);
-      await this.context.saveState({
-        stage: "complete",
-        stageCount,
-        duration,
-        runId: this.context.getRunId(),
-        planAssignments: plan ? Array.from(plan.assignments.keys()) : []
-      });
+      await saveProgress("complete");
       return { success: true, stages: stageCount, duration };
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
       logger.error(`Engine failed: ${msg}`);
       this.emit("error", error);
+      await saveProgress("failed").catch(() => {
+      });
       return {
         success: false,
         stages: stageCount,
@@ -2785,6 +2873,15 @@ var TerminalRenderer = class {
       }
       this.spinners.delete(role);
     }
+    if (result.success && result.output) {
+      const summary = this.extractSummary(result.output);
+      if (summary.length > 0) {
+        console.log(chalk2.dim("  Summary:"));
+        for (const line of summary) {
+          console.log(chalk2.dim(`    ${line}`));
+        }
+      }
+    }
     if (!role.includes("-")) {
       this.completedStages++;
       this.printProgress();
@@ -2912,6 +3009,32 @@ var TerminalRenderer = class {
       this.phaseTimers.delete(role);
     }
   }
+  /**
+   * Extract a short summary from agent output.
+   * Looks for headings, bullet points, or key lines to surface.
+   */
+  extractSummary(output) {
+    const lines = output.split("\n").map((l) => l.trim()).filter(Boolean);
+    const summary = [];
+    for (const line of lines) {
+      if (summary.length >= 5) break;
+      if (/^#{1,3}\s+/.test(line)) {
+        const clean = line.replace(/^#+\s*/, "").slice(0, 80);
+        if (clean && !summary.includes(clean)) {
+          summary.push(clean);
+        }
+        continue;
+      }
+      if (/^[-*]\s+/.test(line) && summary.length < 5) {
+        const clean = line.replace(/^[-*]\s+/, "").slice(0, 80);
+        if (clean) summary.push(clean);
+      }
+    }
+    if (summary.length === 0 && lines.length > 0) {
+      summary.push(lines[0].slice(0, 100));
+    }
+    return summary;
+  }
   printProgress() {
     const total = this.totalStages;
     const done = this.completedStages;
@@ -2937,17 +3060,17 @@ var DEFAULT_CONFIG = {
   workflow: ["plan", "design", "architect", "code", "test", "review", "docs"],
   skipStages: [],
   agents: {
-    analyst: { maxTurns: 30 },
-    strategist: { maxTurns: 30 },
-    designer: { maxTurns: 30 },
-    architect: { maxTurns: 50 },
-    builder: { maxTurns: 100 },
-    qa: { maxTurns: 40 },
-    guardian: { maxTurns: 50 },
-    sentinel: { maxTurns: 30 },
-    security: { maxTurns: 30 },
-    scribe: { maxTurns: 30 },
-    devops: { maxTurns: 40 }
+    analyst: { maxTurns: 50 },
+    strategist: { maxTurns: 50 },
+    designer: { maxTurns: 50 },
+    architect: { maxTurns: 75 },
+    builder: { maxTurns: 150 },
+    qa: { maxTurns: 60 },
+    guardian: { maxTurns: 75 },
+    sentinel: { maxTurns: 50 },
+    security: { maxTurns: 50 },
+    scribe: { maxTurns: 50 },
+    devops: { maxTurns: 60 }
   }
 };
 
@@ -3319,6 +3442,11 @@ function formatSize(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 
+// src/commands/resume.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import chalk11 from "chalk";
+
 // src/ui/interactive.ts
 import * as readline from "readline";
 import { spawn as spawnProcess } from "child_process";
@@ -3384,24 +3512,34 @@ var ALL_AGENTS = [
   { key: "scribe", label: "Scribe", desc: "Documentation" },
   { key: "devops", label: "DevOps", desc: "CI/CD & deployment" }
 ];
+var lastRenderedLines = 0;
 function renderMenu(items, selected, multi, checked) {
+  const cols = process.stdout.columns || 80;
+  lastRenderedLines = 0;
   for (let i = 0; i < items.length; i++) {
     const isSelected = i === selected;
     const pointer = isSelected ? chalk10.hex(THEME.primary)(">") : " ";
     const label = isSelected ? chalk10.bold.white(items[i].label.padEnd(14)) : chalk10.white(items[i].label.padEnd(14));
-    const desc = chalk10.dim(items[i].description);
+    const prefix = multi ? "    X [x]  " : "    X ";
+    const labelRaw = items[i].label.padEnd(14);
+    const availableForDesc = cols - prefix.length - labelRaw.length - 2;
+    const descText = availableForDesc > 10 ? items[i].description.slice(0, availableForDesc) : items[i].description.slice(0, 30);
+    const desc = chalk10.dim(descText);
     let check = "";
     if (multi && checked) {
       check = checked.has(i) ? chalk10.hex(THEME.primary)(" [x] ") : chalk10.dim(" [ ] ");
     }
     process.stdout.write(`    ${pointer}${check} ${label} ${desc}
 `);
+    lastRenderedLines++;
   }
 }
 function clearMenu(count) {
-  for (let i = 0; i < count; i++) {
-    process.stdout.write("\x1B[1A\x1B[2K");
+  const lines = count ?? lastRenderedLines;
+  for (let i = 0; i < lines; i++) {
+    process.stdout.write("\x1B[1A");
   }
+  process.stdout.write("\x1B[0J");
 }
 function arrowSelect(items) {
   return new Promise((resolve) => {
@@ -3420,19 +3558,19 @@ function arrowSelect(items) {
       }
       if (str === "\x1B[A" && selected > 0) {
         selected--;
-        clearMenu(items.length);
+        clearMenu();
         renderMenu(items, selected);
       }
       if (str === "\x1B[B" && selected < items.length - 1) {
         selected++;
-        clearMenu(items.length);
+        clearMenu();
         renderMenu(items, selected);
       }
       if (str === "\r" || str === "\n") {
         if (process.stdin.isTTY) process.stdin.setRawMode(wasRaw ?? false);
         process.stdin.pause();
         process.stdin.removeListener("data", onKey);
-        clearMenu(items.length);
+        clearMenu();
         const item = items[selected];
         console.log(`    ${chalk10.hex(THEME.primary)(">")} ${chalk10.bold.white(item.label)}`);
         resolve(selected);
@@ -3459,12 +3597,12 @@ function arrowMultiSelect(items) {
       }
       if (str === "\x1B[A" && selected > 0) {
         selected--;
-        clearMenu(items.length);
+        clearMenu();
         renderMenu(items, selected, true, checked);
       }
       if (str === "\x1B[B" && selected < items.length - 1) {
         selected++;
-        clearMenu(items.length);
+        clearMenu();
         renderMenu(items, selected, true, checked);
       }
       if (str === " ") {
@@ -3473,14 +3611,14 @@ function arrowMultiSelect(items) {
         } else {
           checked.add(selected);
         }
-        clearMenu(items.length);
+        clearMenu();
         renderMenu(items, selected, true, checked);
       }
       if (str === "\r" || str === "\n") {
         if (process.stdin.isTTY) process.stdin.setRawMode(wasRaw ?? false);
         process.stdin.pause();
         process.stdin.removeListener("data", onKey);
-        clearMenu(items.length);
+        clearMenu();
         const picks = Array.from(checked).sort();
         if (picks.length > 0) {
           const names = picks.map((i) => items[i].label).join(", ");
@@ -3863,11 +4001,168 @@ async function startInteractiveSession() {
   }
 }
 
+// src/commands/resume.ts
+var STAGE_ORDER = STAGES.filter((s) => s.stage !== "complete").map((s) => s.stage);
+var ROLE_TO_STAGE = {
+  analyst: "analyzing",
+  strategist: "planning",
+  designer: "designing",
+  architect: "architecting",
+  builder: "coding",
+  qa: "qa-planning",
+  guardian: "testing",
+  sentinel: "reviewing",
+  security: "securing",
+  scribe: "documenting",
+  devops: "deploying"
+};
+async function discoverRuns(projectDir) {
+  const historyDir = path6.join(projectDir, ".krenk", "history");
+  let entries;
+  try {
+    entries = await fs6.promises.readdir(historyDir);
+  } catch {
+    return [];
+  }
+  const runs = [];
+  for (const entry of entries) {
+    const runDir = path6.join(historyDir, entry);
+    const stat = await fs6.promises.stat(runDir).catch(() => null);
+    if (!stat?.isDirectory()) continue;
+    const state = await ContextManager.loadRunState(projectDir, entry);
+    const inferredStages = [];
+    try {
+      const files = await fs6.promises.readdir(runDir);
+      for (const file of files) {
+        if (file.endsWith(".md")) {
+          const role = file.replace(/\.md$/, "");
+          const stage = ROLE_TO_STAGE[role];
+          if (stage) inferredStages.push(stage);
+        }
+      }
+    } catch {
+    }
+    let date;
+    try {
+      const isoStr = entry.replace(/^(\d{4}-\d{2}-\d{2}T\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/, "$1:$2:$3.$4Z");
+      date = new Date(isoStr);
+      if (isNaN(date.getTime())) date = new Date(stat.mtime);
+    } catch {
+      date = new Date(stat.mtime);
+    }
+    runs.push({ runId: entry, state, inferredStages, date });
+  }
+  runs.sort((a, b) => b.date.getTime() - a.date.getTime());
+  return runs;
+}
+function getStageLabel(completedStages) {
+  if (completedStages.length === 0) return "not started";
+  let furthest = completedStages[0];
+  for (const stage of completedStages) {
+    if (STAGE_ORDER.indexOf(stage) > STAGE_ORDER.indexOf(furthest)) {
+      furthest = stage;
+    }
+  }
+  const info = STAGES.find((s) => s.stage === furthest);
+  return info ? info.label : furthest;
+}
+function getCompletedStages(run) {
+  if (run.state?.completedStages && run.state.completedStages.length > 0) {
+    return run.state.completedStages;
+  }
+  return run.inferredStages;
+}
+function formatRunItem(run) {
+  const dateStr = run.date.toLocaleString();
+  const completed = getCompletedStages(run);
+  const stageLabel = getStageLabel(completed);
+  const status = run.state?.status || (completed.length > 0 ? "interrupted" : "unknown");
+  const promptSnippet = run.state?.prompt ? run.state.prompt.slice(0, 50) + (run.state.prompt.length > 50 ? "..." : "") : "(no prompt saved)";
+  const statusColor = status === "complete" ? chalk11.green : status === "failed" ? chalk11.red : chalk11.yellow;
+  return {
+    label: dateStr,
+    description: `${statusColor(status)} | reached: ${stageLabel} | ${chalk11.dim(promptSnippet)}`
+  };
+}
+async function resumeCommand() {
+  const cwd = process.cwd();
+  console.log(chalk11.bold.hex(THEME.primary)("\n  Resume a previous run\n"));
+  const runs = await discoverRuns(cwd);
+  if (runs.length === 0) {
+    console.log(chalk11.dim("  No previous runs found in .krenk/history/\n"));
+    return;
+  }
+  const resumable = runs.filter((r) => {
+    const status = r.state?.status;
+    return status !== "complete";
+  });
+  if (resumable.length === 0) {
+    console.log(chalk11.dim("  All previous runs completed successfully. Nothing to resume.\n"));
+    console.log(chalk11.dim("  Recent runs:"));
+    for (const run of runs.slice(0, 5)) {
+      const item = formatRunItem(run);
+      console.log(chalk11.dim(`    ${item.label} \u2014 ${item.description}`));
+    }
+    console.log();
+    return;
+  }
+  console.log(chalk11.dim("  Select a run to resume:\n"));
+  const menuItems = resumable.map(formatRunItem);
+  const selectedIndex = await arrowSelect(menuItems);
+  const selectedRun = resumable[selectedIndex];
+  const completedStages = getCompletedStages(selectedRun);
+  const prompt = selectedRun.state?.prompt;
+  if (!prompt) {
+    console.log(chalk11.red("\n  Cannot resume: no prompt was saved for this run."));
+    console.log(chalk11.dim("  This is a legacy run without state.json. Try running the task again.\n"));
+    return;
+  }
+  const skippedLabels = completedStages.map((s) => {
+    const info = STAGES.find((st) => st.stage === s);
+    return info?.label || s;
+  });
+  const remainingStages = STAGE_ORDER.filter((s) => !completedStages.includes(s));
+  const remainingLabels = remainingStages.map((s) => {
+    const info = STAGES.find((st) => st.stage === s);
+    return info?.label || s;
+  });
+  console.log();
+  if (skippedLabels.length > 0) {
+    console.log(chalk11.dim(`  Skipping completed: ${skippedLabels.join(", ")}`));
+  }
+  console.log(chalk11.white(`  Resuming from: ${remainingLabels[0] || "unknown"}`));
+  console.log(chalk11.dim(`  Remaining: ${remainingLabels.join(", ")}`));
+  console.log();
+  const config = await loadConfig(cwd);
+  const skipStages = selectedRun.state?.skipStages || [];
+  const engine = new OrchestrationEngine({
+    cwd,
+    maxParallel: config.maxParallelAgents,
+    skipStages,
+    noUi: false,
+    supervised: false,
+    agentConfig: config.agents,
+    resumeRunId: selectedRun.runId,
+    resumeCompletedStages: completedStages
+  });
+  const renderer = new TerminalRenderer(engine);
+  setupGracefulShutdown(engine, () => renderer.cleanup());
+  const result = await engine.run(prompt);
+  renderer.printSummary(result);
+  if (!result.success) {
+    process.exit(1);
+  }
+}
+
 // src/index.ts
 program.name("krenk").description(
   "Multi-agent software engineering orchestrator powered by Claude Code"
-).version("0.1.0").action(async () => {
-  await startInteractiveSession();
+).version("0.1.0").option("--resume", "Resume a previous interrupted or failed run").action(async (opts) => {
+  if (opts.resume) {
+    await resumeCommand();
+  } else {
+    await startInteractiveSession();
+  }
 });
 program.command("run").description("Run full engineering workflow with all agents").argument("<prompt>", "What to build").option("--skip <stages...>", "Skip specific stages (e.g. --skip design test)").option("--parallel <n>", "Max parallel agents", "3").option("--no-ui", "Disable fancy UI, use plain output").option("--supervised", "Approve each agent before it runs").action(runCommand);
 program.command("plan").description("Run only the planning stage").argument("<prompt>", "What to plan").action(planCommand);