declare-cc 0.6.0 → 1.0.0

package/dist/declare-tools.cjs

@@ -1,9 +1,30 @@
 #!/usr/bin/env node
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // src/git/commit.js
 var require_commit = __commonJS({
@@ -1531,7 +1552,7 @@ var require_help = __commonJS({
             usage: "/declare:help"
           }
         ],
-        version: "0.5.9"
+        version: "1.0.0"
       };
     }
     module2.exports = { runHelp: runHelp2 };
@@ -1862,6 +1883,7 @@ var require_add_milestones_batch = __commonJS({
         milestones.push({
           id,
           title: input.title,
+          description: input.description || "",
           status: "PENDING",
           realizes,
           hasPlan: false
@@ -1872,7 +1894,7 @@ var require_add_milestones_batch = __commonJS({
             decl.milestones.push(id);
           }
         }
-        results.push({ id, title: input.title, realizes, status: "PENDING" });
+        results.push({ id, title: input.title, description: input.description || "", realizes, status: "PENDING" });
       }
       const futureOutput = writeFutureFile(declarations, projectName);
       writeFileSync(futurePath, futureOutput, "utf-8");
@@ -4255,11 +4277,92 @@ var require_health_check = __commonJS({
   }
 });
 
+// src/server/ai-runner.js
+var require_ai_runner = __commonJS({
+  "src/server/ai-runner.js"(exports2, module2) {
+    "use strict";
+    var _query;
+    async function getQuery() {
+      if (!_query) {
+        const sdk = await import("@anthropic-ai/claude-agent-sdk");
+        _query = sdk.query;
+      }
+      return _query;
+    }
+    async function runAI(prompt, opts = {}) {
+      const queryFn = await getQuery();
+      const abortController = opts.abortController || new AbortController();
+      const timeoutMs = opts.withTools || opts.allowedTools ? 10 * 60 * 1e3 : 2 * 60 * 1e3;
+      const timeoutId = setTimeout(() => {
+        if (!abortController.signal.aborted) abortController.abort();
+      }, timeoutMs);
+      const savedClaudeCode = process.env.CLAUDECODE;
+      delete process.env.CLAUDECODE;
+      try {
+        const env = { ...process.env };
+        delete env.CLAUDECODE;
+        const queryOpts = {
+          model: opts.model || "haiku",
+          maxTurns: opts.maxTurns || 1,
+          cwd: opts.cwd || process.cwd(),
+          abortController,
+          env,
+          systemPrompt: opts.systemPrompt || "You are a helpful assistant. Respond concisely and directly."
+        };
+        if (opts.withTools || opts.allowedTools) {
+          queryOpts.allowedTools = opts.allowedTools || ["Read", "Write", "Edit", "Bash", "Glob", "Grep"];
+          queryOpts.permissionMode = "bypassPermissions";
+          if (!opts.maxTurns) queryOpts.maxTurns = 10;
+        } else {
+          queryOpts.tools = [];
+        }
+        const conversation = queryFn({
+          prompt,
+          options: queryOpts
+        });
+        let resultText = "";
+        for await (const message of conversation) {
+          if (message.type === "assistant") {
+            const content = message.message?.content;
+            if (Array.isArray(content)) {
+              for (const block of content) {
+                if (block.type === "text" && block.text) {
+                  resultText += block.text;
+                  if (opts.onText) opts.onText(block.text);
+                }
+              }
+            }
+          } else if (message.type === "result") {
+            if (message.subtype === "success" && message.result) {
+              resultText = message.result;
+            } else if (message.is_error) {
+              const errDetail = message.errors?.join(", ") || message.error || JSON.stringify(message);
+              console.error("[ai-runner] SDK error result:", errDetail);
+              return { text: "", error: errDetail || "AI query failed" };
+            }
+          }
+        }
+        return { text: resultText };
+      } catch (err) {
+        console.error("[ai-runner] Exception:", err.message || err);
+        if (abortController.signal.aborted) {
+          return { text: "", error: "Cancelled" };
+        }
+        return { text: "", error: String(err.message || err) };
+      } finally {
+        clearTimeout(timeoutId);
+        if (savedClaudeCode) process.env.CLAUDECODE = savedClaudeCode;
+      }
+    }
+    module2.exports = { runAI };
+  }
+});
+
 // src/server/process-manager.js
 var require_process_manager = __commonJS({
   "src/server/process-manager.js"(exports2, module2) {
     "use strict";
-    var { spawn } = require("node:child_process");
+    var { runAI } = require_ai_runner();
     var fs = require("node:fs");
     var path = require("node:path");
     var { findMilestoneFolder } = require_milestone_folders();
@@ -4270,7 +4373,49 @@ var require_process_manager = __commonJS({
       } catch (_) {
       }
     }
-    function createProcessManager(sseClients, cwd) {
+    function buildExecutionPrompt(actionId, milestoneId, ctx) {
+      if (!ctx) {
+        return `Run /declare:execute ${milestoneId} for action ${actionId} only. Do not ask questions, execute autonomously.`;
+      }
+      const lines = [
+        `Execute action ${actionId} for milestone ${milestoneId}. Work autonomously \u2014 do not ask questions.`,
+        ""
+      ];
+      if (ctx.declaration) {
+        lines.push(`## Declaration: ${ctx.declaration.id}`);
+        lines.push(ctx.declaration.statement);
+        lines.push("");
+      }
+      if (ctx.milestone) {
+        lines.push(`## Milestone: ${ctx.milestone.id} \u2014 ${ctx.milestone.title}`);
+        if (ctx.milestone.description) {
+          lines.push(ctx.milestone.description);
+        }
+        lines.push("");
+      }
+      lines.push(`## Action: ${ctx.action.id} \u2014 ${ctx.action.title}`);
+      if (ctx.action.produces) {
+        lines.push(`**Produces:** ${ctx.action.produces}`);
+      }
+      lines.push("");
+      if (ctx.siblingActions.length > 0) {
+        lines.push("## Other actions for this milestone (do NOT do these, just for context):");
+        for (const s of ctx.siblingActions) {
+          const statusMark = s.status === "DONE" ? " [DONE]" : "";
+          lines.push(`- ${s.id}: ${s.title}${s.produces ? " (produces: " + s.produces + ")" : ""}${statusMark}`);
+        }
+        lines.push("");
+      }
+      lines.push("## Instructions");
+      lines.push("1. Read the project context files: .planning/FUTURE.md, .planning/MILESTONES.md, .planning/STATE.md");
+      lines.push('2. Understand what this action needs to deliver based on the "Produces" field above');
+      lines.push("3. Explore the codebase to find the right files to modify");
+      lines.push("4. Implement the changes \u2014 write real, working code");
+      lines.push("5. Verify your changes work (run relevant tests, check for errors)");
+      lines.push("6. Commit your changes with a descriptive message");
+      return lines.join("\n");
+    }
+    function createProcessManager(sseClients, cwd, registry) {
       const processes = /* @__PURE__ */ new Map();
       function broadcast(event, data) {
         const payload = `event: ${event}
@@ -4285,32 +4430,14 @@ data: ${JSON.stringify(data)}
           }
         }
       }
-      function createLineHandler(actionId, streamName, logPath) {
-        let buffer = "";
-        return (chunk) => {
-          buffer += chunk.toString();
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          for (const line of lines) {
-            broadcast("action-output", { actionId, text: line, stream: streamName });
-            appendLog(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] [${actionId}] [${streamName}] ${line}`);
-          }
-        };
-      }
-      function execute(actionId, milestoneId) {
+      function execute(actionId, milestoneId, ctx) {
         if (processes.size > 0) {
           return { error: "busy", status: 409 };
         }
         if (processes.has(actionId)) {
           return { error: "already_running", status: 409 };
         }
-        const prompt = `Run /declare:execute ${milestoneId} for action ${actionId} only. Do not ask questions, execute autonomously.`;
-        const spawnEnv = { ...process.env, FORCE_COLOR: "0" };
-        delete spawnEnv.CLAUDECODE;
-        const proc = spawn("claude", ["-p", prompt], {
-          cwd,
-          env: spawnEnv
-        });
+        const prompt = buildExecutionPrompt(actionId, milestoneId, ctx);
         const planningDir = path.join(cwd, ".planning");
         const milestoneFolder = findMilestoneFolder(planningDir, milestoneId);
         let logPath;
@@ -4320,28 +4447,56 @@ data: ${JSON.stringify(data)}
           process.stderr.write(`[declare] Warning: milestone folder not found for ${milestoneId}, skipping execution log
 `);
         }
-        processes.set(actionId, { proc, milestoneId, logPath });
+        const abortController = new AbortController();
+        let agentId;
+        if (registry) {
+          const agent = registry.spawn("execution", actionId, milestoneId);
+          agentId = agent.id;
+        }
+        processes.set(actionId, { abortController, milestoneId, logPath, agentId });
         appendLog(logPath, `
 === START ${actionId} @ ${(/* @__PURE__ */ new Date()).toISOString()} ===`);
-        if (proc.stdout) {
-          proc.stdout.on("data", createLineHandler(actionId, "stdout", logPath));
-        }
-        if (proc.stderr) {
-          proc.stderr.on("data", createLineHandler(actionId, "stderr", logPath));
-        }
-        proc.on("close", (exitCode) => {
+        runAI(prompt, {
+          cwd,
+          model: "sonnet",
+          withTools: true,
+          maxTurns: 10,
+          abortController,
+          onText: (chunk) => {
+            broadcast("action-output", { actionId, text: chunk, stream: "stdout" });
+            appendLog(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] [${actionId}] [stdout] ${chunk}`);
+          }
+        }).then(({ text, error }) => {
           const entry = processes.get(actionId);
-          appendLog(entry?.logPath, `=== END ${actionId} @ ${(/* @__PURE__ */ new Date()).toISOString()} exit=${exitCode ?? -1} ===
+          const entryAgentId = entry?.agentId;
+          const exitCode = error ? 1 : 0;
+          appendLog(entry?.logPath, `=== END ${actionId} @ ${(/* @__PURE__ */ new Date()).toISOString()} exit=${exitCode} ===
 `);
           processes.delete(actionId);
-          broadcast("action-complete", { actionId, exitCode: exitCode ?? -1 });
-        });
-        proc.on("error", (_err) => {
+          broadcast("action-complete", { actionId, exitCode });
+          if (registry && entryAgentId) {
+            if (exitCode === 0) {
+              const mFolder = entry?.logPath ? path.dirname(entry.logPath) : null;
+              registry.complete(entryAgentId, {
+                actionId,
+                milestoneId: entry?.milestoneId || milestoneId,
+                summaryPath: mFolder ? path.join(mFolder, actionId + "-SUMMARY.md") : null,
+                logPath: entry?.logPath || null
+              });
+            } else {
+              registry.fail(entryAgentId, exitCode, error || "execution failed");
+            }
+          }
+        }).catch((err) => {
           const entry = processes.get(actionId);
+          const entryAgentId = entry?.agentId;
           appendLog(entry?.logPath, `=== ERROR ${actionId} @ ${(/* @__PURE__ */ new Date()).toISOString()} ===
 `);
           processes.delete(actionId);
           broadcast("action-complete", { actionId, exitCode: -1 });
+          if (registry && entryAgentId) {
+            registry.fail(entryAgentId, -1, String(err.message || err));
+          }
         });
         return { ok: true };
       }
@@ -4350,7 +4505,7 @@ data: ${JSON.stringify(data)}
         if (!entry) {
           return { error: "not_running", status: 404 };
         }
-        entry.proc.kill("SIGTERM");
+        entry.abortController.abort();
         return { ok: true };
       }
       function running() {
@@ -4366,7 +4521,7 @@ data: ${JSON.stringify(data)}
 var require_derivation_runner = __commonJS({
   "src/server/derivation-runner.js"(exports2, module2) {
     "use strict";
-    var { spawn } = require("node:child_process");
+    var { runAI } = require_ai_runner();
     function buildPrompt(declarationId, declarations) {
       let targets;
       if (declarationId) {
@@ -4377,10 +4532,10 @@ var require_derivation_runner = __commonJS({
         );
       }
       const formatted = targets.map((d) => `- ${d.id}: ${d.statement}`).join("\n");
-      return 'You are deriving milestones for a Declare project. Given these declarations, propose 2-4 milestones per declaration by asking "For this to be true, what must be true?" Output ONLY a JSON array with no markdown fencing: [{"title": "milestone title", "realizes": "D-XX", "reason": "why this must be true"}]. Declarations:\n\n' + formatted;
+      return 'You are deriving milestones for a Declare project. Given these declarations, propose 2-4 milestones per declaration by asking "For this to be true, what must be true?" Each milestone needs a concise title AND a detailed description explaining what it delivers, its scope, and success criteria. Output ONLY a JSON array with no markdown fencing: [{"title": "short milestone title", "description": "Detailed description of what this milestone delivers, its scope and boundaries, and how to verify it is complete.", "realizes": "D-XX", "reason": "why this must be true"}]. Declarations:\n\n' + formatted;
     }
-    function createDerivationRunner(sseClients, cwd) {
-      let current = null;
+    function createDerivationRunner(sseClients, cwd, registry) {
+      const sessions = /* @__PURE__ */ new Map();
       function broadcast(event, data) {
         const payload = `event: ${event}
 data: ${JSON.stringify(data)}
@@ -4394,88 +4549,117 @@ data: ${JSON.stringify(data)}
           }
         }
       }
-      function createLineHandler(sessionId, streamName, accumulator) {
-        let buffer = "";
-        return (chunk) => {
-          const text = chunk.toString();
-          if (streamName === "stdout") {
-            accumulator.text += text;
-          }
-          buffer += text;
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          for (const line of lines) {
+      function derive(declarationId, declarations) {
+        const sessionId = `deriv-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        const prompt = buildPrompt(declarationId, declarations);
+        const abortController = new AbortController();
+        let agentId;
+        if (registry) {
+          const agent = registry.spawn("derivation", declarationId || "all", "");
+          agentId = agent.id;
+        }
+        sessions.set(sessionId, { abortController, agentId, declarationId, startTime: Date.now() });
+        broadcast("derivation-output", {
+          sessionId,
+          declarationId,
+          text: "Spawning AI agent\u2026",
+          stream: "status"
+        });
+        runAI(prompt, {
+          cwd,
+          model: "sonnet",
+          maxTurns: 1,
+          abortController,
+          onText: (chunk) => {
             broadcast("derivation-output", {
               sessionId,
-              text: line,
-              stream: streamName
+              declarationId,
+              text: chunk,
+              stream: "stdout"
             });
           }
-        };
-      }
-      function derive(declarationId, declarations) {
-        if (current) {
-          return { error: "busy", status: 409 };
-        }
-        const sessionId = `deriv-${Date.now()}`;
-        const prompt = buildPrompt(declarationId, declarations);
-        const env = { ...process.env, FORCE_COLOR: "0" };
-        delete env.CLAUDECODE;
-        const proc = spawn("claude", ["-p", prompt, "--output-format", "text"], {
-          cwd,
-          env
-        });
-        current = { sessionId, proc };
-        const stdout = { text: "" };
-        if (proc.stdout) {
-          proc.stdout.on("data", createLineHandler(sessionId, "stdout", stdout));
-        }
-        if (proc.stderr) {
-          proc.stderr.on("data", createLineHandler(sessionId, "stderr", stdout));
-        }
-        proc.on("close", (exitCode) => {
+        }).then(({ text, error }) => {
+          const session = sessions.get(sessionId);
+          const closingAgentId = session ? session.agentId : void 0;
+          sessions.delete(sessionId);
+          if (error) {
+            broadcast("derivation-complete", {
+              sessionId,
+              declarationId,
+              exitCode: 1,
+              milestones: null,
+              error
+            });
+            if (registry && closingAgentId) {
+              registry.fail(closingAgentId, 1, error);
+            }
+            return;
+          }
           let milestones = null;
-          if (exitCode === 0) {
-            try {
-              milestones = JSON.parse(stdout.text.trim());
-            } catch (_) {
+          try {
+            milestones = JSON.parse(text.trim());
+          } catch (_) {
+            const match = text.match(/\[[\s\S]*\]/);
+            if (match) {
+              try {
+                milestones = JSON.parse(match[0]);
+              } catch (__) {
+              }
             }
           }
-          current = null;
           broadcast("derivation-complete", {
             sessionId,
-            exitCode: exitCode ?? -1,
+            declarationId,
+            exitCode: 0,
             milestones
           });
-        });
-        proc.on("error", (_err) => {
-          current = null;
+          if (registry && closingAgentId) {
+            const milestoneIds = Array.isArray(milestones) ? milestones.map((m) => m.id || m.title || "unknown").filter(Boolean) : [];
+            registry.complete(closingAgentId, { milestones: milestoneIds });
+          }
+        }).catch((err) => {
+          const session = sessions.get(sessionId);
+          const errorAgentId = session ? session.agentId : void 0;
+          sessions.delete(sessionId);
           broadcast("derivation-complete", {
             sessionId,
+            declarationId,
             exitCode: -1,
-            milestones: null
+            milestones: null,
+            error: String(err.message || err)
           });
+          if (registry && errorAgentId) {
+            registry.fail(errorAgentId, -1, "error");
+          }
         });
         return { ok: true, sessionId };
       }
-      function stop() {
-        if (!current) {
-          return { error: "not_running", status: 404 };
+      function stop(sessionId) {
+        if (sessionId) {
+          const session = sessions.get(sessionId);
+          if (!session) {
+            return { error: "not_running", status: 404 };
+          }
+          session.abortController.abort();
+          return { ok: true };
+        }
+        return stopAll();
+      }
+      function stopAll() {
+        for (const [, session] of sessions) {
+          session.abortController.abort();
         }
-        current.proc.kill("SIGTERM");
         return { ok: true };
       }
       function running() {
-        return current ? current.sessionId : null;
+        if (sessions.size === 0) return null;
+        return Array.from(sessions.entries()).map(([id, s]) => ({
+          sessionId: id,
+          declarationId: s.declarationId,
+          startTime: s.startTime
+        }));
       }
-      return { derive, stop, running };
-    }
-    if (require.main === module2) {
-      const runner = createDerivationRunner(/* @__PURE__ */ new Set(), ".");
-      console.log("derive:", typeof runner.derive);
-      console.log("stop:", typeof runner.stop);
-      console.log("running:", typeof runner.running);
-      console.log("OK");
+      return { derive, stop, stopAll, running };
     }
     module2.exports = { createDerivationRunner };
   }
@@ -4485,7 +4669,7 @@ data: ${JSON.stringify(data)}
 var require_action_derivation_runner = __commonJS({
   "src/server/action-derivation-runner.js"(exports2, module2) {
     "use strict";
-    var { spawn } = require("node:child_process");
+    var { runAI } = require_ai_runner();
     function buildActionPrompt(milestone, existingActions) {
       let prompt = `You are deriving actions for a Declare project milestone. An action is a concrete piece of work that causes (moves toward) a milestone. Given this milestone, propose 2-5 actions by asking "What work must be done to achieve this?" Output ONLY a JSON array with no markdown fencing: [{"title": "action title", "produces": "what this action delivers", "reason": "why this is needed"}]. 
 
@@ -4501,8 +4685,8 @@ Milestone:
       }
       return prompt;
     }
-    function createActionDerivationRunner(sseClients, cwd) {
-      let current = null;
+    function createActionDerivationRunner(sseClients, cwd, registry) {
+      const sessions = /* @__PURE__ */ new Map();
       function broadcast(event, data) {
         const payload = `event: ${event}
 data: ${JSON.stringify(data)}
@@ -4516,86 +4700,107 @@ data: ${JSON.stringify(data)}
           }
         }
       }
-      function createLineHandler(sessionId, streamName, accumulator) {
-        let buffer = "";
-        return (chunk) => {
-          const text = chunk.toString();
-          if (streamName === "stdout") {
-            accumulator.text += text;
-          }
-          buffer += text;
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          for (const line of lines) {
-            broadcast("action-derivation-output", {
-              sessionId,
-              text: line,
-              stream: streamName
-            });
-          }
-        };
-      }
       function derive(milestone, existingActions) {
-        if (current) {
-          return { error: "busy", status: 409 };
-        }
         const sessionId = `action-deriv-${Date.now()}`;
         const prompt = buildActionPrompt(milestone, existingActions);
-        const env = { ...process.env, FORCE_COLOR: "0" };
-        delete env.CLAUDECODE;
-        const proc = spawn("claude", ["-p", prompt, "--output-format", "text"], {
+        const abortController = new AbortController();
+        let agentId;
+        if (registry) {
+          const agent = registry.spawn("action-derivation", milestone.id, milestone.id);
+          agentId = agent.id;
+        }
+        sessions.set(sessionId, { milestoneId: milestone.id, agentId, abortController, startTime: Date.now() });
+        runAI(prompt, {
           cwd,
-          env
-        });
-        current = { sessionId, milestoneId: milestone.id, proc };
-        const stdout = { text: "" };
-        if (proc.stdout) {
-          proc.stdout.on("data", createLineHandler(sessionId, "stdout", stdout));
-        }
-        if (proc.stderr) {
-          proc.stderr.on("data", createLineHandler(sessionId, "stderr", stdout));
-        }
-        proc.on("close", (exitCode) => {
+          model: "haiku",
+          maxTurns: 1,
+          abortController,
+          onText: (text) => {
+            broadcast("action-derivation-output", {
+              sessionId,
+              milestoneId: milestone.id,
+              text,
+              stream: "stdout"
+            });
+          }
+        }).then(({ text, error }) => {
+          const session = sessions.get(sessionId);
+          const closingAgentId = session ? session.agentId : void 0;
+          sessions.delete(sessionId);
           let actions = null;
-          if (exitCode === 0) {
+          const exitCode = error ? 1 : 0;
+          if (!error && text) {
             try {
-              actions = JSON.parse(stdout.text.trim());
+              actions = JSON.parse(text.trim());
             } catch (_) {
+              const jsonMatch = text.match(/\[[\s\S]*\]/);
+              if (jsonMatch) {
+                try {
+                  actions = JSON.parse(jsonMatch[0]);
+                } catch (_2) {
+                }
+              }
             }
           }
-          current = null;
           broadcast("action-derivation-complete", {
             sessionId,
-            exitCode: exitCode ?? -1,
+            milestoneId: milestone.id,
+            exitCode,
             actions
           });
-        });
-        proc.on("error", (_err) => {
-          current = null;
-          broadcast("action-derivation-complete", {
-            sessionId,
-            exitCode: -1,
-            actions: null
-          });
+          if (registry && closingAgentId) {
+            if (exitCode === 0) {
+              registry.complete(closingAgentId, {
+                milestoneId: milestone.id,
+                actionCount: Array.isArray(actions) ? actions.length : null
+              });
+            } else {
+              registry.fail(closingAgentId, 1, error || "action derivation failed");
+            }
+          }
+        }).catch((err) => {
+          const session = sessions.get(sessionId);
+          const closingAgentId = session ? session.agentId : void 0;
+          sessions.delete(sessionId);
+          broadcast("action-derivation-complete", { sessionId, milestoneId: milestone.id, exitCode: 1, actions: null });
+          if (registry && closingAgentId) {
+            registry.fail(closingAgentId, 1, String(err));
+          }
         });
         return { ok: true, sessionId };
       }
-      function stop() {
-        if (!current) {
-          return { error: "not_running", status: 404 };
+      function stop(sessionId) {
+        if (sessionId) {
+          const session = sessions.get(sessionId);
+          if (!session) {
+            return { error: "not_running", status: 404 };
+          }
+          session.abortController.abort();
+          return { ok: true };
+        }
+        return stopAll();
+      }
+      function stopAll() {
+        for (const [, session] of sessions) {
+          session.abortController.abort();
         }
-        current.proc.kill("SIGTERM");
         return { ok: true };
       }
       function running() {
-        return current ? current.sessionId : null;
+        if (sessions.size === 0) return null;
+        return Array.from(sessions.entries()).map(([id, s]) => ({
+          sessionId: id,
+          milestoneId: s.milestoneId,
+          startTime: s.startTime
+        }));
       }
-      return { derive, stop, running };
+      return { derive, stop, stopAll, running };
     }
     if (require.main === module2) {
       const runner = createActionDerivationRunner(/* @__PURE__ */ new Set(), ".");
       console.log("derive:", typeof runner.derive);
       console.log("stop:", typeof runner.stop);
+      console.log("stopAll:", typeof runner.stopAll);
       console.log("running:", typeof runner.running);
       console.log("OK");
     }
@@ -4607,14 +4812,15 @@ data: ${JSON.stringify(data)}
 var require_revision_runner = __commonJS({
   "src/server/revision-runner.js"(exports2, module2) {
     "use strict";
-    var { spawn } = require("node:child_process");
+    var { runAI } = require_ai_runner();
     var fs = require("node:fs");
     var path = require("node:path");
     function buildRevisionPrompt(artifactContent, annotations) {
       const annotationList = annotations.map((a) => `- Line ${a.line}: ${a.text}`).join("\n");
-      return "You are revising a plan artifact based on reviewer annotations. Do NOT implement anything \u2014 only update the plan document.\n\n## Current plan content\n\n" + artifactContent + "\n\n## Reviewer annotations to address\n\n" + annotationList + "\n\n## Instructions\n\nRevise the plan above to address ALL the reviewer's annotations. Output ONLY the revised plan content \u2014 no explanations, no markdown fencing, no preamble. The output will directly replace the current file.";
+      return "## Current plan content\n\n" + artifactContent + "\n\n## Reviewer annotations to address\n\n" + annotationList + "\n\n## Instructions\n\nRevise the plan above to address ALL the reviewer's annotations. Output ONLY the revised plan content \u2014 no explanations, no markdown fencing, no preamble. The output will directly replace the current file.";
     }
-    function createRevisionRunner(sseClients, cwd, onComplete) {
+    var SYSTEM_PROMPT = "You are revising a plan artifact based on reviewer annotations. Do NOT implement anything \u2014 only update the plan document. Output ONLY the revised content with no markdown fencing or preamble.";
+    function createRevisionRunner(sseClients, cwd, onComplete, registry) {
       let current = null;
       function broadcast(event, data) {
         const payload = `event: ${event}
@@ -4629,26 +4835,6 @@ data: ${JSON.stringify(data)}
           }
         }
       }
-      function createLineHandler(sessionId, nodeId, streamName, accumulator) {
-        let buffer = "";
-        return (chunk) => {
-          const text = chunk.toString();
-          if (streamName === "stdout") {
-            accumulator.text += text;
-          }
-          buffer += text;
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          for (const line of lines) {
-            broadcast("revision-output", {
-              sessionId,
-              nodeId,
-              text: line,
-              stream: streamName
-            });
-          }
-        };
-      }
       function stripMarkdownFencing(text) {
         const trimmed = text.trim();
         const fenceMatch = trimmed.match(/^```(?:markdown)?\s*\n([\s\S]*?)\n```\s*$/);
@@ -4677,70 +4863,90 @@ data: ${JSON.stringify(data)}
           fs.copyFileSync(artifactPath, versionedPath);
         } catch (_) {
         }
-        const spawnEnv = { ...process.env, FORCE_COLOR: "0" };
-        delete spawnEnv.CLAUDECODE;
-        const proc = spawn("claude", ["-p", prompt, "--output-format", "text"], {
-          cwd,
-          env: spawnEnv
-        });
-        current = { sessionId, proc, nodeId };
-        const stdout = { text: "" };
-        if (proc.stdout) {
-          proc.stdout.on("data", createLineHandler(sessionId, nodeId, "stdout", stdout));
-        }
-        if (proc.stderr) {
-          proc.stderr.on("data", createLineHandler(sessionId, nodeId, "stderr", stdout));
+        const abortController = new AbortController();
+        let agentId;
+        if (registry) {
+          const agent = registry.spawn("revision", nodeId, "");
+          agentId = agent.id;
         }
-        proc.on("close", (exitCode) => {
+        current = { sessionId, abortController, nodeId, agentId };
+        runAI(prompt, {
+          cwd,
+          model: "sonnet",
+          systemPrompt: SYSTEM_PROMPT,
+          abortController,
+          onText: (chunk) => {
+            broadcast("revision-output", {
+              sessionId,
+              nodeId,
+              text: chunk,
+              stream: "stdout"
+            });
+          }
+        }).then(({ text, error }) => {
           const completedNodeId = current ? current.nodeId : nodeId;
+          const closingAgentId = current ? current.agentId : void 0;
           current = null;
-          if (exitCode === 0) {
-            try {
-              const revisedContent = stripMarkdownFencing(stdout.text);
-              fs.writeFileSync(artifactPath, revisedContent, "utf-8");
-              const annPath = path.join(cwd, ".planning", "annotations", completedNodeId.toUpperCase() + ".json");
-              let annData = { nodeId: completedNodeId.toUpperCase(), annotations: [], revisionRound: 0 };
-              if (fs.existsSync(annPath)) {
-                try {
-                  annData = JSON.parse(fs.readFileSync(annPath, "utf-8"));
-                } catch (_) {
-                }
+          if (error) {
+            broadcast("revision-complete", {
+              sessionId,
+              nodeId: completedNodeId,
+              exitCode: 1,
+              error: true
+            });
+            if (registry && closingAgentId) {
+              registry.fail(closingAgentId, 1, error);
+            }
+            return;
+          }
+          try {
+            const revisedContent = stripMarkdownFencing(text);
+            fs.writeFileSync(artifactPath, revisedContent, "utf-8");
+            const annPath = path.join(cwd, ".planning", "annotations", completedNodeId.toUpperCase() + ".json");
+            let annData = { nodeId: completedNodeId.toUpperCase(), annotations: [], revisionRound: 0 };
+            if (fs.existsSync(annPath)) {
+              try {
+                annData = JSON.parse(fs.readFileSync(annPath, "utf-8"));
+              } catch (_) {
               }
-              const newRound = (annData.revisionRound || 0) + 1;
-              annData.revisionRound = newRound;
-              const annDir = path.dirname(annPath);
-              fs.mkdirSync(annDir, { recursive: true });
-              fs.writeFileSync(annPath, JSON.stringify(annData, null, 2), "utf-8");
-              broadcast("revision-complete", {
-                sessionId,
-                nodeId: completedNodeId,
-                exitCode,
-                revisionRound: newRound
-              });
-              if (onComplete) {
-                try {
-                  onComplete(completedNodeId);
-                } catch (_) {
-                }
+            }
+            const newRound = (annData.revisionRound || 0) + 1;
+            annData.revisionRound = newRound;
+            const annDir = path.dirname(annPath);
+            fs.mkdirSync(annDir, { recursive: true });
+            fs.writeFileSync(annPath, JSON.stringify(annData, null, 2), "utf-8");
+            broadcast("revision-complete", {
+              sessionId,
+              nodeId: completedNodeId,
+              exitCode: 0,
+              revisionRound: newRound
+            });
+            if (onComplete) {
+              try {
+                onComplete(completedNodeId);
+              } catch (_) {
               }
-            } catch (err) {
-              broadcast("revision-complete", {
-                sessionId,
+            }
+            if (registry && closingAgentId) {
+              registry.complete(closingAgentId, {
                 nodeId: completedNodeId,
-                exitCode: -1,
-                error: true
+                planPath: artifactPath,
+                revisionRound: newRound
               });
             }
-          } else {
+          } catch (err) {
             broadcast("revision-complete", {
               sessionId,
               nodeId: completedNodeId,
-              exitCode: exitCode ?? -1,
+              exitCode: -1,
               error: true
             });
+            if (registry && closingAgentId) {
+              registry.fail(closingAgentId, -1, "revision post-processing error");
+            }
           }
-        });
-        proc.on("error", (_err) => {
+        }).catch((err) => {
+          const errorAgentId = current ? current.agentId : void 0;
           current = null;
           broadcast("revision-complete", {
             sessionId,
@@ -4748,6 +4954,9 @@ data: ${JSON.stringify(data)}
             exitCode: -1,
             error: true
           });
+          if (registry && errorAgentId) {
+            registry.fail(errorAgentId, -1, "error");
+          }
         });
         return { ok: true, sessionId };
       }
@@ -4755,7 +4964,7 @@ data: ${JSON.stringify(data)}
         if (!current) {
           return { error: "not_running", status: 404 };
         }
-        current.proc.kill("SIGTERM");
+        current.abortController.abort();
         return { ok: true };
       }
       function running() {
@@ -5204,57 +5413,252 @@ data: ${JSON.stringify(data)}
   }
 });
 
-// src/server/pipeline-runner.js
-var require_pipeline_runner = __commonJS({
-  "src/server/pipeline-runner.js"(exports2, module2) {
+// src/commands/lifecycle-stages.js
+var require_lifecycle_stages = __commonJS({
+  "src/commands/lifecycle-stages.js"(exports2, module2) {
     "use strict";
-    var { spawn, execSync } = require("node:child_process");
-    var fs = require("node:fs");
-    var path = require("node:path");
-    var { findMilestoneFolder } = require_milestone_folders();
-    var STATE_FILE = ".planning/pipeline-state.json";
-    var OUTPUT_BUFFER_MAX = 5e4;
-    function appendLog(logPath, line) {
-      if (!logPath) return;
-      try {
-        fs.appendFileSync(logPath, line + "\n", "utf-8");
-      } catch (_) {
+    var COMPLETED_STATUSES = /* @__PURE__ */ new Set(["DONE", "KEPT", "HONORED"]);
+    var EXECUTING_STATUSES = /* @__PURE__ */ new Set(["EXECUTING", "IN_PROGRESS", "RUNNING"]);
+    function computeLifecycleStages(graph, runningActionIds) {
+      const { declarations = [], milestones = [], actions = [] } = graph;
+      const running = runningActionIds || /* @__PURE__ */ new Set();
+      const stages = {
+        "needs-planning": [],
+        "needs-approval": [],
+        "ready-to-execute": [],
+        "in-execution": [],
+        "done": []
+      };
+      const milestoneById = new Map(milestones.map((m) => [m.id, m]));
+      const actionsByMilestone = /* @__PURE__ */ new Map();
+      for (const a of actions) {
+        for (const mId of a.causes || []) {
+          if (!actionsByMilestone.has(mId)) actionsByMilestone.set(mId, []);
+          actionsByMilestone.get(mId).push(a);
+        }
       }
-    }
-    function isTransientFailure(exitCode, stderrOutput) {
-      if (exitCode === 124 || exitCode === 137 || exitCode === -1) return true;
-      const patterns = /ETIMEDOUT|ECONNRESET|ECONNREFUSED|ENOMEM|SIGKILL|SIGTERM|socket hang up|network timeout/i;
-      return patterns.test(stderrOutput);
-    }
-    function generateExecutionReport(cwd, results, pipelineStartTime, pipelineStopped, startSha) {
-      try {
-        let endSha = "unknown";
-        try {
-          endSha = execSync("git rev-parse --short HEAD", { cwd }).toString().trim();
-        } catch (_) {
+      const milestonesByDecl = /* @__PURE__ */ new Map();
+      for (const d of declarations) {
+        milestonesByDecl.set(d.id, (d.milestones || []).filter((mId) => milestoneById.has(mId)));
+      }
+      for (const d of declarations) {
+        const status = (d.status || "").toUpperCase();
+        if (COMPLETED_STATUSES.has(status)) {
+          stages["done"].push(makeItem(d, "declaration", "done"));
+          continue;
         }
-        const endTime = Date.now();
-        const totalMs = endTime - pipelineStartTime;
-        const totalMin = Math.floor(totalMs / 6e4);
-        const totalSec = Math.floor(totalMs % 6e4 / 1e3);
-        const passed = results.filter((r) => r.exitCode === 0).length;
-        const failed = results.filter((r) => r.exitCode !== 0).length;
-        const overallStatus = pipelineStopped ? "STOPPED" : failed > 0 ? "FAILED" : "SUCCESS";
-        const startedAt = new Date(pipelineStartTime).toISOString();
-        const completedAt = new Date(endTime).toISOString();
-        let rows = "";
-        for (let i = 0; i < results.length; i++) {
-          const r = results[i];
-          const status = r.exitCode === 0 ? "PASS" : "FAIL";
-          const durMin = Math.floor(r.durationMs / 6e4);
-          const durSec = Math.floor(r.durationMs % 6e4 / 1e3);
-          const retried = r.retried ? `Yes (${r.attempts})` : "No";
-          rows += `| ${i + 1} | ${r.actionId} | ${r.milestoneId} | ${status} | ${durMin}m ${durSec}s | ${retried} |
-`;
+        const myMilestones = milestonesByDecl.get(d.id) || [];
+        if (myMilestones.length === 0) {
+          stages["needs-planning"].push(makeItem(d, "declaration", "needs-planning"));
+          continue;
         }
-        const report = `# Execution Report
-
-**Status:** ${overallStatus}
+        if (d.reviewState !== "approved") {
+          stages["needs-approval"].push(makeItem(d, "declaration", "needs-approval"));
+          continue;
+        }
+        const allMilestonesDone = myMilestones.every((mId) => {
+          const m = milestoneById.get(mId);
+          return m && COMPLETED_STATUSES.has((m.status || "").toUpperCase());
+        });
+        if (allMilestonesDone) {
+          stages["done"].push(makeItem(d, "declaration", "done"));
+        } else {
+        }
+      }
+      for (const m of milestones) {
+        const status = (m.status || "").toUpperCase();
+        if (COMPLETED_STATUSES.has(status)) {
+          stages["done"].push(makeItem(m, "milestone", "done"));
+          continue;
+        }
+        const myActions = actionsByMilestone.get(m.id) || [];
+        const hasPlan = m.hasPlan || myActions.length > 0;
+        if (!hasPlan) {
+          stages["needs-planning"].push(makeItem(m, "milestone", "needs-planning"));
+          continue;
+        }
+        if (m.reviewState !== "approved") {
+          stages["needs-approval"].push(makeItem(m, "milestone", "needs-approval"));
+          continue;
+        }
+        const hasExecuting = myActions.some(
+          (a) => EXECUTING_STATUSES.has((a.status || "").toUpperCase()) || running.has(a.id)
+        );
+        if (hasExecuting) {
+          stages["in-execution"].push(makeItem(m, "milestone", "in-execution"));
+          continue;
+        }
+        const allActionsDone = myActions.length > 0 && myActions.every(
+          (a) => COMPLETED_STATUSES.has((a.status || "").toUpperCase())
+        );
+        if (allActionsDone) {
+          stages["done"].push(makeItem(m, "milestone", "done"));
+          continue;
+        }
+        const deps = m.dependsOn || [];
+        const depsBlocked = deps.some((depId) => {
+          const dep = milestoneById.get(depId);
+          return !dep || !COMPLETED_STATUSES.has((dep.status || "").toUpperCase());
+        });
+        if (depsBlocked) {
+          stages["needs-approval"].push(makeItem(m, "milestone", "needs-approval"));
+        } else {
+          stages["ready-to-execute"].push(makeItem(m, "milestone", "ready-to-execute"));
+        }
+      }
+      for (const a of actions) {
+        const status = (a.status || "").toUpperCase();
+        if (COMPLETED_STATUSES.has(status)) {
+          stages["done"].push(makeItem(a, "action", "done"));
+          continue;
+        }
+        if (EXECUTING_STATUSES.has(status) || running.has(a.id)) {
+          stages["in-execution"].push(makeItem(a, "action", "in-execution"));
+          continue;
+        }
+        if (a.reviewState !== "approved") {
+          stages["needs-approval"].push(makeItem(a, "action", "needs-approval"));
+          continue;
+        }
+        const parentMilestones = (a.causes || []).map((mId) => milestoneById.get(mId)).filter(Boolean);
+        const parentBlocked = parentMilestones.some((m) => {
+          const deps = m.dependsOn || [];
+          return deps.some((depId) => {
+            const dep = milestoneById.get(depId);
+            return !dep || !COMPLETED_STATUSES.has((dep.status || "").toUpperCase());
+          });
+        });
+        if (parentBlocked) {
+          stages["needs-approval"].push(makeItem(a, "action", "needs-approval"));
+        } else {
+          stages["ready-to-execute"].push(makeItem(a, "action", "ready-to-execute"));
+        }
+      }
+      const nextAction = computeNextAction(stages, declarations, milestones, actions);
+      const total = declarations.length + milestones.length + actions.length;
+      const done = stages["done"].length;
+      const percentage = total > 0 ? Math.round(done / total * 100) : 0;
+      return {
+        stages,
+        nextAction,
+        progress: { total, done, percentage }
+      };
+    }
+    function computeNextAction(stages, declarations, milestones, actions) {
+      const planningDecl = stages["needs-planning"].find((item) => item.type === "declaration");
+      if (planningDecl) {
+        return {
+          action: "derive-milestones",
+          label: `Plan milestones for ${planningDecl.id}`,
+          targetId: planningDecl.id,
+          targetType: "declaration"
+        };
+      }
+      const planningMile = stages["needs-planning"].find((item) => item.type === "milestone");
+      if (planningMile) {
+        return {
+          action: "derive-actions",
+          label: `Plan actions for ${planningMile.id}`,
+          targetId: planningMile.id,
+          targetType: "milestone"
+        };
+      }
+      if (stages["needs-approval"].length > 0) {
+        const first = stages["needs-approval"][0];
+        return {
+          action: "approve",
+          label: `Review ${first.id}`,
+          targetId: first.id,
+          targetType: first.type
+        };
+      }
+      if (stages["ready-to-execute"].length > 0) {
+        return {
+          action: "execute",
+          label: "Execute approved actions"
+        };
+      }
+      if (stages["in-execution"].length > 0) {
+        return {
+          action: "view-execution",
+          label: "Execution in progress"
+        };
+      }
+      const total = declarations.length + milestones.length + actions.length;
+      if (total > 0) {
+        return {
+          action: "complete",
+          label: "All items complete"
+        };
+      }
+      return null;
+    }
+    function makeItem(node, type, stage) {
+      return {
+        id: node.id,
+        title: node.title || node.statement || node.id,
+        type,
+        status: node.status || "PENDING",
+        reviewState: node.reviewState,
+        stage
+      };
+    }
+    module2.exports = { computeLifecycleStages, COMPLETED_STATUSES, EXECUTING_STATUSES };
+  }
+});
+
+// src/server/pipeline-runner.js
+var require_pipeline_runner = __commonJS({
+  "src/server/pipeline-runner.js"(exports2, module2) {
+    "use strict";
+    var { runAI } = require_ai_runner();
+    var { execSync } = require("node:child_process");
+    var fs = require("node:fs");
+    var path = require("node:path");
+    var { findMilestoneFolder } = require_milestone_folders();
+    var STATE_FILE = ".planning/pipeline-state.json";
+    var OUTPUT_BUFFER_MAX = 5e4;
+    function appendLog(logPath, line) {
+      if (!logPath) return;
+      try {
+        fs.appendFileSync(logPath, line + "\n", "utf-8");
+      } catch (_) {
+      }
+    }
+    function isTransientFailure(exitCode, errorOutput) {
+      if (exitCode === 124 || exitCode === 137 || exitCode === -1) return true;
+      const patterns = /ETIMEDOUT|ECONNRESET|ECONNREFUSED|ENOMEM|SIGKILL|SIGTERM|socket hang up|network timeout|Cancelled/i;
+      return patterns.test(errorOutput);
+    }
+    function generateExecutionReport(cwd, results, pipelineStartTime, pipelineStopped, startSha) {
+      try {
+        let endSha = "unknown";
+        try {
+          endSha = execSync("git rev-parse --short HEAD", { cwd }).toString().trim();
+        } catch (_) {
+        }
+        const endTime = Date.now();
+        const totalMs = endTime - pipelineStartTime;
+        const totalMin = Math.floor(totalMs / 6e4);
+        const totalSec = Math.floor(totalMs % 6e4 / 1e3);
+        const passed = results.filter((r) => r.exitCode === 0).length;
+        const failed = results.filter((r) => r.exitCode !== 0).length;
+        const overallStatus = pipelineStopped ? "STOPPED" : failed > 0 ? "FAILED" : "SUCCESS";
+        const startedAt = new Date(pipelineStartTime).toISOString();
+        const completedAt = new Date(endTime).toISOString();
+        let rows = "";
+        for (let i = 0; i < results.length; i++) {
+          const r = results[i];
+          const status = r.exitCode === 0 ? "PASS" : "FAIL";
+          const durMin = Math.floor(r.durationMs / 6e4);
+          const durSec = Math.floor(r.durationMs % 6e4 / 1e3);
+          const retried = r.retried ? `Yes (${r.attempts})` : "No";
+          rows += `| ${i + 1} | ${r.actionId} | ${r.milestoneId} | ${status} | ${durMin}m ${durSec}s | ${retried} |
+`;
+        }
+        const report = `# Execution Report
+
+**Status:** ${overallStatus}
 **Started:** ${startedAt}
 **Completed:** ${completedAt}
 **Duration:** ${totalMin}m ${totalSec}s
@@ -5278,16 +5682,18 @@ ${rows}
         return null;
       }
     }
-    function createPipelineRunner(sseClients, cwd) {
+    function createPipelineRunner(sseClients, cwd, registry) {
       let isRunning = false;
       let stopRequested = false;
-      const activeProcesses = /* @__PURE__ */ new Map();
+      const activeControllers = /* @__PURE__ */ new Map();
       let results = [];
       let pipelineState = null;
       let pausedOnFailure = null;
       let skipResolve = null;
       const outputBuffers = {};
       let totalActionCount = 0;
+      let pipelineAgentId;
+      const actionAgentIds = /* @__PURE__ */ new Map();
       function persistState() {
         if (!pipelineState) {
           try {
@@ -5304,7 +5710,7 @@ ${rows}
           completedActions: pipelineState.completedActions,
           failedActions: pipelineState.failedActions,
           stoppedActions: pipelineState.stoppedActions,
-          activeActions: [...activeProcesses.keys()],
+          activeActions: [...activeControllers.keys()],
           outputBuffers,
           pausedOnFailure,
           timestamp: Date.now()
@@ -5359,78 +5765,75 @@ data: ${JSON.stringify(data)}
         }
       }
       function executeAction(actionId, milestoneId) {
-        return new Promise((resolve) => {
-          const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-          const startTime = Date.now();
-          const prompt = `Run /declare:execute ${milestoneId} for action ${actionId} only. Do not ask questions, execute autonomously.`;
-          const spawnEnv = { ...process.env, FORCE_COLOR: "0" };
-          delete spawnEnv.CLAUDECODE;
-          const proc = spawn("claude", ["-p", prompt], {
-            cwd,
-            env: spawnEnv
-          });
-          activeProcesses.set(actionId, proc);
-          const planningDir = path.join(cwd, ".planning");
-          const milestoneFolder = findMilestoneFolder(planningDir, milestoneId);
-          const logPath = milestoneFolder ? path.join(milestoneFolder, "execution.log") : void 0;
-          appendLog(logPath, `
+        const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const startTime = Date.now();
+        if (registry) {
+          const agent = registry.spawn("execution", actionId, milestoneId);
+          actionAgentIds.set(actionId, agent.id);
+        }
+        const prompt = `Run /declare:execute ${milestoneId} for action ${actionId} only. Do not ask questions, execute autonomously.`;
+        const abortController = new AbortController();
+        activeControllers.set(actionId, abortController);
+        const planningDir = path.join(cwd, ".planning");
+        const milestoneFolder = findMilestoneFolder(planningDir, milestoneId);
+        const logPath = milestoneFolder ? path.join(milestoneFolder, "execution.log") : void 0;
+        appendLog(logPath, `
 === START ${actionId} (pipeline) @ ${startedAt} ===`);
-          let stdoutBuf = "";
-          let stderrBuf = "";
-          let stderrFull = "";
-          if (proc.stdout) {
-            proc.stdout.on("data", (chunk) => {
-              stdoutBuf += chunk.toString();
-              const lines = stdoutBuf.split("\n");
-              stdoutBuf = lines.pop() || "";
-              for (const line of lines) {
-                broadcast("action-output", { actionId, text: line, stream: "stdout" });
-                appendLog(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] [${actionId}] [stdout] ${line}`);
-                if (!outputBuffers[actionId]) outputBuffers[actionId] = "";
-                outputBuffers[actionId] += line + "\n";
-                if (outputBuffers[actionId].length > OUTPUT_BUFFER_MAX) {
-                  outputBuffers[actionId] = outputBuffers[actionId].slice(-OUTPUT_BUFFER_MAX);
-                }
-              }
-            });
+        return runAI(prompt, {
+          cwd,
+          model: "sonnet",
+          withTools: true,
+          maxTurns: 10,
+          abortController,
+          onText: (chunk) => {
+            broadcast("action-output", { actionId, text: chunk, stream: "stdout" });
+            appendLog(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] [${actionId}] [stdout] ${chunk}`);
+            if (!outputBuffers[actionId]) outputBuffers[actionId] = "";
+            outputBuffers[actionId] += chunk;
+            if (outputBuffers[actionId].length > OUTPUT_BUFFER_MAX) {
+              outputBuffers[actionId] = outputBuffers[actionId].slice(-OUTPUT_BUFFER_MAX);
+            }
           }
-          if (proc.stderr) {
-            proc.stderr.on("data", (chunk) => {
-              const text = chunk.toString();
-              stderrFull += text;
-              stderrBuf += text;
-              const lines = stderrBuf.split("\n");
-              stderrBuf = lines.pop() || "";
-              for (const line of lines) {
-                broadcast("action-output", { actionId, text: line, stream: "stderr" });
-                appendLog(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] [${actionId}] [stderr] ${line}`);
-                if (!outputBuffers[actionId]) outputBuffers[actionId] = "";
-                outputBuffers[actionId] += line + "\n";
-                if (outputBuffers[actionId].length > OUTPUT_BUFFER_MAX) {
-                  outputBuffers[actionId] = outputBuffers[actionId].slice(-OUTPUT_BUFFER_MAX);
-                }
+        }).then(({ text, error }) => {
+          const exitCode = error ? 1 : 0;
+          const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          const durationMs = Date.now() - startTime;
+          appendLog(logPath, `=== END ${actionId} (pipeline) @ ${completedAt} exit=${exitCode} duration=${durationMs}ms ===
+`);
+          activeControllers.delete(actionId);
+          broadcast("action-complete", { actionId, exitCode, durationMs });
+          if (registry) {
+            const aId = actionAgentIds.get(actionId);
+            if (aId) {
+              if (exitCode === 0) {
+                registry.complete(aId, {
+                  actionId,
+                  milestoneId,
+                  logPath: logPath || null,
+                  durationMs
+                });
+              } else {
+                registry.fail(aId, exitCode, error || "execution failed");
               }
-            });
+              actionAgentIds.delete(actionId);
+            }
           }
-          proc.on("close", (exitCode) => {
-            const code = exitCode ?? -1;
-            const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-            const durationMs = Date.now() - startTime;
-            appendLog(logPath, `=== END ${actionId} (pipeline) @ ${completedAt} exit=${code} duration=${durationMs}ms ===
-`);
-            activeProcesses.delete(actionId);
-            broadcast("action-complete", { actionId, exitCode: code, durationMs });
-            resolve({ actionId, milestoneId, exitCode: code, stderrOutput: stderrFull, durationMs, startedAt, completedAt, retried: false, attempts: 1 });
-          });
-          proc.on("error", (_err) => {
-            const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-            const durationMs = Date.now() - startTime;
-            appendLog(logPath, `=== ERROR ${actionId} (pipeline) @ ${completedAt} ===
+          return { actionId, milestoneId, exitCode, errorOutput: error || "", durationMs, startedAt, completedAt, retried: false, attempts: 1 };
+        }).catch((err) => {
+          const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          const durationMs = Date.now() - startTime;
+          appendLog(logPath, `=== ERROR ${actionId} (pipeline) @ ${completedAt} ===
 `);
-            activeProcesses.delete(actionId);
-            broadcast("action-complete", { actionId, exitCode: -1, durationMs });
-            resolve({ actionId, milestoneId, exitCode: -1, stderrOutput: stderrFull, durationMs, startedAt, completedAt, retried: false, attempts: 1 });
-          });
+          activeControllers.delete(actionId);
+          broadcast("action-complete", { actionId, exitCode: -1, durationMs });
+          if (registry) {
+            const aId = actionAgentIds.get(actionId);
+            if (aId) {
+              registry.fail(aId, -1, String(err.message || err));
+              actionAgentIds.delete(actionId);
+            }
+          }
+          return { actionId, milestoneId, exitCode: -1, errorOutput: String(err.message || err), durationMs, startedAt, completedAt, retried: false, attempts: 1 };
         });
       }
       function start() {
@@ -5445,6 +5848,10 @@ data: ${JSON.stringify(data)}
         isRunning = true;
         stopRequested = false;
         results = [];
+        if (registry) {
+          const agent = registry.spawn("pipeline", "manifest", "");
+          pipelineAgentId = agent.id;
+        }
         pipelineState = {
           currentWave: 0,
           totalWaves: waves.length,
@@ -5497,7 +5904,7 @@ data: ${JSON.stringify(data)}
             const waveResults = await Promise.all(promises);
             for (let ri = 0; ri < waveResults.length; ri++) {
               const r = waveResults[ri];
-              if (r.exitCode !== 0 && !stopRequested && isTransientFailure(r.exitCode, r.stderrOutput)) {
+              if (r.exitCode !== 0 && !stopRequested && isTransientFailure(r.exitCode, r.errorOutput)) {
                 broadcast("action-retry", { actionId: r.actionId, milestoneId: r.milestoneId, attempt: 2, reason: "transient failure detected" });
                 appendLog(
                   findMilestoneFolder(path.join(cwd, ".planning"), r.milestoneId) ? path.join(findMilestoneFolder(path.join(cwd, ".planning"), r.milestoneId), "execution.log") : void 0,
@@ -5557,7 +5964,7 @@ data: ${JSON.stringify(data)}
           const finalResults = [...results];
           isRunning = false;
           if (stopRequested) {
-            for (const actionId of activeProcesses.keys()) {
+            for (const actionId of activeControllers.keys()) {
               finalState.stoppedActions.push(actionId);
             }
           }
@@ -5572,6 +5979,19 @@ data: ${JSON.stringify(data)}
             results: finalResults,
             reportPath: reportPath ? ".planning/execution-report.md" : null
           });
+          if (registry && pipelineAgentId) {
+            const failed = finalState.failedActions.length;
+            if (failed === 0 && !stopRequested) {
+              registry.complete(pipelineAgentId, {
+                completed: finalState.completedActions.length,
+                failed: 0,
+                reportPath: reportPath ? ".planning/execution-report.md" : null
+              });
+            } else {
+              registry.fail(pipelineAgentId, 1, stopRequested ? "stopped by user" : `${failed} action(s) failed`);
+            }
+            pipelineAgentId = void 0;
+          }
           stopRequested = false;
           pausedOnFailure = null;
           pipelineState = null;
@@ -5581,6 +6001,10 @@ data: ${JSON.stringify(data)}
           pausedOnFailure = null;
           pipelineState = null;
           persistState();
+          if (registry && pipelineAgentId) {
+            registry.fail(pipelineAgentId, -1, String(_err));
+            pipelineAgentId = void 0;
+          }
           broadcast("pipeline-complete", {
             completed: [],
             failed: [],
@@ -5600,11 +6024,18 @@ data: ${JSON.stringify(data)}
           skipResolve("stop");
           skipResolve = null;
         }
-        for (const [, proc] of activeProcesses) {
+        for (const [actionId, controller] of activeControllers) {
           try {
-            proc.kill("SIGTERM");
+            controller.abort();
           } catch (_) {
           }
+          if (registry) {
+            const aId = actionAgentIds.get(actionId);
+            if (aId) {
+              registry.fail(aId, -1, "stopped by user");
+              actionAgentIds.delete(actionId);
+            }
+          }
         }
         persistState();
         return { ok: true };
@@ -5618,7 +6049,7 @@ data: ${JSON.stringify(data)}
           running: isRunning,
           currentWave: pipelineState.currentWave,
           totalWaves: pipelineState.totalWaves,
-          activeActions: [...activeProcesses.keys()],
+          activeActions: [...activeControllers.keys()],
           completedActions: pipelineState.completedActions,
           failedActions: pipelineState.failedActions,
           results
@@ -5646,7 +6077,7 @@ data: ${JSON.stringify(data)}
           totalActions: totalActionCount,
           completedActions: pipelineState ? pipelineState.completedActions : [],
           failedActions: pipelineState ? pipelineState.failedActions : [],
-          activeActions: [...activeProcesses.keys()],
+          activeActions: [...activeControllers.keys()],
           outputBuffers,
           pausedOnFailure
         };
@@ -5657,6 +6088,201 @@ data: ${JSON.stringify(data)}
   }
 });
 
+// src/server/agent-registry.js
+var require_agent_registry = __commonJS({
+  "src/server/agent-registry.js"(exports2, module2) {
+    "use strict";
+    var fs = require("node:fs");
+    var path = require("node:path");
+    var RECENT_MAX = 50;
+    var RECENT_MAX_AGE_MS = 30 * 60 * 1e3;
+    function createAgentRegistry(cwd, broadcastFn) {
+      const agents = /* @__PURE__ */ new Map();
+      let recentAgents = [];
+      const statePath = path.join(cwd, ".planning", "agent-state.json");
+      function pruneRecent() {
+        const cutoff = Date.now() - RECENT_MAX_AGE_MS;
+        recentAgents = recentAgents.filter((a) => {
+          const ts = a.completedAt || a.updatedAt;
+          return new Date(ts).getTime() > cutoff;
+        });
+      }
+      function moveToRecent(agentId) {
+        const record = agents.get(agentId);
+        if (!record) return;
+        agents.delete(agentId);
+        recentAgents.push(record);
+        if (recentAgents.length > RECENT_MAX) {
+          recentAgents = recentAgents.slice(recentAgents.length - RECENT_MAX);
+        }
+      }
+      function persistState() {
+        try {
+          const state = {
+            agents: Object.fromEntries(agents),
+            recentAgents,
+            persistedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          fs.writeFileSync(statePath, JSON.stringify(state, null, 2), "utf-8");
+        } catch (_) {
+        }
+      }
+      function spawn(type, target, milestoneId) {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const id = `${type.slice(0, 4)}-${target}-${Date.now()}`;
+        const record = {
+          id,
+          type,
+          target,
+          milestoneId: milestoneId || "",
+          status: "running",
+          startedAt: now,
+          updatedAt: now,
+          completedAt: null,
+          exitCode: null,
+          error: null,
+          result: null
+        };
+        agents.set(id, record);
+        broadcastFn("agent-start", record);
+        persistState();
+        return record;
+      }
+      function update(agentId, patch) {
+        const record = agents.get(agentId);
+        if (!record) return null;
+        Object.assign(record, patch, { updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+        broadcastFn("agent-update", record);
+        persistState();
+        return record;
+      }
+      function complete(agentId, result) {
+        const record = agents.get(agentId);
+        if (!record) return null;
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        record.status = "complete";
+        record.completedAt = now;
+        record.updatedAt = now;
+        record.exitCode = 0;
+        record.result = result;
+        moveToRecent(agentId);
+        broadcastFn("agent-complete", record);
+        persistState();
+        return record;
+      }
+      function fail(agentId, exitCode, errorMessage) {
+        const record = agents.get(agentId);
+        if (!record) return null;
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        record.status = "failed";
+        record.completedAt = now;
+        record.updatedAt = now;
+        record.exitCode = exitCode;
+        record.error = errorMessage;
+        moveToRecent(agentId);
+        broadcastFn("agent-complete", record);
+        persistState();
+        return record;
+      }
+      function get(agentId) {
+        const active = agents.get(agentId);
+        if (active) return active;
+        return recentAgents.find((a) => a.id === agentId) || null;
+      }
+      function getActive() {
+        return [...agents.values()];
+      }
+      function getRecent(limit = 20) {
+        pruneRecent();
+        return recentAgents.slice(-limit);
+      }
+      function getAll() {
+        return { active: getActive(), recent: getRecent() };
+      }
+      function markInterrupted(agentIds) {
+        for (const id of agentIds) {
+          const record = agents.get(id);
+          if (!record) continue;
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          record.status = "interrupted";
+          record.completedAt = now;
+          record.updatedAt = now;
+          moveToRecent(id);
+        }
+        persistState();
+      }
+      function loadFromDisk() {
+        try {
+          const raw = fs.readFileSync(statePath, "utf-8");
+          return JSON.parse(raw);
+        } catch (_) {
+          return null;
+        }
+      }
+      function restoreFromDisk() {
+        const persisted = loadFromDisk();
+        if (!persisted) return { restored: 0, interrupted: 0 };
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        let interruptedCount = 0;
+        const seenIds = new Set(recentAgents.map((a) => a.id));
+        const persistedAgents = persisted.agents || {};
+        for (const [id, record] of Object.entries(persistedAgents)) {
+          if (seenIds.has(id)) continue;
+          record.status = "interrupted";
+          record.completedAt = now;
+          record.updatedAt = now;
+          record.exitCode = -1;
+          record.error = "server restarted";
+          recentAgents.push(record);
+          seenIds.add(id);
+          interruptedCount++;
+        }
+        const cutoff = Date.now() - RECENT_MAX_AGE_MS;
+        const persistedRecent = persisted.recentAgents || [];
+        for (const record of persistedRecent) {
+          if (seenIds.has(record.id)) continue;
+          const ts = record.completedAt || record.updatedAt;
+          if (new Date(ts).getTime() <= cutoff) continue;
+          recentAgents.push(record);
+          seenIds.add(record.id);
+        }
+        if (recentAgents.length > RECENT_MAX) {
+          recentAgents = recentAgents.slice(recentAgents.length - RECENT_MAX);
+        }
+        persistState();
+        return { restored: recentAgents.length, interrupted: interruptedCount };
+      }
+      return {
+        spawn,
+        update,
+        complete,
+        fail,
+        get,
+        getActive,
+        getRecent,
+        getAll,
+        markInterrupted,
+        loadFromDisk,
+        restoreFromDisk
+      };
+    }
+    if (require.main === module2) {
+      const reg = createAgentRegistry(".", () => {
+      });
+      const a = reg.spawn("execution", "A-01", "M-01");
+      console.log("spawned:", a.id, a.status);
+      reg.complete(a.id, { path: "test.md" });
+      console.log("completed:", reg.get(a.id).status);
+      console.log("active:", reg.getActive().length);
+      console.log("recent:", reg.getRecent().length);
+      const restored = reg.restoreFromDisk();
+      console.log("restored:", restored.restored, "interrupted:", restored.interrupted);
+      console.log("OK");
+    }
+    module2.exports = { createAgentRegistry };
+  }
+});
+
 // src/server/index.js
 var require_server = __commonJS({
   "src/server/index.js"(exports2, module2) {
@@ -5685,7 +6311,9 @@ var require_server = __commonJS({
     var { computeWorkflowState } = require_workflow_state();
     var { createPlayRunner } = require_play();
     var { computeReadiness } = require_readiness();
+    var { computeLifecycleStages } = require_lifecycle_stages();
     var { createPipelineRunner } = require_pipeline_runner();
+    var { createAgentRegistry } = require_agent_registry();
     var MIME_TYPES = {
       ".html": "text/html; charset=utf-8",
       ".js": "application/javascript; charset=utf-8",
@@ -5867,6 +6495,21 @@ var require_server = __commonJS({
         sendJson(res, 500, { error: String(err) });
       }
     }
+    function handleLifecycle(res, cwd) {
+      try {
+        const graph = runLoadGraph2(cwd);
+        if ("error" in graph) {
+          sendJson(res, 500, { error: graph.error });
+          return;
+        }
+        const pm = getProcessManager(cwd);
+        const runningIds = new Set(pm.running());
+        const result = computeLifecycleStages(graph, runningIds);
+        sendJson(res, 200, result);
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
     async function handleSaveManifest(req, res, cwd) {
       try {
         const body = await readJsonBody(req);
@@ -5977,25 +6620,38 @@ var require_server = __commonJS({
     }
     function handleExecuteAction(res, cwd, actionId) {
       try {
-        const result = runGetExecPlan2(cwd, ["--action", actionId]);
-        if (result.error || !result.execPlan) {
-          sendJson(res, 400, { error: "Action not found or no exec-plan" });
+        const graph = runLoadGraph2(cwd);
+        if ("error" in graph) {
+          sendJson(res, 500, { error: graph.error });
           return;
         }
-        const graph = runLoadGraph2(cwd);
-        if (!("error" in graph)) {
-          const normalizedId = actionId.toUpperCase();
-          const action = graph.actions.find((a) => a.id.toUpperCase() === normalizedId);
-          if (action && action.reviewState !== "approved") {
-            sendJson(res, 403, {
-              error: "Action not approved for execution",
-              unapproved: [{ id: action.id, title: action.title, reviewState: action.reviewState || "draft" }]
-            });
-            return;
-          }
+        const normalizedId = actionId.toUpperCase();
+        const action = graph.actions.find((a) => a.id.toUpperCase() === normalizedId);
+        if (!action) {
+          sendJson(res, 404, { error: "Action not found" });
+          return;
+        }
+        if (action.reviewState !== "approved") {
+          sendJson(res, 403, {
+            error: "Action not approved for execution",
+            unapproved: [{ id: action.id, title: action.title, reviewState: action.reviewState || "draft" }]
+          });
+          return;
         }
+        const milestoneId = (action.causes || []).find((c) => c.startsWith("M-")) || (action.causes || [])[0] || actionId;
+        const milestone = graph.milestones.find((m) => m.id === milestoneId);
+        const declaration = milestone ? (graph.declarations || []).find((d) => (milestone.realizes || []).includes(d.id)) : null;
+        const siblingActions = graph.actions.filter(
+          (a) => a.id !== action.id && (a.causes || []).includes(milestoneId)
+        );
+        const actionContext = {
+          action: { id: action.id, title: action.title, produces: action.produces || "", status: action.status },
+          milestone: milestone ? { id: milestone.id, title: milestone.title, description: milestone.description || "" } : null,
+          declaration: declaration ? { id: declaration.id, statement: declaration.statement || declaration.title || "" } : null,
+          siblingActions: siblingActions.map((a) => ({ id: a.id, title: a.title, produces: a.produces || "", status: a.status }))
+        };
         const pm = getProcessManager(cwd);
-        const execResult = pm.execute(actionId, result.milestoneId);
+        const execResult = pm.execute(actionId, milestoneId, actionContext);
         if (execResult.error) {
           sendJson(res, execResult.status || 500, { error: execResult.error });
           return;
@@ -6019,24 +6675,35 @@ var require_server = __commonJS({
           milestones: d.milestones || []
         }));
         const dr = getDerivationRunner(cwd);
-        const result = dr.derive(body.declarationId || null, declarations);
+        const declarationId = body.declarationId || null;
+        const result = dr.derive(declarationId, declarations);
         if (result.error) {
           sendJson(res, result.status || 500, { error: result.error });
           return;
         }
-        sendJson(res, 202, { ok: true, sessionId: result.sessionId });
+        sendJson(res, 202, { ok: true, sessionId: result.sessionId, declarationId });
       } catch (err) {
         sendJson(res, 400, { error: String(err) });
       }
     }
-    function handleDeriveStop(res, cwd) {
+    function handleDeriveStop(req, res, cwd) {
       const dr = getDerivationRunner(cwd);
-      const result = dr.stop();
-      if (result.error) {
-        sendJson(res, result.status || 500, { error: result.error });
-      } else {
-        sendJson(res, 200, { ok: true });
-      }
+      let sessionId;
+      const chunks = [];
+      req.on("data", (c) => chunks.push(c));
+      req.on("end", () => {
+        try {
+          const body = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+          sessionId = body.sessionId;
+        } catch (_) {
+        }
+        const result = dr.stop(sessionId);
+        if (result.error) {
+          sendJson(res, result.status || 500, { error: result.error });
+        } else {
+          sendJson(res, 200, { ok: true });
+        }
+      });
     }
     async function handleDeriveAccept(req, res, cwd) {
       try {
@@ -6056,6 +6723,36 @@ var require_server = __commonJS({
         sendJson(res, 400, { error: String(err) });
       }
     }
+    function handleDeriveAll(res, cwd) {
+      try {
+        const graph = runLoadGraph2(cwd);
+        if ("error" in graph) {
+          sendJson(res, 500, { error: graph.error });
+          return;
+        }
+        const declarations = graph.declarations.map((d) => ({
+          id: d.id,
+          statement: d.statement,
+          milestones: d.milestones || []
+        }));
+        const needsPlanning = declarations.filter((d) => !d.milestones || d.milestones.length === 0);
+        if (needsPlanning.length === 0) {
+          sendJson(res, 200, { ok: true, sessions: [], message: "All declarations already have milestones" });
+          return;
+        }
+        const dr = getDerivationRunner(cwd);
+        const results = [];
+        for (const decl of needsPlanning) {
+          const result = dr.derive(decl.id, declarations);
+          if (result.ok) {
+            results.push({ declarationId: decl.id, sessionId: result.sessionId });
+          }
+        }
+        sendJson(res, 202, { ok: true, sessions: results });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
     function handleActionDerive(res, cwd, milestoneId) {
       try {
         const graph = runLoadGraph2(cwd);
@@ -6360,19 +7057,38 @@ var require_server = __commonJS({
       }
     }
     var sseClients = /* @__PURE__ */ new Set();
+    var agentRegistry = null;
+    function getAgentRegistry(cwd) {
+      if (!agentRegistry) {
+        agentRegistry = createAgentRegistry(cwd, (event, data) => {
+          const payload = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+          for (const client of sseClients) {
+            try {
+              client.write(payload);
+            } catch (_) {
+              sseClients.delete(client);
+            }
+          }
+        });
+      }
+      return agentRegistry;
+    }
     var processManager = null;
     function getProcessManager(cwd) {
-      if (!processManager) processManager = createProcessManager(sseClients, cwd);
+      if (!processManager) processManager = createProcessManager(sseClients, cwd, getAgentRegistry(cwd));
       return processManager;
     }
     var derivationRunner = null;
     function getDerivationRunner(cwd) {
-      if (!derivationRunner) derivationRunner = createDerivationRunner(sseClients, cwd);
+      if (!derivationRunner) derivationRunner = createDerivationRunner(sseClients, cwd, getAgentRegistry(cwd));
       return derivationRunner;
     }
     var actionDerivationRunner = null;
     function getActionDerivationRunner(cwd) {
-      if (!actionDerivationRunner) actionDerivationRunner = createActionDerivationRunner(sseClients, cwd);
+      if (!actionDerivationRunner) actionDerivationRunner = createActionDerivationRunner(sseClients, cwd, getAgentRegistry(cwd));
       return actionDerivationRunner;
     }
     var playRunner = null;
@@ -6382,7 +7098,7 @@ var require_server = __commonJS({
     }
     var pipelineRunnerInstance = null;
     function getPipelineRunner(cwd) {
-      if (!pipelineRunnerInstance) pipelineRunnerInstance = createPipelineRunner(sseClients, cwd);
+      if (!pipelineRunnerInstance) pipelineRunnerInstance = createPipelineRunner(sseClients, cwd, getAgentRegistry(cwd));
       return pipelineRunnerInstance;
     }
     var revisionRunner = null;
@@ -6391,7 +7107,7 @@ var require_server = __commonJS({
         revisionRunner = createRevisionRunner(sseClients, cwd, (nodeId) => {
           setReviewState(cwd, nodeId, "in_review");
           broadcastChange();
-        });
+        }, getAgentRegistry(cwd));
       }
       return revisionRunner;
     }
@@ -6546,7 +7262,7 @@ var require_server = __commonJS({
         sendJson(res, 200, { ok: true });
       }
     }
-    var refineSession = null;
+    var refineSessions = /* @__PURE__ */ new Map();
     function buildRefinePrompt(nodeId, graph, mode, userMessage) {
       const id = nodeId.toUpperCase();
       const prefix = id.split("-")[0];
@@ -6586,99 +7302,772 @@ Produces: ${m.produces || "(none)"}`).join("\n\n");
         const siblingActions = graph.actions.filter((a) => a.id !== action.id && (a.causes || []).some((c) => milestoneIds.includes(c)));
         siblingsContent = siblingActions.map((a) => `${a.id}: ${a.title} [${a.status}]`).join("\n");
       }
-      const modeInstructions = {
-        write: `The user wants to refine this ${nodeType} with specific direction:
-
-"${userMessage || ""}"
-
-Apply their feedback to improve the title and statement/produces. Keep the same format and scope level.`,
-        outdated: `Check if this ${nodeType} is still relevant given the current state of its parent and siblings. Some siblings may already be DONE. Consider:
-- Has progress on siblings made this redundant?
-- Does the title/statement still accurately describe what's needed?
-- Should this be reworded to reflect current reality?`,
-        sharpen: `Make this ${nodeType} more specific and actionable. Consider:
-- Is the title vague or generic? Make it concrete.
-- Does the statement/produces describe a clear, verifiable outcome?
-- Could someone read this and know exactly what "done" looks like?`,
-        consolidate: `Check if this ${nodeType} overlaps with its siblings. Consider:
-- Are any siblings covering the same ground?
-- Could this be merged with a sibling for clarity?
-- Is this a subset of another sibling?
-
-If overlap exists, suggest how to differentiate or merge. If no overlap, say so.`,
-        expand: `This ${nodeType} may be too broad. Consider:
-- Could it be broken into 2-3 more specific items?
-- Are there implicit sub-tasks hiding in the description?
-- Would splitting improve clarity and trackability?
-
-Suggest a breakdown if warranted. If it's already well-scoped, say so.`
-      };
-      const taskBlock = modeInstructions[mode] || `Analyze this ${nodeType} in the context of its parent and siblings. Consider:
-- Is it well-scoped? Too broad or too narrow compared to siblings?
-- Does it overlap with any sibling?
-- Does it clearly contribute to its parent's goal?
-- Is the title/statement clear and specific?`;
-      return `You are reviewing a Declare project artifact and suggesting improvements.
-
-## This ${nodeType}
-
-${nodeContent}
-
-## Parent context
-
-${parentContent}
-
-## Sibling ${nodeType === "declaration" ? "declarations" : nodeType === "milestone" ? "milestones" : "actions"}
+      const modeInstructions = {
+        write: `The user wants to modify this ${nodeType} with specific direction:
+
+"${userMessage || ""}"
+
+You have tool access \u2014 directly edit the project files to apply the requested changes. The planning files are at:
+- ${nodeType === "declaration" ? "FUTURE.md" : nodeType === "milestone" ? "MILESTONES.md" : "the milestone PLAN.md"}
+- MILESTONES.md (for milestone references)
+- FUTURE-ARCHIVE.md (if archiving)
+
+Apply the changes directly. After making edits, summarize what you changed.`,
+        outdated: `Check if this ${nodeType} is still relevant given the current state of its parent and siblings. Some siblings may already be DONE. Consider:
+- Has progress on siblings made this redundant?
+- Does the title/statement still accurately describe what's needed?
+- Should this be reworded to reflect current reality?`,
+        sharpen: `Make this ${nodeType} more specific and actionable. Consider:
+- Is the title vague or generic? Make it concrete.
+- Does the statement/produces describe a clear, verifiable outcome?
+- Could someone read this and know exactly what "done" looks like?`,
+        consolidate: `Check if this ${nodeType} overlaps with its siblings. Consider:
+- Are any siblings covering the same ground?
+- Could this be merged with a sibling for clarity?
+- Is this a subset of another sibling?
+
+If overlap exists, suggest how to differentiate or merge. If no overlap, say so.`,
+        expand: `This ${nodeType} may be too broad. Consider:
+- Could it be broken into 2-3 more specific items?
+- Are there implicit sub-tasks hiding in the description?
+- Would splitting improve clarity and trackability?
+
+Suggest a breakdown if warranted. If it's already well-scoped, say so.`
+      };
+      const taskBlock = modeInstructions[mode] || `Analyze this ${nodeType} in the context of its parent and siblings. Consider:
+- Is it well-scoped? Too broad or too narrow compared to siblings?
+- Does it overlap with any sibling?
+- Does it clearly contribute to its parent's goal?
+- Is the title/statement clear and specific?`;
+      return `You are reviewing a Declare project artifact and suggesting improvements.
+
+## This ${nodeType}
+
+${nodeContent}
+
+## Parent context
+
+${parentContent}
+
+## Sibling ${nodeType === "declaration" ? "declarations" : nodeType === "milestone" ? "milestones" : "actions"}
+
+${siblingsContent || "(none)"}
+
+## Task
+
+${taskBlock}
+
+If improvements are possible, suggest a revised version. Output ONLY the improved text in this format:
+
+**Title:** <improved title>
+**Statement:** <improved statement or produces>
+**Reason:** <one sentence explaining why this is better>
+
+If the current version is already good, output exactly: LGTM \u2014 no changes needed.`;
+    }
+    async function handleRefine(req, res, cwd, nodeId) {
+      try {
+        const body = await readJsonBody(req).catch(() => ({}));
+        const mode = body.mode || "general";
+        const userMessage = body.message || "";
+        const graph = runLoadGraph2(cwd);
+        if ("error" in graph) {
+          sendJson(res, 500, { error: graph.error });
+          return;
+        }
+        const prompt = buildRefinePrompt(nodeId, graph, mode, userMessage);
+        if (!prompt) {
+          sendJson(res, 404, { error: "Node not found: " + nodeId });
+          return;
+        }
+        const sessionId = `refine-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        const { runAI } = require_ai_runner();
+        const activityFile = path.join(cwd, ".planning", "activity.jsonl");
+        const nId = nodeId.toUpperCase();
+        let refineAgentId;
+        try {
+          const reg = getAgentRegistry(cwd);
+          const agent = reg.spawn("refine", nId, nId);
+          refineAgentId = agent.id;
+        } catch (_) {
+        }
+        const abortController = new AbortController();
+        refineSessions.set(sessionId, { sessionId, nodeId: nId, suggestion: "", abortController, agentId: refineAgentId });
+        const isWriteMode = mode === "write";
+        runAI(prompt, {
+          cwd,
+          model: "haiku",
+          maxTurns: isWriteMode ? 10 : 1,
+          withTools: isWriteMode,
+          abortController,
+          onText: (text) => {
+            const session = refineSessions.get(sessionId);
+            if (session) session.suggestion += text;
+            const payload = `event: refine-output
+data: ${JSON.stringify({ sessionId, nodeId: nId, text })}
+
+`;
+            for (const client of sseClients) {
+              try {
+                client.write(payload);
+              } catch (_) {
+                sseClients.delete(client);
+              }
+            }
+          }
+        }).then(({ text, error }) => {
+          const session = refineSessions.get(sessionId);
+          const suggestion = text || (session ? session.suggestion : "");
+          refineSessions.delete(sessionId);
+          const exitCode = error ? 1 : 0;
+          const payload = `event: refine-complete
+data: ${JSON.stringify({ sessionId, nodeId: nId, exitCode, suggestion, error })}
+
+`;
+          for (const client of sseClients) {
+            try {
+              client.write(payload);
+            } catch (_) {
+              sseClients.delete(client);
+            }
+          }
+          if (refineAgentId) {
+            try {
+              const reg = getAgentRegistry(cwd);
+              if (!error) reg.complete(refineAgentId, { nodeId: nId });
+              else reg.fail(refineAgentId, 1, error);
+            } catch (_) {
+            }
+          }
+          const phase = error ? "error" : "done";
+          const desc = error ? `Review of ${nId} failed: ${error}` : `Review of ${nId} complete` + (suggestion.includes("LGTM") ? " \u2014 no changes needed" : " \u2014 suggestion ready");
+          try {
+            fs.appendFileSync(activityFile, JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Task", phase, agent: "Refine", desc }) + "\n");
+          } catch (_) {
+          }
+        }).catch((err) => {
+          refineSessions.delete(sessionId);
+          const payload = `event: refine-complete
+data: ${JSON.stringify({ sessionId, nodeId: nId, exitCode: 1, suggestion: "", error: String(err) })}
+
+`;
+          for (const client of sseClients) {
+            try {
+              client.write(payload);
+            } catch (_) {
+              sseClients.delete(client);
+            }
+          }
+          if (refineAgentId) {
+            try {
+              getAgentRegistry(cwd).fail(refineAgentId, 1, String(err));
+            } catch (_) {
+            }
+          }
+        });
+        const entry = { ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Task", phase: "start", agent: "Refine", desc: `Analyzing ${nodeId.toUpperCase()} for improvements` };
+        fs.appendFileSync(activityFile, JSON.stringify(entry) + "\n");
+        sendJson(res, 202, { ok: true, sessionId });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    function handleRefineStop(res, sessionId) {
+      if (sessionId) {
+        const session = refineSessions.get(sessionId);
+        if (!session) {
+          sendJson(res, 404, { error: "Session not found" });
+          return;
+        }
+        try {
+          session.abortController.abort();
+        } catch (_) {
+        }
+        refineSessions.delete(sessionId);
+        sendJson(res, 200, { ok: true });
+      } else {
+        for (const [id, session] of refineSessions) {
+          try {
+            session.abortController.abort();
+          } catch (_) {
+          }
+        }
+        refineSessions.clear();
+        sendJson(res, 200, { ok: true });
+      }
+    }
+    async function handleRefineAccept(req, res, cwd) {
+      try {
+        const body = await readJsonBody(req);
+        const { nodeId, title, statement } = body;
+        if (!nodeId) {
+          sendJson(res, 400, { error: "Missing nodeId" });
+          return;
+        }
+        const id = nodeId.toUpperCase();
+        const prefix = id.split("-")[0];
+        const planningDir = path.join(cwd, ".planning");
+        if (prefix === "D") {
+          const futurePath = path.join(planningDir, "FUTURE.md");
+          const content = fs.readFileSync(futurePath, "utf-8");
+          const declarations = parseFutureFile(content);
+          const decl = declarations.find((d) => d.id === id);
+          if (decl) {
+            if (title) decl.title = title;
+            if (statement) decl.statement = statement;
+            const projectNameMatch = content.match(/^# Future:\\s*(.+)/m);
+            const projectName = projectNameMatch ? projectNameMatch[1].trim() : "Project";
+            fs.writeFileSync(futurePath, writeFutureFile(declarations, projectName), "utf-8");
+          }
+        } else if (prefix === "M") {
+          const msPath = path.join(planningDir, "MILESTONES.md");
+          const content = fs.readFileSync(msPath, "utf-8");
+          const { milestones } = parseMilestonesFile(content);
+          const mile = milestones.find((m) => m.id === id);
+          if (mile && title) {
+            mile.title = title;
+            const projectNameMatch = content.match(/^# Milestones:\\s*(.+)/m);
+            const projectName = projectNameMatch ? projectNameMatch[1].trim() : "Project";
+            fs.writeFileSync(msPath, writeMilestonesFile(milestones, projectName), "utf-8");
+          }
+        }
+        const activityFile = path.join(cwd, ".planning", "activity.jsonl");
+        const entry = { ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Review", phase: "end", desc: `Refined ${id}`, nodeId: id, reviewState: "approved" };
+        fs.appendFileSync(activityFile, JSON.stringify(entry) + "\n");
+        sendJson(res, 200, { ok: true });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    var discussSession = null;
+    async function handleDiscuss(req, res, cwd, nodeId) {
+      try {
+        if (discussSession) {
+          sendJson(res, 409, { error: "A discuss session is already running" });
+          return;
+        }
+        const graph = runLoadGraph2(cwd);
+        if ("error" in graph) {
+          sendJson(res, 500, { error: graph.error });
+          return;
+        }
+        const id = nodeId.toUpperCase();
+        const prefix = id.split("-")[0];
+        let nodeContext = "";
+        if (prefix === "D") {
+          const decl = graph.declarations.find((d) => d.id === id);
+          if (!decl) {
+            sendJson(res, 404, { error: "Declaration not found" });
+            return;
+          }
+          nodeContext = `Declaration ${decl.id}: ${decl.title}
+Statement: ${decl.statement || decl.title}`;
+          const myMiles = graph.milestones.filter((m) => (m.realizes || []).includes(id));
+          if (myMiles.length > 0) {
+            nodeContext += "\n\nExisting milestones:\n" + myMiles.map((m) => `- ${m.id}: ${m.title}`).join("\n");
+          }
+        } else if (prefix === "M") {
+          const mile = graph.milestones.find((m) => m.id === id);
+          if (!mile) {
+            sendJson(res, 404, { error: "Milestone not found" });
+            return;
+          }
+          nodeContext = `Milestone ${mile.id}: ${mile.title}`;
+          const myActions = graph.actions.filter((a) => (a.causes || []).includes(id));
+          if (myActions.length > 0) {
+            nodeContext += "\n\nExisting actions:\n" + myActions.map((a) => `- ${a.id}: ${a.title}`).join("\n");
+          }
+        }
+        const prompt = `You are helping a user plan their software project. You need to identify gray areas and ambiguities that should be resolved BEFORE creating detailed plans.
+
+Given this project artifact:
+
+${nodeContext}
+
+Identify 3-5 important questions that should be answered to avoid wasted work. Focus on:
+- Ambiguous scope (what's included vs excluded?)
+- Technical decisions that affect the plan
+- Dependencies or constraints not mentioned
+- Success criteria that need clarification
+
+Output ONLY a JSON array of question objects:
+[{"question": "The question text", "context": "Why this matters", "options": ["Option A", "Option B"]}]
+
+The options array is optional \u2014 include it only when there are clear alternatives to choose from.`;
+        const sessionId = `discuss-${Date.now()}`;
+        const { runAI } = require_ai_runner();
+        const activityFile = path.join(cwd, ".planning", "activity.jsonl");
+        let agentId;
+        try {
+          const reg = getAgentRegistry(cwd);
+          const agent = reg.spawn("discuss", id, id);
+          agentId = agent.id;
+        } catch (_) {
+        }
+        const abortController = new AbortController();
+        discussSession = { sessionId, nodeId: id, abortController, agentId };
+        runAI(prompt, {
+          cwd,
+          model: "haiku",
+          maxTurns: 1,
+          abortController,
+          onText: (text) => {
+            const payload = `event: discuss-output
+data: ${JSON.stringify({ sessionId, nodeId: id, text })}
+
+`;
+            for (const client of sseClients) {
+              try {
+                client.write(payload);
+              } catch (_) {
+                sseClients.delete(client);
+              }
+            }
+          }
+        }).then(({ text, error }) => {
+          const closingSession = discussSession;
+          discussSession = null;
+          let questions = null;
+          if (!error && text) {
+            try {
+              questions = JSON.parse(text.trim());
+            } catch (_) {
+              const jsonMatch = text.match(/\[[\s\S]*\]/);
+              if (jsonMatch) {
+                try {
+                  questions = JSON.parse(jsonMatch[0]);
+                } catch (_2) {
+                }
+              }
+            }
+          }
+          const payload = `event: discuss-complete
+data: ${JSON.stringify({ sessionId, nodeId: id, questions, error })}
+
+`;
+          for (const client of sseClients) {
+            try {
+              client.write(payload);
+            } catch (_) {
+              sseClients.delete(client);
+            }
+          }
+          if (closingSession && closingSession.agentId) {
+            try {
+              const reg = getAgentRegistry(cwd);
+              if (!error) reg.complete(closingSession.agentId, { nodeId: id, questionCount: Array.isArray(questions) ? questions.length : 0 });
+              else reg.fail(closingSession.agentId, 1, error);
+            } catch (_) {
+            }
+          }
+          const phase = error ? "error" : "done";
+          const desc = error ? `Discuss ${id} failed: ${error}` : `Discuss ${id}: ${Array.isArray(questions) ? questions.length : 0} questions`;
+          try {
+            fs.appendFileSync(activityFile, JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Task", phase, agent: "Discuss", desc }) + "\n");
+          } catch (_) {
+          }
+        }).catch((err) => {
+          discussSession = null;
+          if (agentId) {
+            try {
+              getAgentRegistry(cwd).fail(agentId, 1, String(err));
+            } catch (_) {
+            }
+          }
+        });
+        try {
+          fs.appendFileSync(activityFile, JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Task", phase: "start", agent: "Discuss", desc: `Analyzing ${id} for discussion` }) + "\n");
+        } catch (_) {
+        }
+        sendJson(res, 202, { ok: true, sessionId });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    async function handleDiscussAnswer(req, res, cwd, nodeId) {
+      try {
+        const body = await readJsonBody(req);
+        const answers = body.answers;
+        if (!Array.isArray(answers) || answers.length === 0) {
+          sendJson(res, 400, { error: "Missing answers array" });
+          return;
+        }
+        const id = nodeId.toUpperCase();
+        const prefix = id.split("-")[0];
+        const planningDir = path.join(cwd, ".planning");
+        let contextContent = `# Context: ${id}
+
+`;
+        contextContent += `Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+`;
+        for (const item of answers) {
+          contextContent += `## ${item.question}
+
+${item.answer}
+
+`;
+        }
+        if (prefix === "M") {
+          const { ensureMilestoneFolder } = require_milestone_folders();
+          const graph = runLoadGraph2(cwd);
+          if ("error" in graph) {
+            sendJson(res, 500, { error: graph.error });
+            return;
+          }
+          const milestone = graph.milestones.find((m) => m.id === id);
+          if (!milestone) {
+            sendJson(res, 404, { error: "Milestone not found" });
+            return;
+          }
+          const folder = ensureMilestoneFolder(planningDir, milestone.id, milestone.title);
+          const contextPath = path.join(folder, "CONTEXT.md");
+          fs.writeFileSync(contextPath, contextContent, "utf-8");
+        } else {
+          const contextPath = path.join(planningDir, `CONTEXT-${id}.md`);
+          fs.writeFileSync(contextPath, contextContent, "utf-8");
+        }
+        sendJson(res, 200, { ok: true });
+        broadcastChange();
+      } catch (err) {
+        sendJson(res, 400, { error: String(err) });
+      }
+    }
+    var commandSession = null;
+    async function handleCommand(req, res, cwd) {
+      try {
+        if (commandSession) {
+          sendJson(res, 409, { error: "A command is already running" });
+          return;
+        }
+        const body = await readJsonBody(req).catch(() => ({}));
+        const message = (body.message || "").trim();
+        const context = body.context || {};
+        if (!message) {
+          sendJson(res, 400, { error: "No message provided" });
+          return;
+        }
+        const sessionId = `cmd-${Date.now()}`;
+        const { runAI } = require_ai_runner();
+        const activityFile = path.join(cwd, ".planning", "activity.jsonl");
+        const graph = runLoadGraph2(cwd);
+        let contextBlock = "";
+        if (!("error" in graph)) {
+          if (context.nodeId) {
+            const allNodes = [...graph.declarations || [], ...graph.milestones || [], ...graph.actions || []];
+            const node = allNodes.find((n) => n.id === context.nodeId);
+            if (node) {
+              contextBlock = `
+Current view is focused on: ${node.id} \u2014 ${node.title || node.statement || ""} (${node.status || "PENDING"})`;
+            }
+          }
+          if (context.nodeIds && context.nodeIds.length > 0) {
+            const allNodes = [...graph.declarations || [], ...graph.milestones || [], ...graph.actions || []];
+            const visible = context.nodeIds.map((id) => allNodes.find((n) => n.id === id)).filter(Boolean);
+            contextBlock += `
+Visible nodes:
+${visible.map((n) => `- ${n.id}: ${n.title || n.statement || ""} (${n.status || "PENDING"})`).join("\n")}`;
+          }
+          if (context.viewDescription) {
+            contextBlock += `
+View: ${context.viewDescription}`;
+          }
+        }
+        const prompt = `You are working on a Declare project. The project planning files are in ${path.join(cwd, ".planning")}/
+
+The user is looking at the dashboard and says: "${message}"
+${contextBlock}
+
+The planning files:
+- FUTURE.md \u2014 declarations (the "what" the project declares will be true)
+- MILESTONES.md \u2014 milestones (checkpoints that realize declarations)
+- milestones/M-XX-slug/PLAN.md \u2014 action plans per milestone
+
+Apply the user's request by editing the relevant files. Be concise in your response \u2014 just state what you did.`;
+        let agentId;
+        try {
+          const reg = getAgentRegistry(cwd);
+          const agent = reg.spawn("command", context.nodeId || "project", context.nodeId || "project");
+          agentId = agent.id;
+        } catch (_) {
+        }
+        const abortController = new AbortController();
+        commandSession = { sessionId, abortController, agentId };
+        runAI(prompt, {
+          cwd,
+          model: "sonnet",
+          maxTurns: 15,
+          withTools: true,
+          abortController,
+          onText: (text) => {
+            const payload = `event: command-output
+data: ${JSON.stringify({ sessionId, text })}
+
+`;
+            for (const client of sseClients) {
+              try {
+                client.write(payload);
+              } catch (_) {
+                sseClients.delete(client);
+              }
+            }
+          }
+        }).then(({ text, error }) => {
+          commandSession = null;
+          const exitCode = error ? 1 : 0;
+          const payload = `event: command-complete
+data: ${JSON.stringify({ sessionId, exitCode, result: text, error })}
+
+`;
+          for (const client of sseClients) {
+            try {
+              client.write(payload);
+            } catch (_) {
+              sseClients.delete(client);
+            }
+          }
+          if (agentId) {
+            try {
+              const reg = getAgentRegistry(cwd);
+              if (!error) reg.complete(agentId, { message: message.slice(0, 50) });
+              else reg.fail(agentId, 1, error);
+            } catch (_) {
+            }
+          }
+          const phase = error ? "error" : "done";
+          const desc = error ? `Command failed: ${error}` : `Command complete: ${text.slice(0, 80)}`;
+          try {
+            fs.appendFileSync(activityFile, JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Task", phase, agent: "Command", desc }) + "\n");
+          } catch (_) {
+          }
+        }).catch((err) => {
+          commandSession = null;
+          if (agentId) {
+            try {
+              getAgentRegistry(cwd).fail(agentId, 1, String(err));
+            } catch (_) {
+            }
+          }
+        });
+        try {
+          fs.appendFileSync(activityFile, JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Task", phase: "start", agent: "Command", desc: message.slice(0, 100) }) + "\n");
+        } catch (_) {
+        }
+        sendJson(res, 202, { ok: true, sessionId });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    var onboardSession = null;
+    function persistOnboardSession(cwd) {
+      const filePath = path.join(cwd, ".planning", "onboard-session.json");
+      if (!onboardSession) {
+        try {
+          fs.unlinkSync(filePath);
+        } catch (_) {
+        }
+        return;
+      }
+      try {
+        const data = {
+          prompt: onboardSession.prompt,
+          answers: onboardSession.answers,
+          questions: onboardSession.questions,
+          proposals: onboardSession.proposals,
+          phase: onboardSession.phase,
+          approveIndex: onboardSession.approveIndex || 0,
+          savedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+      } catch (_) {
+      }
+    }
+    function restoreOnboardSession(cwd) {
+      const filePath = path.join(cwd, ".planning", "onboard-session.json");
+      try {
+        if (!fs.existsSync(filePath)) return false;
+        const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        if (data.phase === "questions" && !data.questions) return false;
+        if (data.phase === "proposals" && !data.proposals) return false;
+        onboardSession = {
+          prompt: data.prompt,
+          answers: data.answers,
+          questions: data.questions,
+          proposals: data.proposals,
+          phase: data.phase,
+          approveIndex: data.approveIndex || 0,
+          abortController: null
+        };
+        return true;
+      } catch (_) {
+        return false;
+      }
+    }
+    async function handleOnboard(req, res, cwd) {
+      try {
+        if (onboardSession) {
+          sendJson(res, 409, { error: "An onboarding session is already running" });
+          return;
+        }
+        const body = await readJsonBody(req);
+        const message = (body.message || "").trim();
+        if (!message) {
+          sendJson(res, 400, { error: "No message provided" });
+          return;
+        }
+        const { runAI } = require_ai_runner();
+        const activityFile = path.join(cwd, ".planning", "activity.jsonl");
+        const prompt = `You are helping a user plan their software project. They have described their vision:
 
-${siblingsContent || "(none)"}
+"${message}"
 
-## Task
+Identify 3-5 important clarification questions that should be answered before breaking this vision into concrete declarations. Focus on:
+- Scope boundaries (what's included vs excluded?)
+- Key technical decisions that affect the architecture
+- Target users and use cases
+- Priority and sequencing preferences
+- Success criteria and constraints
 
-${taskBlock}
+Output ONLY a JSON array of question objects:
+[{"question": "The question text", "context": "Why this matters for planning", "options": ["Option A", "Option B"]}]
 
-If improvements are possible, suggest a revised version. Output ONLY the improved text in this format:
+The options array is optional \u2014 include it only when there are clear alternatives to choose from.`;
+        let agentId;
+        try {
+          const reg = getAgentRegistry(cwd);
+          const agent = reg.spawn("onboard", "project", "");
+          agentId = agent.id;
+        } catch (_) {
+        }
+        const abortController = new AbortController();
+        onboardSession = { prompt: message, answers: null, questions: null, proposals: null, phase: "questions", approveIndex: 0, abortController, agentId };
+        persistOnboardSession(cwd);
+        runAI(prompt, {
+          cwd,
+          model: "haiku",
+          maxTurns: 1,
+          abortController,
+          onText: (text) => {
+            const payload = `event: onboard-output
+data: ${JSON.stringify({ text })}
 
-**Title:** <improved title>
-**Statement:** <improved statement or produces>
-**Reason:** <one sentence explaining why this is better>
+`;
+            for (const client of sseClients) {
+              try {
+                client.write(payload);
+              } catch (_) {
+                sseClients.delete(client);
+              }
+            }
+          }
+        }).then(({ text, error }) => {
+          let questions = null;
+          if (!error && text) {
+            try {
+              questions = JSON.parse(text.trim());
+            } catch (_) {
+              const jsonMatch = text.match(/\[[\s\S]*\]/);
+              if (jsonMatch) {
+                try {
+                  questions = JSON.parse(jsonMatch[0]);
+                } catch (_2) {
+                }
+              }
+            }
+          }
+          if (onboardSession && questions) {
+            onboardSession.questions = questions;
+            persistOnboardSession(cwd);
+          }
+          const payload = `event: onboard-questions-complete
+data: ${JSON.stringify({ questions, error })}
 
-If the current version is already good, output exactly: LGTM \u2014 no changes needed.`;
+`;
+          for (const client of sseClients) {
+            try {
+              client.write(payload);
+            } catch (_) {
+              sseClients.delete(client);
+            }
+          }
+          if (agentId) {
+            try {
+              const reg = getAgentRegistry(cwd);
+              if (!error) reg.complete(agentId, { questionCount: Array.isArray(questions) ? questions.length : 0 });
+              else reg.fail(agentId, 1, error);
+            } catch (_) {
+            }
+          }
+          try {
+            fs.appendFileSync(activityFile, JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Task", phase: error ? "error" : "done", agent: "Onboard", desc: error ? `Onboard questions failed: ${error}` : `Onboard: ${Array.isArray(questions) ? questions.length : 0} questions` }) + "\n");
+          } catch (_) {
+          }
+        }).catch((err) => {
+          if (agentId) {
+            try {
+              getAgentRegistry(cwd).fail(agentId, 1, String(err));
+            } catch (_) {
+            }
+          }
+        });
+        try {
+          fs.appendFileSync(activityFile, JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Task", phase: "start", agent: "Onboard", desc: "Generating clarification questions" }) + "\n");
+        } catch (_) {
+        }
+        sendJson(res, 202, { ok: true });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
     }
-    async function handleRefine(req, res, cwd, nodeId) {
+    async function handleOnboardAnswer(req, res, cwd) {
       try {
-        if (refineSession) {
-          sendJson(res, 409, { error: "A refine session is already running" });
+        if (!onboardSession) {
+          sendJson(res, 400, { error: "No onboarding session active" });
           return;
         }
-        const body = await readJsonBody(req).catch(() => ({}));
-        const mode = body.mode || "general";
-        const userMessage = body.message || "";
-        const graph = runLoadGraph2(cwd);
-        if ("error" in graph) {
-          sendJson(res, 500, { error: graph.error });
-          return;
+        const body = await readJsonBody(req);
+        const answers = body.answers || [];
+        onboardSession.answers = answers;
+        onboardSession.phase = "proposals";
+        persistOnboardSession(cwd);
+        const { runAI } = require_ai_runner();
+        const activityFile = path.join(cwd, ".planning", "activity.jsonl");
+        let answersBlock = "";
+        if (answers.length > 0) {
+          answersBlock = "\n\nThe user answered these clarification questions:\n" + answers.map((a) => `Q: ${a.question}
+A: ${a.answer}`).join("\n\n");
         }
-        const prompt = buildRefinePrompt(nodeId, graph, mode, userMessage);
-        if (!prompt) {
-          sendJson(res, 404, { error: "Node not found: " + nodeId });
-          return;
+        const prompt = `You are helping a user break down their software project vision into concrete declarations.
+
+The user's vision: "${onboardSession.prompt}"${answersBlock}
+
+In the Declare framework, a "declaration" is a statement about what WILL be true when the project succeeds. Each declaration should be:
+- A concrete, verifiable outcome (not a task or feature)
+- Scoped to be achievable independently
+- Written as a present-tense statement of truth (e.g., "Users can sign in with Google OAuth")
+
+Propose 4-6 declarations that together cover the user's vision. Each should be distinct and non-overlapping.
+
+Output ONLY a JSON array:
+[{"title": "Short declaration title", "statement": "The full declaration statement written as a present-tense truth", "reasoning": "Brief explanation of why this declaration matters"}]`;
+        let agentId;
+        try {
+          const reg = getAgentRegistry(cwd);
+          const agent = reg.spawn("onboard-propose", "project", "");
+          agentId = agent.id;
+        } catch (_) {
         }
-        const sessionId = `refine-${Date.now()}`;
-        const { spawn } = require("node:child_process");
-        const spawnEnv = { ...process.env, FORCE_COLOR: "0" };
-        delete spawnEnv.CLAUDECODE;
-        const proc = spawn("claude", ["-p", prompt, "--output-format", "text"], {
+        const abortController = new AbortController();
+        onboardSession.abortController = abortController;
+        if (agentId) onboardSession.agentId = agentId;
+        runAI(prompt, {
           cwd,
-          env: spawnEnv
-        });
-        const activityFile = path.join(cwd, ".planning", "activity.jsonl");
-        refineSession = { sessionId, proc, nodeId: nodeId.toUpperCase(), suggestion: "", stderr: "" };
-        if (proc.stdout) {
-          proc.stdout.on("data", (chunk) => {
-            const text = chunk.toString();
-            if (refineSession) refineSession.suggestion += text;
-            const payload = `event: refine-output
-data: ${JSON.stringify({ sessionId, nodeId: nodeId.toUpperCase(), text })}
+          model: "sonnet",
+          maxTurns: 1,
+          abortController,
+          onText: (text) => {
+            const payload = `event: onboard-output
+data: ${JSON.stringify({ text })}
 
 `;
             for (const client of sseClients) {
@@ -6688,21 +8077,28 @@ data: ${JSON.stringify({ sessionId, nodeId: nodeId.toUpperCase(), text })}
                 sseClients.delete(client);
               }
             }
-          });
-        }
-        if (proc.stderr) {
-          proc.stderr.on("data", (chunk) => {
-            if (refineSession) refineSession.stderr += chunk.toString();
-          });
-        }
-        proc.on("close", (exitCode) => {
-          const suggestion = refineSession ? refineSession.suggestion : "";
-          const stderrText = refineSession ? refineSession.stderr : "";
-          const nId = refineSession ? refineSession.nodeId : nodeId.toUpperCase();
-          refineSession = null;
-          if (stderrText) console.error(`[refine ${nId}] stderr:`, stderrText.slice(0, 500));
-          const payload = `event: refine-complete
-data: ${JSON.stringify({ sessionId, nodeId: nId, exitCode, suggestion, error: exitCode !== 0 ? stderrText.slice(0, 500) : void 0 })}
+          }
+        }).then(({ text, error }) => {
+          let proposals = null;
+          if (!error && text) {
+            try {
+              proposals = JSON.parse(text.trim());
+            } catch (_) {
+              const jsonMatch = text.match(/\[[\s\S]*\]/);
+              if (jsonMatch) {
+                try {
+                  proposals = JSON.parse(jsonMatch[0]);
+                } catch (_2) {
+                }
+              }
+            }
+          }
+          if (onboardSession && proposals) {
+            onboardSession.proposals = proposals;
+            persistOnboardSession(cwd);
+          }
+          const payload = `event: onboard-proposals-complete
+data: ${JSON.stringify({ proposals, error })}
 
 `;
           for (const client of sseClients) {
@@ -6712,76 +8108,81 @@ data: ${JSON.stringify({ sessionId, nodeId: nId, exitCode, suggestion, error: ex
               sseClients.delete(client);
             }
           }
-          const phase = exitCode === 0 ? "done" : "error";
-          const desc = exitCode === 0 ? `Review of ${nId} complete` + (suggestion.includes("LGTM") ? " \u2014 no changes needed" : " \u2014 suggestion ready") : `Review of ${nId} failed (exit ${exitCode})`;
-          const doneEntry = { ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Task", phase, agent: "Refine", desc };
+          if (agentId) {
+            try {
+              const reg = getAgentRegistry(cwd);
+              if (!error) reg.complete(agentId, { proposalCount: Array.isArray(proposals) ? proposals.length : 0 });
+              else reg.fail(agentId, 1, error);
+            } catch (_) {
+            }
+          }
           try {
-            fs.appendFileSync(activityFile, JSON.stringify(doneEntry) + "\n");
+            fs.appendFileSync(activityFile, JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Task", phase: error ? "error" : "done", agent: "Onboard", desc: error ? `Onboard proposals failed: ${error}` : `Onboard: ${Array.isArray(proposals) ? proposals.length : 0} proposals` }) + "\n");
           } catch (_) {
           }
+        }).catch((err) => {
+          if (agentId) {
+            try {
+              getAgentRegistry(cwd).fail(agentId, 1, String(err));
+            } catch (_) {
+            }
+          }
         });
-        const entry = { ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Task", phase: "start", agent: "Refine", desc: `Analyzing ${nodeId.toUpperCase()} for improvements` };
-        fs.appendFileSync(activityFile, JSON.stringify(entry) + "\n");
-        sendJson(res, 202, { ok: true, sessionId });
+        try {
+          fs.appendFileSync(activityFile, JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Task", phase: "start", agent: "Onboard", desc: "Generating declaration proposals" }) + "\n");
+        } catch (_) {
+        }
+        sendJson(res, 202, { ok: true });
       } catch (err) {
         sendJson(res, 500, { error: String(err) });
       }
     }
-    function handleRefineStop(res) {
-      if (!refineSession) {
-        sendJson(res, 404, { error: "No refine session running" });
-        return;
-      }
-      try {
-        refineSession.proc.kill();
-      } catch (_) {
-      }
-      refineSession = null;
-      sendJson(res, 200, { ok: true });
-    }
-    async function handleRefineAccept(req, res, cwd) {
+    async function handleOnboardApprove(req, res, cwd) {
       try {
         const body = await readJsonBody(req);
-        const { nodeId, title, statement } = body;
-        if (!nodeId) {
-          sendJson(res, 400, { error: "Missing nodeId" });
+        const { title, statement } = body;
+        if (!title || !statement) {
+          sendJson(res, 400, { error: "Missing title or statement" });
           return;
         }
-        const id = nodeId.toUpperCase();
-        const prefix = id.split("-")[0];
-        const planningDir = path.join(cwd, ".planning");
-        if (prefix === "D") {
-          const futurePath = path.join(planningDir, "FUTURE.md");
-          const content = fs.readFileSync(futurePath, "utf-8");
-          const declarations = parseFutureFile(content);
-          const decl = declarations.find((d) => d.id === id);
-          if (decl) {
-            if (title) decl.title = title;
-            if (statement) decl.statement = statement;
-            const projectNameMatch = content.match(/^# Future:\\s*(.+)/m);
-            const projectName = projectNameMatch ? projectNameMatch[1].trim() : "Project";
-            fs.writeFileSync(futurePath, writeFutureFile(declarations, projectName), "utf-8");
-          }
-        } else if (prefix === "M") {
-          const msPath = path.join(planningDir, "MILESTONES.md");
-          const content = fs.readFileSync(msPath, "utf-8");
-          const { milestones } = parseMilestonesFile(content);
-          const mile = milestones.find((m) => m.id === id);
-          if (mile && title) {
-            mile.title = title;
-            const projectNameMatch = content.match(/^# Milestones:\\s*(.+)/m);
-            const projectName = projectNameMatch ? projectNameMatch[1].trim() : "Project";
-            fs.writeFileSync(msPath, writeMilestonesFile(milestones, projectName), "utf-8");
+        const result = runAddDeclaration2(cwd, ["--title", title, "--statement", statement]);
+        if ("error" in result) {
+          sendJson(res, 400, { error: result.error });
+          return;
+        }
+        setReviewState(cwd, result.id, "approved");
+        broadcastChange();
+        if (onboardSession) {
+          onboardSession.phase = "approving";
+          onboardSession.approveIndex = (onboardSession.approveIndex || 0) + 1;
+          persistOnboardSession(cwd);
+        }
+        try {
+          const graph = runLoadGraph2(cwd);
+          if (!("error" in graph)) {
+            const declarations = graph.declarations.map((d) => ({
+              id: d.id,
+              statement: d.statement,
+              milestones: d.milestones || []
+            }));
+            const dr = getDerivationRunner(cwd);
+            dr.derive(result.id, declarations);
           }
+        } catch (_) {
         }
-        const activityFile = path.join(cwd, ".planning", "activity.jsonl");
-        const entry = { ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Review", phase: "end", desc: `Refined ${id}`, nodeId: id, reviewState: "approved" };
-        fs.appendFileSync(activityFile, JSON.stringify(entry) + "\n");
-        sendJson(res, 200, { ok: true });
+        sendJson(res, 201, result);
       } catch (err) {
         sendJson(res, 500, { error: String(err) });
       }
     }
+    function handleOnboardCancel(req, res, cwd) {
+      if (onboardSession && onboardSession.abortController) {
+        onboardSession.abortController.abort();
+      }
+      onboardSession = null;
+      persistOnboardSession(cwd);
+      sendJson(res, 200, { ok: true });
+    }
     function handleArchiveNode(res, cwd, nodeId) {
       const id = nodeId.toUpperCase();
       const prefix = id.split("-")[0];
@@ -7149,13 +8550,17 @@ data: ${JSON.stringify({ reason: "delete", nodeId: id })}
           return;
         }
         if (urlPath === "/api/milestones/derive/stop") {
-          handleDeriveStop(res, cwd);
+          handleDeriveStop(req, res, cwd);
           return;
         }
         if (urlPath === "/api/milestones/derive/accept") {
           handleDeriveAccept(req, res, cwd);
           return;
         }
+        if (urlPath === "/api/declarations/derive-all") {
+          handleDeriveAll(res, cwd);
+          return;
+        }
         const actionDeriveMatch = urlPath.match(/^\/api\/milestones\/([^/]+)\/actions\/derive$/);
         if (actionDeriveMatch) {
           handleActionDerive(res, cwd, actionDeriveMatch[1]);
@@ -7263,6 +8668,42 @@ data: ${JSON.stringify({ reason: "delete", nodeId: id })}
           handleRefineAccept(req, res, cwd);
           return;
         }
+        const discussMatch = urlPath.match(/^\/api\/node\/([^/]+)\/discuss$/);
+        if (discussMatch) {
+          handleDiscuss(req, res, cwd, discussMatch[1]);
+          return;
+        }
+        const discussAnswerMatch = urlPath.match(/^\/api\/node\/([^/]+)\/discuss\/answer$/);
+        if (discussAnswerMatch) {
+          handleDiscussAnswer(req, res, cwd, discussAnswerMatch[1]);
+          return;
+        }
+        if (urlPath === "/api/command") {
+          handleCommand(req, res, cwd);
+          return;
+        }
+        if (urlPath === "/api/onboard/complete") {
+          onboardSession = null;
+          persistOnboardSession(cwd);
+          sendJson(res, 200, { ok: true });
+          return;
+        }
+        if (urlPath === "/api/onboard") {
+          handleOnboard(req, res, cwd);
+          return;
+        }
+        if (urlPath === "/api/onboard/answer") {
+          handleOnboardAnswer(req, res, cwd);
+          return;
+        }
+        if (urlPath === "/api/onboard/approve") {
+          handleOnboardApprove(req, res, cwd);
+          return;
+        }
+        if (urlPath === "/api/onboard/cancel") {
+          handleOnboardCancel(req, res, cwd);
+          return;
+        }
         if (urlPath === "/api/execution-manifest") {
           handleSaveManifest(req, res, cwd);
           return;
@@ -7332,6 +8773,22 @@ data: ${JSON.stringify({ reason: "delete", nodeId: id })}
         sendJson(res, 200, { running: pm.running() });
         return;
       }
+      if (urlPath === "/api/agents") {
+        const reg = getAgentRegistry(cwd);
+        sendJson(res, 200, reg.getAll());
+        return;
+      }
+      const agentMatch = urlPath.match(/^\/api\/agents\/([^/]+)$/);
+      if (agentMatch) {
+        const reg = getAgentRegistry(cwd);
+        const agent = reg.get(decodeURIComponent(agentMatch[1]));
+        if (agent) {
+          sendJson(res, 200, agent);
+        } else {
+          sendJson(res, 404, { error: "Agent not found" });
+        }
+        return;
+      }
       if (urlPath === "/api/play/status") {
         const pr = getPlayRunner(cwd);
         const plr = getPipelineRunner(cwd);
@@ -7350,7 +8807,28 @@ data: ${JSON.stringify({ reason: "delete", nodeId: id })}
       }
       if (urlPath === "/api/derivation/running") {
         const dr = getDerivationRunner(cwd);
-        sendJson(res, 200, { running: dr.running() });
+        const runningSessions = dr.running();
+        sendJson(res, 200, {
+          running: runningSessions ? runningSessions[0].sessionId : null,
+          sessions: runningSessions
+        });
+        return;
+      }
+      if (urlPath === "/api/onboard/state") {
+        if (!onboardSession) restoreOnboardSession(cwd);
+        if (onboardSession) {
+          sendJson(res, 200, {
+            active: true,
+            prompt: onboardSession.prompt,
+            phase: onboardSession.phase,
+            questions: onboardSession.questions,
+            proposals: onboardSession.proposals,
+            answers: onboardSession.answers,
+            approveIndex: onboardSession.approveIndex || 0
+          });
+        } else {
+          sendJson(res, 200, { active: false });
+        }
         return;
       }
       const actionDeriveRunningMatch = urlPath.match(/^\/api\/milestones\/([^/]+)\/actions\/derive\/running$/);
@@ -7359,6 +8837,10 @@ data: ${JSON.stringify({ reason: "delete", nodeId: id })}
         sendJson(res, 200, { running: adr.running() });
         return;
       }
+      if (urlPath === "/api/lifecycle") {
+        handleLifecycle(res, cwd);
+        return;
+      }
       if (urlPath === "/api/workflow/state") {
         handleWorkflowState(res, cwd);
         return;
@@ -7432,6 +8914,22 @@ data: ${JSON.stringify({ reason: "delete", nodeId: id })}
           resolve(void 0);
         });
       });
+      const portFilePath = require("path").join(cwd, ".planning", "server.port");
+      require("fs").writeFileSync(portFilePath, String(resolvedPort), "utf-8");
+      const deletePortFile = () => {
+        try {
+          require("fs").unlinkSync(portFilePath);
+        } catch (_) {
+        }
+      };
+      server.on("close", deletePortFile);
+      process.on("exit", deletePortFile);
+      const reg = getAgentRegistry(cwd);
+      const restored = reg.restoreFromDisk();
+      if (restored.interrupted > 0) {
+        process.stderr.write(`[declare] Restored agent state: ${restored.interrupted} agent(s) marked as interrupted from previous run
+`);
+      }
       const url = `http://localhost:${resolvedPort}`;
       return { server, port: resolvedPort, url };
     }
@@ -7443,6 +8941,7 @@ data: ${JSON.stringify({ reason: "delete", nodeId: id })}
 var require_serve = __commonJS({
   "src/commands/serve.js"(exports2, module2) {
     "use strict";
+    var { spawn } = require("child_process");
     var { startServer } = require_server();
     function parsePortFlag(args) {
       const idx = args.indexOf("--port");
@@ -7453,6 +8952,11 @@ var require_serve = __commonJS({
     async function runServe2(cwd, args) {
       const port = parsePortFlag(args) || parseInt(process.env.PORT || "", 10) || 3847;
       const { server, port: resolvedPort, url } = await startServer(cwd, port);
+      const noOpen = args.includes("--no-open") || process.env.DECLARE_NO_OPEN;
+      if (!noOpen) {
+        const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        spawn(opener, [url], { stdio: "ignore", detached: true }).unref();
+      }
       process.on("SIGINT", () => {
         server.close(() => process.exit(0));
       });
@@ -7473,6 +8977,7 @@ var require_open = __commonJS({
     var path = require("path");
     var http = require("http");
     var { spawn } = require("child_process");
+    var { runInit: runInit2 } = require_init();
     function checkServer(port) {
       return new Promise((resolve) => {
         const req = http.get(`http://localhost:${port}/api/graph`, (res) => {
@@ -7496,16 +9001,11 @@ var require_open = __commonJS({
     async function runOpen2(cwd, args) {
       const planningDir = path.join(cwd, ".planning");
       if (!fs.existsSync(planningDir)) {
-        console.log("");
-        console.log("  No .planning/ directory found in: " + cwd);
-        console.log("");
-        console.log("  To initialize this project with Declare, run:");
-        console.log("    npx declare-cc");
-        console.log("");
-        console.log("  Or, if declare-cc is already installed globally:");
-        console.log("    declare-cc");
-        console.log("");
-        process.exit(0);
+        console.log("Initializing Declare project in: " + cwd);
+        const result = runInit2(cwd, []);
+        if (result.created && result.created.length > 0) {
+          console.log("Created: " + result.created.join(", "));
+        }
       }
       const portFile = path.join(cwd, ".planning", "server.port");
       const port = fs.existsSync(portFile) ? parseInt(fs.readFileSync(portFile, "utf8").trim(), 10) : 3847;