declare-cc 0.5.9 → 0.6.0

package/dist/declare-tools.cjs

@@ -215,7 +215,19 @@ var require_future = __commonJS({
         const status = rawStatus.toUpperCase().trim();
         const rawMilestones = extractField(lines, "Milestones");
         const milestones = rawMilestones ? rawMilestones.split(",").map((s) => s.trim()).filter(Boolean) : [];
-        declarations.push({ id, title: title.trim(), statement, status, milestones });
+        const reviewState = extractField(lines, "Review") || "draft";
+        const rawRef = extractField(lines, "Ref");
+        let ref;
+        if (rawRef) {
+          ref = {};
+          const urlMatch = rawRef.match(/url=(\S+)/);
+          const pathMatch = rawRef.match(/path=(\S+)/);
+          if (urlMatch) ref.url = urlMatch[1];
+          if (pathMatch) ref.path = pathMatch[1];
+        }
+        const decl = { id, title: title.trim(), statement, status, milestones, reviewState };
+        if (ref) decl.ref = ref;
+        declarations.push(decl);
       }
       return declarations;
     }
@@ -225,7 +237,14 @@ var require_future = __commonJS({
         lines.push(`## ${d.id}: ${d.title}`);
         lines.push(`**Statement:** ${d.statement}`);
         lines.push(`**Status:** ${d.status}`);
+        lines.push(`**Review:** ${d.reviewState || "draft"}`);
         lines.push(`**Milestones:** ${d.milestones.join(", ")}`);
+        if (d.ref && (d.ref.url || d.ref.path)) {
+          const parts = [];
+          if (d.ref.url) parts.push(`url=${d.ref.url}`);
+          if (d.ref.path) parts.push(`path=${d.ref.path}`);
+          lines.push(`**Ref:** ${parts.join(" ")}`);
+        }
         lines.push("");
       }
       return lines.join("\n");
@@ -302,9 +321,13 @@ var require_milestones = __commonJS({
       const milestones = milestoneRows.map((row) => ({
         id: (row["ID"] || "").trim(),
         title: (row["Title"] || "").trim(),
+        description: (row["Description"] || "").trim(),
         status: (row["Status"] || "PENDING").trim().toUpperCase(),
         realizes: splitMultiValue(row["Realizes"] || ""),
-        hasPlan: (row["Plan"] || "").trim().toUpperCase() === "YES"
+        hasPlan: (row["Plan"] || "").trim().toUpperCase() === "YES",
+        classification: (row["Classification"] || "agent").trim().toLowerCase() === "human" ? "human" : "agent",
+        dependsOn: splitMultiValue(row["Depends On"] || ""),
+        reviewState: (row["Review"] || "draft").trim() || "draft"
       })).filter((m) => m.id);
       return { milestones };
     }
@@ -315,14 +338,22 @@ var require_milestones = __commonJS({
       const projectName = maybeProjectName || (typeof projectNameOrActions === "string" ? projectNameOrActions : "Project");
       const lines = [`# Milestones: ${projectName}`, ""];
       lines.push("## Milestones", "");
-      const mHeaders = ["ID", "Title", "Status", "Realizes", "Plan"];
-      const mRows = milestones.map((m) => [
-        m.id,
-        m.title,
-        m.status,
-        m.realizes.join(", "),
-        m.hasPlan ? "YES" : "NO"
-      ]);
+      const hasDescriptions = milestones.some((m) => m.description);
+      const hasClassification = milestones.some((m) => m.classification && m.classification !== "agent");
+      const hasDependsOn = milestones.some((m) => m.dependsOn && m.dependsOn.length > 0);
+      const mHeaders = ["ID", "Title"];
+      if (hasDescriptions) mHeaders.push("Description");
+      mHeaders.push("Status", "Realizes", "Plan", "Review");
+      if (hasClassification) mHeaders.push("Classification");
+      if (hasDependsOn) mHeaders.push("Depends On");
+      const mRows = milestones.map((m) => {
+        const row = [m.id, m.title];
+        if (hasDescriptions) row.push(m.description || "");
+        row.push(m.status, m.realizes.join(", "), m.hasPlan ? "YES" : "NO", m.reviewState || "draft");
+        if (hasClassification) row.push(m.classification || "agent");
+        if (hasDependsOn) row.push((m.dependsOn || []).join(", "));
+        return row;
+      });
       lines.push(...formatTable(mHeaders, mRows));
       lines.push("");
       return lines.join("\n");
@@ -427,7 +458,7 @@ var require_plan = __commonJS({
     }
     function parsePlanFile(content) {
       if (!content || !content.trim()) {
-        return { milestone: null, realizes: [], status: "PENDING", derived: "", actions: [] };
+        return { milestone: null, realizes: [], status: "PENDING", derived: "", produces: "", actions: [] };
       }
       const headerMatch = content.match(/^# Plan:\s*(M-\d+)/m);
       const milestone = headerMatch ? headerMatch[1] : null;
@@ -437,6 +468,7 @@ var require_plan = __commonJS({
       const realizes = realizesRaw ? realizesRaw.split(",").map((s) => s.trim()).filter(Boolean) : [];
       const status = (extractField(headerLines, "Status") || "PENDING").toUpperCase();
       const derived = extractField(headerLines, "Derived") || "";
+      const produces = extractField(headerLines, "Produces") || "";
       const actionSections = content.split(/^### /m).slice(1);
       const actions = actionSections.map((section) => {
         const lines = section.trim().split("\n");
@@ -444,31 +476,35 @@ var require_plan = __commonJS({
         if (!actionHeaderMatch) return null;
         const [, id, title] = actionHeaderMatch;
         const actionStatus = (extractField(lines, "Status") || "PENDING").toUpperCase();
-        const produces = extractField(lines, "Produces") || "";
+        const produces2 = extractField(lines, "Produces") || "";
+        const reviewState = extractField(lines, "Review") || "draft";
         const description = lines.slice(1).filter((l) => !l.trim().startsWith("**")).map((l) => l.trim()).filter(Boolean).join("\n");
-        return { id, title: title.trim(), status: actionStatus, produces, description };
+        return { id, title: title.trim(), status: actionStatus, produces: produces2, description, reviewState };
       }).filter(Boolean);
-      return { milestone, realizes, status, derived, actions };
+      return { milestone, realizes, status, derived, produces, actions };
     }
-    function writePlanFile(milestoneId, milestoneTitle, realizes, actions) {
+    function writePlanFile(milestoneId, milestoneTitle, realizes, actions, options) {
       const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const milestoneProduces = options && options.produces || "";
       const lines = [
         `# Plan: ${milestoneId} -- ${milestoneTitle}`,
         "",
         `**Milestone:** ${milestoneId}`,
         `**Realizes:** ${realizes.join(", ")}`,
         `**Status:** PENDING`,
-        `**Derived:** ${today}`,
-        "",
-        "## Actions",
-        ""
+        `**Derived:** ${today}`
       ];
+      if (milestoneProduces) {
+        lines.push(`**Produces:** ${milestoneProduces}`);
+      }
+      lines.push("", "## Actions", "");
       for (const action of actions) {
         const id = action.id || "A-XX";
         const status = action.status || "PENDING";
         const produces = action.produces || "";
         lines.push(`### ${id}: ${action.title}`);
         lines.push(`**Status:** ${status}`);
+        lines.push(`**Review:** ${action.reviewState || "draft"}`);
         if (produces) {
           lines.push(`**Produces:** ${produces}`);
         }
@@ -560,6 +596,7 @@ var require_engine = __commonJS({
       return COMPLETED_STATUSES.has(status);
     }
     var VALID_TYPES = /* @__PURE__ */ new Set(["declaration", "milestone", "action"]);
+    var VALID_REVIEW_STATES = /* @__PURE__ */ new Set(["draft", "in_review", "revision_needed", "approved"]);
     var VALID_EDGE_DIRECTIONS = {
       action: "milestone",
       milestone: "declaration"
@@ -896,6 +933,71 @@ var require_engine = __commonJS({
       get size() {
         return this.nodes.size;
       }
+      // ---------------------------------------------------------------------------
+      // Wholeness computation (bottom-up integrity model)
+      // ---------------------------------------------------------------------------
+      /**
+       * Compute wholeness state for every node in the graph.
+       *
+       * Bottom-up, three-pass computation:
+       *   1. Actions: whole if isCompleted(status), broken otherwise
+       *   2. Milestones: whole if ALL child actions whole, partial if SOME, broken if NONE (or no children)
+       *   3. Declarations: whole if ALL child milestones whole, partial if SOME, broken if NONE (or no children)
+       *
+       * Milestone wholeness is computed from action completion, NOT from the milestone's own status field.
+       * Declaration wholeness is computed from milestone wholeness results.
+       *
+       * @returns {Map<string, string>} Map of node ID to wholeness state ("whole" | "partial" | "broken")
+       */
+      computeWholeness() {
+        const wholeness = /* @__PURE__ */ new Map();
+        for (const [id, node] of this.nodes) {
+          if (node.type === "action") {
+            wholeness.set(id, isCompleted(node.status) ? "whole" : "broken");
+          }
+        }
+        for (const [id, node] of this.nodes) {
+          if (node.type === "milestone") {
+            const children = this.downEdges.get(id);
+            if (!children || children.size === 0) {
+              wholeness.set(id, "broken");
+              continue;
+            }
+            let wholeCount = 0;
+            for (const childId of children) {
+              if (wholeness.get(childId) === "whole") wholeCount++;
+            }
+            if (wholeCount === children.size) {
+              wholeness.set(id, "whole");
+            } else if (wholeCount > 0) {
+              wholeness.set(id, "partial");
+            } else {
+              wholeness.set(id, "broken");
+            }
+          }
+        }
+        for (const [id, node] of this.nodes) {
+          if (node.type === "declaration") {
+            const children = this.downEdges.get(id);
+            if (!children || children.size === 0) {
+              wholeness.set(id, "broken");
+              continue;
+            }
+            let wholeCount = 0;
+            for (const childId of children) {
+              if (wholeness.get(childId) === "whole") wholeCount++;
+            }
+            if (wholeCount === children.size) {
+              wholeness.set(id, "whole");
+            } else if (wholeCount > 0) {
+              wholeness.set(id, "partial");
+            } else {
+              wholeness.set(id, "broken");
+            }
+          }
+        }
+        return wholeness;
+      }
       /**
        * Get graph statistics.
        * @returns {{ declarations: number, milestones: number, actions: number, edges: number, byStatus: {PENDING: number, ACTIVE: number, DONE: number} }}
@@ -926,7 +1028,85 @@ var require_engine = __commonJS({
         return node ? { id: node.id, type: node.type, title: node.title, status: node.status } : { id: e.node, type: "unknown", title: "", status: "" };
       });
     }
-    module2.exports = { DeclareDag, COMPLETED_STATUSES, isCompleted, findOrphans };
+    function computeWholeness(dag) {
+      return dag.computeWholeness();
+    }
+    function computeWorkabilityPath(dag, nodeId) {
+      if (!dag.getNode(nodeId)) {
+        throw new Error(`Node not found: ${nodeId}`);
+      }
+      const wholenessMap = dag.computeWholeness();
+      const nodeWholeness = wholenessMap.get(nodeId);
+      if (nodeWholeness === "whole") {
+        return { nodeId, wholeness: "whole", steps: [] };
+      }
+      const brokenActions = [];
+      const visited = /* @__PURE__ */ new Set();
+      function walkDown(id) {
+        if (visited.has(id)) return;
+        visited.add(id);
+        const node = dag.getNode(id);
+        if (!node) return;
+        if (node.type === "action" && wholenessMap.get(id) === "broken") {
+          brokenActions.push(node);
+          return;
+        }
+        const children = dag.downEdges.get(id);
+        if (!children) return;
+        for (const childId of children) {
+          if (wholenessMap.get(childId) !== "whole") {
+            walkDown(childId);
+          }
+        }
+      }
+      walkDown(nodeId);
+      const steps = brokenActions.map((action) => {
+        const ancestors = /* @__PURE__ */ new Set();
+        const ancestorVisited = /* @__PURE__ */ new Set();
+        function walkUp(id) {
+          if (ancestorVisited.has(id)) return;
+          ancestorVisited.add(id);
+          const upTargets = dag.upEdges.get(id);
+          if (!upTargets) return;
+          for (const targetId of upTargets) {
+            ancestors.add(targetId);
+            walkUp(targetId);
+          }
+        }
+        walkUp(action.id);
+        let nonWholeCount = 0;
+        for (const ancestorId of ancestors) {
+          if (wholenessMap.get(ancestorId) !== "whole") {
+            nonWholeCount++;
+          }
+        }
+        let impact;
+        if (nonWholeCount >= 3) {
+          impact = "high";
+        } else if (nonWholeCount >= 1) {
+          impact = "medium";
+        } else {
+          impact = "low";
+        }
+        const upstream = dag.getUpstream(action.id);
+        const milestone = upstream.find((n) => n.type === "milestone");
+        const milestoneId = milestone ? milestone.id : "";
+        return {
+          actionId: action.id,
+          title: action.title,
+          milestoneId,
+          impact
+        };
+      });
+      const impactOrder = { high: 0, medium: 1, low: 2 };
+      steps.sort((a, b) => {
+        const impactDiff = impactOrder[a.impact] - impactOrder[b.impact];
+        if (impactDiff !== 0) return impactDiff;
+        return a.actionId.localeCompare(b.actionId);
+      });
+      return { nodeId, wholeness: nodeWholeness, steps };
+    }
+    module2.exports = { DeclareDag, VALID_REVIEW_STATES, COMPLETED_STATUSES, isCompleted, findOrphans, computeWholeness, computeWorkabilityPath };
   }
 });
 
@@ -942,26 +1122,31 @@ var require_build_dag = __commonJS({
     var { DeclareDag } = require_engine();
     function loadActionsFromFolders(planningDir) {
       const milestonesDir = join(planningDir, "milestones");
-      if (!existsSync(milestonesDir)) return [];
+      if (!existsSync(milestonesDir)) return { actions: [], milestoneProduces: {} };
       const allActions = [];
+      const milestoneProduces = {};
       const entries = readdirSync(milestonesDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory() || entry.name.startsWith("_")) continue;
         const planPath = join(milestonesDir, entry.name, "PLAN.md");
         if (!existsSync(planPath)) continue;
         const content = readFileSync(planPath, "utf-8");
-        const { milestone, actions } = parsePlanFile(content);
+        const { milestone, actions, produces } = parsePlanFile(content);
+        if (milestone && produces) {
+          milestoneProduces[milestone] = produces;
+        }
         for (const action of actions) {
           allActions.push({
             id: action.id,
             title: action.title,
             status: action.status,
             produces: action.produces,
+            reviewState: action.reviewState || "draft",
             causes: milestone ? [milestone] : []
           });
         }
       }
-      return allActions;
+      return { actions: allActions, milestoneProduces };
     }
     function buildDagFromDisk(cwd) {
       const planningDir = join(cwd, ".planning");
@@ -974,16 +1159,33 @@ var require_build_dag = __commonJS({
       const milestonesContent = existsSync(milestonesPath) ? readFileSync(milestonesPath, "utf-8") : "";
       const declarations = parseFutureFile(futureContent);
       const { milestones } = parseMilestonesFile(milestonesContent);
-      const actions = loadActionsFromFolders(planningDir);
+      const { actions: allLoadedActions, milestoneProduces } = loadActionsFromFolders(planningDir);
+      const milestoneIds = new Set(milestones.map((m) => m.id.toUpperCase()));
+      const actions = allLoadedActions.filter(
+        (a) => a.causes.some((c) => milestoneIds.has(c.toUpperCase()))
+      );
+      for (const m of milestones) {
+        if (milestoneProduces[m.id]) {
+          m.produces = milestoneProduces[m.id];
+        }
+      }
       const dag = new DeclareDag();
       for (const d of declarations) {
-        dag.addNode(d.id, "declaration", d.title, d.status || "PENDING");
+        const meta = { reviewState: d.reviewState || "draft" };
+        if (d.ref) meta.ref = d.ref;
+        dag.addNode(d.id, "declaration", d.title, d.status || "PENDING", meta);
       }
       for (const m of milestones) {
-        dag.addNode(m.id, "milestone", m.title, m.status || "PENDING");
+        dag.addNode(m.id, "milestone", m.title, m.status || "PENDING", {
+          description: m.description || "",
+          produces: m.produces || "",
+          classification: m.classification || "agent",
+          dependsOn: m.dependsOn || [],
+          reviewState: m.reviewState || "draft"
+        });
       }
       for (const a of actions) {
-        dag.addNode(a.id, "action", a.title, a.status || "PENDING");
+        dag.addNode(a.id, "action", a.title, a.status || "PENDING", { reviewState: a.reviewState || "draft" });
       }
       for (const m of milestones) {
         for (const declId of m.realizes) {
@@ -1409,6 +1611,113 @@ var require_add_declaration = __commonJS({
   }
 });
 
+// src/commands/update-declaration.js
+var require_update_declaration = __commonJS({
+  "src/commands/update-declaration.js"(exports2, module2) {
+    "use strict";
+    var { existsSync, readFileSync, writeFileSync } = require("node:fs");
+    var { join } = require("node:path");
+    var { parseFutureFile, writeFutureFile } = require_future();
+    var { commitPlanningDocs: commitPlanningDocs2, loadConfig } = require_commit();
+    var { parseFlag } = require_parse_args();
+    function runUpdateDeclaration2(cwd, args) {
+      const id = parseFlag(args, "id");
+      const title = parseFlag(args, "title");
+      const statement = parseFlag(args, "statement");
+      const status = parseFlag(args, "status");
+      if (!id) {
+        return { error: "Missing required flag: --id" };
+      }
+      if (!title && !statement && !status) {
+        return { error: "At least one of --title, --statement, or --status must be provided" };
+      }
+      const planningDir = join(cwd, ".planning");
+      const futurePath = join(planningDir, "FUTURE.md");
+      if (!existsSync(futurePath)) {
+        return { error: "FUTURE.md not found" };
+      }
+      const futureContent = readFileSync(futurePath, "utf-8");
+      const declarations = parseFutureFile(futureContent);
+      const decl = declarations.find((d) => d.id === id);
+      if (!decl) {
+        return { error: `Declaration not found: ${id}` };
+      }
+      if (title) decl.title = title;
+      if (statement) decl.statement = statement;
+      if (status) decl.status = status.toUpperCase();
+      const headerMatch = futureContent.match(/^# Future: (.+)/m);
+      const projectName = headerMatch ? headerMatch[1].trim() : "Project";
+      const content = writeFutureFile(declarations, projectName);
+      writeFileSync(futurePath, content, "utf-8");
+      const config = loadConfig(cwd);
+      let committed = false;
+      let hash;
+      if (config.commit_docs !== false) {
+        const result = commitPlanningDocs2(
+          cwd,
+          `declare: update ${id} "${decl.title}"`,
+          [".planning/FUTURE.md"]
+        );
+        committed = result.committed;
+        hash = result.hash;
+      }
+      return { id, title: decl.title, statement: decl.statement, status: decl.status, committed, hash };
+    }
+    module2.exports = { runUpdateDeclaration: runUpdateDeclaration2 };
+  }
+});
+
+// src/commands/delete-declaration.js
+var require_delete_declaration = __commonJS({
+  "src/commands/delete-declaration.js"(exports2, module2) {
+    "use strict";
+    var { existsSync, readFileSync, writeFileSync } = require("node:fs");
+    var { join } = require("node:path");
+    var { parseFutureFile, writeFutureFile } = require_future();
+    var { commitPlanningDocs: commitPlanningDocs2, loadConfig } = require_commit();
+    var { parseFlag } = require_parse_args();
+    function runDeleteDeclaration2(cwd, args) {
+      const id = parseFlag(args, "id");
+      if (!id) {
+        return { error: "Missing required flag: --id" };
+      }
+      const planningDir = join(cwd, ".planning");
+      const futurePath = join(planningDir, "FUTURE.md");
+      if (!existsSync(futurePath)) {
+        return { error: "FUTURE.md not found" };
+      }
+      const futureContent = readFileSync(futurePath, "utf-8");
+      const declarations = parseFutureFile(futureContent);
+      const decl = declarations.find((d) => d.id === id);
+      if (!decl) {
+        return { error: `Declaration not found: ${id}` };
+      }
+      if (decl.milestones && decl.milestones.length > 0) {
+        return { error: "Cannot delete declaration with linked milestones. Renegotiate instead." };
+      }
+      const filtered = declarations.filter((d) => d.id !== id);
+      const headerMatch = futureContent.match(/^# Future: (.+)/m);
+      const projectName = headerMatch ? headerMatch[1].trim() : "Project";
+      const content = writeFutureFile(filtered, projectName);
+      writeFileSync(futurePath, content, "utf-8");
+      const config = loadConfig(cwd);
+      let committed = false;
+      let hash;
+      if (config.commit_docs !== false) {
+        const result = commitPlanningDocs2(
+          cwd,
+          `declare: delete ${id} "${decl.title}"`,
+          [".planning/FUTURE.md"]
+        );
+        committed = result.committed;
+        hash = result.hash;
+      }
+      return { id, title: decl.title, deleted: true, committed, hash };
+    }
+    module2.exports = { runDeleteDeclaration: runDeleteDeclaration2 };
+  }
+});
+
 // src/commands/add-milestone.js
 var require_add_milestone = __commonJS({
   "src/commands/add-milestone.js"(exports2, module2) {
@@ -1601,19 +1910,91 @@ var require_add_action = __commonJS({
   }
 });
 
+// src/commands/readiness.js
+var require_readiness = __commonJS({
+  "src/commands/readiness.js"(exports2, module2) {
+    "use strict";
+    var COMPLETED = /* @__PURE__ */ new Set(["DONE", "KEPT", "HONORED"]);
+    function computeReadiness(graph) {
+      const { milestones, actions } = graph;
+      const milestoneStatus = {};
+      for (const m of milestones) {
+        milestoneStatus[m.id] = (m.status || "PENDING").toUpperCase();
+      }
+      const actionCounts = {};
+      for (const m of milestones) {
+        actionCounts[m.id] = { done: 0, total: 0 };
+      }
+      for (const a of actions) {
+        const causes = a.causes || [];
+        for (const mId of causes) {
+          if (!actionCounts[mId]) continue;
+          actionCounts[mId].total++;
+          if (COMPLETED.has((a.status || "").toUpperCase())) {
+            actionCounts[mId].done++;
+          }
+        }
+      }
+      const readiness = {};
+      for (const m of milestones) {
+        const status = milestoneStatus[m.id];
+        const progress = actionCounts[m.id] || { done: 0, total: 0 };
+        if (COMPLETED.has(status)) {
+          readiness[m.id] = { state: "done", blockedBy: [], progress };
+          continue;
+        }
+        const deps = m.dependsOn || [];
+        const blockedBy = [];
+        for (const depId of deps) {
+          const depStatus = milestoneStatus[depId];
+          if (!depStatus || !COMPLETED.has(depStatus)) {
+            blockedBy.push(depId);
+          }
+        }
+        if (blockedBy.length > 0) {
+          readiness[m.id] = { state: "blocked", blockedBy, progress };
+        } else if (progress.total === 0 && !m.hasPlan) {
+          readiness[m.id] = { state: "no-actions", blockedBy: [], progress };
+        } else {
+          readiness[m.id] = { state: "ready", blockedBy: [], progress };
+        }
+      }
+      return readiness;
+    }
+    module2.exports = { computeReadiness };
+  }
+});
+
 // src/commands/load-graph.js
 var require_load_graph = __commonJS({
   "src/commands/load-graph.js"(exports2, module2) {
     "use strict";
     var { buildDagFromDisk, loadActionsFromFolders } = require_build_dag();
+    var { computeReadiness } = require_readiness();
     function runLoadGraph2(cwd) {
       const graphResult = buildDagFromDisk(cwd);
       if (graphResult.error) return graphResult;
       const { dag, declarations, milestones, actions } = graphResult;
+      const wholeness = dag.computeWholeness();
+      const enrichedMilestones = milestones.map((m) => ({
+        ...m,
+        classification: m.classification || "agent",
+        dependsOn: m.dependsOn || [],
+        wholeness: wholeness.get(m.id) || "broken"
+      }));
+      const enrichedActions = actions.map((a) => ({ ...a, wholeness: wholeness.get(a.id) || "broken" }));
+      const readiness = computeReadiness({
+        milestones: enrichedMilestones,
+        actions: enrichedActions
+      });
       return {
-        declarations,
-        milestones,
-        actions,
+        declarations: declarations.map((d) => ({ ...d, wholeness: wholeness.get(d.id) || "broken" })),
+        milestones: enrichedMilestones.map((m) => ({
+          ...m,
+          readiness: readiness[m.id] || { state: "blocked", blockedBy: [], progress: { done: 0, total: 0 } }
+        })),
+        actions: enrichedActions,
+        readiness,
         stats: dag.stats(),
         validation: dag.validate()
       };
@@ -1676,7 +2057,7 @@ var require_create_plan = __commonJS({
       for (const m of milestones) {
         dag.addNode(m.id, "milestone", m.title, m.status || "PENDING");
       }
-      const existingActions = loadActionsFromFolders(planningDir);
+      const { actions: existingActions } = loadActionsFromFolders(planningDir);
       for (const a of existingActions) {
         dag.addNode(a.id, "action", a.title, a.status || "PENDING");
       }
@@ -3018,7 +3399,7 @@ var require_sync_status = __commonJS({
           writeFileSync(planPath, planContent, "utf-8");
         }
       }
-      const freshActions = loadActionsFromFolders(planningDir);
+      const { actions: freshActions } = loadActionsFromFolders(planningDir);
       const milestoneActionIds = /* @__PURE__ */ new Map();
       const actionStatusMap = /* @__PURE__ */ new Map();
       for (const a of freshActions) {
@@ -3109,6 +3490,7 @@ var require_get_exec_plan = __commonJS({
     "use strict";
     var { existsSync, readFileSync, readdirSync } = require("node:fs");
     var { join } = require("node:path");
+    var { execSync } = require("node:child_process");
     var { parseFlag } = require_parse_args();
     var { buildDagFromDisk } = require_build_dag();
     var { findMilestoneFolder } = require_milestone_folders();
@@ -3197,6 +3579,48 @@ var require_get_exec_plan = __commonJS({
       );
       return match ? join(milestoneFolder, match) : null;
     }
+    function resolveActionModel(cwd, summaryContent) {
+      try {
+        if (summaryContent) {
+          const fmMatch = summaryContent.match(/^---\n([\s\S]*?)\n---/);
+          if (fmMatch) {
+            const fm = parseFrontmatter(fmMatch[1]);
+            if (fm.model) return String(fm.model);
+          }
+        }
+        const configPath = join(cwd, ".planning", "config.json");
+        if (existsSync(configPath)) {
+          const config = JSON.parse(readFileSync(configPath, "utf-8"));
+          return config.modelAssignment?.executor ?? null;
+        }
+        return null;
+      } catch {
+        return null;
+      }
+    }
+    function getActionCommits(cwd, actionId, milestoneId) {
+      try {
+        const milestonePrefix = milestoneId.match(/^(M-\d+)/);
+        if (!milestonePrefix) return [];
+        const grepPattern = `(${milestonePrefix[1]}-${actionId})`;
+        const output = execSync(
+          `git log --all --oneline --format="%H|%s|%ai" --extended-regexp --grep="${grepPattern}"`,
+          { cwd, encoding: "utf-8", timeout: 5e3 }
+        );
+        const lines = output.trim().split("\n").filter(Boolean);
+        return lines.map((line) => {
+          const [sha, message, date] = line.split("|");
+          return {
+            sha: sha || "",
+            shortSha: (sha || "").slice(0, 7),
+            message: message || "",
+            date: date || ""
+          };
+        });
+      } catch {
+        return [];
+      }
+    }
     function runGetExecPlan2(cwd, args) {
       const actionId = parseFlag(args, "action");
       if (!actionId) {
@@ -3215,6 +3639,7 @@ var require_get_exec_plan = __commonJS({
       if (!milestoneFolder) {
         return { error: `Milestone folder not found for ${milestone.id}` };
       }
+      const commits = getActionCommits(cwd, actionId, milestone.id);
       const execPlanPath = findExecPlan(milestoneFolder, actionId);
       if (!execPlanPath) {
         return {
@@ -3224,7 +3649,9 @@ var require_get_exec_plan = __commonJS({
           milestoneId: milestone.id,
           milestoneTitle: milestone.title,
           execPlan: null,
-          summaryExists: false
+          summaryExists: false,
+          model: resolveActionModel(cwd, null),
+          commits
         };
       }
       const raw = readFileSync(execPlanPath, "utf-8");
@@ -3238,12 +3665,14 @@ var require_get_exec_plan = __commonJS({
       const summaryPath = join(milestoneFolder, `${actionId}-SUMMARY.md`);
       const summaryExists = existsSync(summaryPath);
       const summaryContent = summaryExists ? readFileSync(summaryPath, "utf-8") : null;
+      const model = resolveActionModel(cwd, summaryContent);
       return {
         actionId,
         actionTitle: action.title,
         status: action.status,
         milestoneId: milestone.id,
         milestoneTitle: milestone.title,
+        model,
         execPlan: {
           wave: frontmatter.wave ? Number(frontmatter.wave) : null,
           autonomous: frontmatter.autonomous === "true" || frontmatter.autonomous === true,
@@ -3257,7 +3686,8 @@ var require_get_exec_plan = __commonJS({
           verification
         },
         summaryExists,
-        summaryContent
+        summaryContent,
+        commits
       };
     }
     module2.exports = { runGetExecPlan: runGetExecPlan2 };
@@ -3825,92 +4255,1815 @@ var require_health_check = __commonJS({
   }
 });
 
-// src/server/index.js
-var require_server = __commonJS({
-  "src/server/index.js"(exports2, module2) {
+// src/server/process-manager.js
+var require_process_manager = __commonJS({
+  "src/server/process-manager.js"(exports2, module2) {
     "use strict";
-    var http = require("node:http");
+    var { spawn } = require("node:child_process");
     var fs = require("node:fs");
-    var net = require("node:net");
     var path = require("node:path");
-    var { runLoadGraph: runLoadGraph2 } = require_load_graph();
-    var { runStatus: runStatus2 } = require_status();
-    var { runGetExecPlan: runGetExecPlan2 } = require_get_exec_plan();
-    var MIME_TYPES = {
-      ".html": "text/html; charset=utf-8",
-      ".js": "application/javascript; charset=utf-8",
-      ".css": "text/css; charset=utf-8",
-      ".json": "application/json; charset=utf-8",
-      ".svg": "image/svg+xml",
-      ".png": "image/png",
-      ".ico": "image/x-icon"
-    };
-    function getPublicDir(cwd) {
-      const installed = path.join(cwd, ".claude", "server", "public");
-      if (fs.existsSync(installed)) return installed;
-      const bundled = path.join(__dirname, "public");
-      if (fs.existsSync(bundled)) return bundled;
-      return path.join(cwd, "src", "server", "public");
-    }
-    function sendJson(res, statusCode, data) {
-      const body = JSON.stringify(data, null, 2);
-      res.writeHead(statusCode, {
-        "Content-Type": "application/json; charset=utf-8",
-        "Content-Length": Buffer.byteLength(body),
-        "Access-Control-Allow-Origin": "*",
-        "Access-Control-Allow-Methods": "GET, OPTIONS",
-        "Access-Control-Allow-Headers": "Content-Type"
-      });
-      res.end(body);
-    }
-    function sendFile(res, filePath) {
-      const ext = path.extname(filePath).toLowerCase();
-      const contentType = MIME_TYPES[ext] || "application/octet-stream";
-      fs.readFile(filePath, (err, data) => {
-        if (err) {
-          res.writeHead(404, { "Content-Type": "text/plain" });
-          res.end("Not Found");
-          return;
-        }
-        res.writeHead(200, {
-          "Content-Type": contentType,
-          "Content-Length": data.length
-        });
-        res.end(data);
-      });
-    }
-    function handleGraph(res, cwd) {
+    var { findMilestoneFolder } = require_milestone_folders();
+    function appendLog(logPath, line) {
+      if (!logPath) return;
       try {
-        const graph = runLoadGraph2(cwd);
-        if ("error" in graph) {
-          sendJson(res, 500, { error: graph.error });
-          return;
-        }
-        sendJson(res, 200, graph);
-      } catch (err) {
-        sendJson(res, 500, { error: String(err) });
+        fs.appendFileSync(logPath, line + "\n", "utf-8");
+      } catch (_) {
       }
     }
-    function handleStatus(res, cwd) {
-      try {
-        const status = runStatus2(cwd);
-        if ("error" in status) {
-          sendJson(res, 500, { error: status.error });
-          return;
+    function createProcessManager(sseClients, cwd) {
+      const processes = /* @__PURE__ */ new Map();
+      function broadcast(event, data) {
+        const payload = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+        for (const client of sseClients) {
+          try {
+            client.write(payload);
+          } catch (_) {
+            sseClients.delete(client);
+          }
         }
-        sendJson(res, 200, status);
-      } catch (err) {
-        sendJson(res, 500, { error: String(err) });
       }
-    }
-    function handleMilestone(res, cwd, milestoneId) {
-      try {
-        const graph = runLoadGraph2(cwd);
-        if ("error" in graph) {
-          sendJson(res, 500, { error: graph.error });
-          return;
+      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) {
+        if (processes.size > 0) {
+          return { error: "busy", status: 409 };
         }
-        const normalizedId = milestoneId.toUpperCase();
+        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 planningDir = path.join(cwd, ".planning");
+        const milestoneFolder = findMilestoneFolder(planningDir, milestoneId);
+        let logPath;
+        if (milestoneFolder) {
+          logPath = path.join(milestoneFolder, "execution.log");
+        } else {
+          process.stderr.write(`[declare] Warning: milestone folder not found for ${milestoneId}, skipping execution log
+`);
+        }
+        processes.set(actionId, { proc, milestoneId, logPath });
+        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) => {
+          const entry = processes.get(actionId);
+          appendLog(entry?.logPath, `=== END ${actionId} @ ${(/* @__PURE__ */ new Date()).toISOString()} exit=${exitCode ?? -1} ===
+`);
+          processes.delete(actionId);
+          broadcast("action-complete", { actionId, exitCode: exitCode ?? -1 });
+        });
+        proc.on("error", (_err) => {
+          const entry = processes.get(actionId);
+          appendLog(entry?.logPath, `=== ERROR ${actionId} @ ${(/* @__PURE__ */ new Date()).toISOString()} ===
+`);
+          processes.delete(actionId);
+          broadcast("action-complete", { actionId, exitCode: -1 });
+        });
+        return { ok: true };
+      }
+      function stop(actionId) {
+        const entry = processes.get(actionId);
+        if (!entry) {
+          return { error: "not_running", status: 404 };
+        }
+        entry.proc.kill("SIGTERM");
+        return { ok: true };
+      }
+      function running() {
+        return [...processes.keys()];
+      }
+      return { execute, stop, running };
+    }
+    module2.exports = { createProcessManager };
+  }
+});
+
+// src/server/derivation-runner.js
+var require_derivation_runner = __commonJS({
+  "src/server/derivation-runner.js"(exports2, module2) {
+    "use strict";
+    var { spawn } = require("node:child_process");
+    function buildPrompt(declarationId, declarations) {
+      let targets;
+      if (declarationId) {
+        targets = declarations.filter((d) => d.id === declarationId);
+      } else {
+        targets = declarations.filter(
+          (d) => !d.milestones || d.milestones.length === 0
+        );
+      }
+      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;
+    }
+    function createDerivationRunner(sseClients, cwd) {
+      let current = null;
+      function broadcast(event, data) {
+        const payload = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+        for (const client of sseClients) {
+          try {
+            client.write(payload);
+          } catch (_) {
+            sseClients.delete(client);
+          }
+        }
+      }
+      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("derivation-output", {
+              sessionId,
+              text: line,
+              stream: streamName
+            });
+          }
+        };
+      }
+      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) => {
+          let milestones = null;
+          if (exitCode === 0) {
+            try {
+              milestones = JSON.parse(stdout.text.trim());
+            } catch (_) {
+            }
+          }
+          current = null;
+          broadcast("derivation-complete", {
+            sessionId,
+            exitCode: exitCode ?? -1,
+            milestones
+          });
+        });
+        proc.on("error", (_err) => {
+          current = null;
+          broadcast("derivation-complete", {
+            sessionId,
+            exitCode: -1,
+            milestones: null
+          });
+        });
+        return { ok: true, sessionId };
+      }
+      function stop() {
+        if (!current) {
+          return { error: "not_running", status: 404 };
+        }
+        current.proc.kill("SIGTERM");
+        return { ok: true };
+      }
+      function running() {
+        return current ? current.sessionId : null;
+      }
+      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");
+    }
+    module2.exports = { createDerivationRunner };
+  }
+});
+
+// src/server/action-derivation-runner.js
+var require_action_derivation_runner = __commonJS({
+  "src/server/action-derivation-runner.js"(exports2, module2) {
+    "use strict";
+    var { spawn } = require("node:child_process");
+    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"}]. 
+
+Milestone:
+- ${milestone.id}: ${milestone.title} (realizes: ${milestone.realizes.join(", ")})`;
+      if (existingActions.length > 0) {
+        prompt += "\n\nExisting actions for this milestone (do NOT duplicate these):\n";
+        for (const a of existingActions) {
+          prompt += `- ${a.id}: ${a.title}`;
+          if (a.produces) prompt += ` (produces: ${a.produces})`;
+          prompt += "\n";
+        }
+      }
+      return prompt;
+    }
+    function createActionDerivationRunner(sseClients, cwd) {
+      let current = null;
+      function broadcast(event, data) {
+        const payload = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+        for (const client of sseClients) {
+          try {
+            client.write(payload);
+          } catch (_) {
+            sseClients.delete(client);
+          }
+        }
+      }
+      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"], {
+          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) => {
+          let actions = null;
+          if (exitCode === 0) {
+            try {
+              actions = JSON.parse(stdout.text.trim());
+            } catch (_) {
+            }
+          }
+          current = null;
+          broadcast("action-derivation-complete", {
+            sessionId,
+            exitCode: exitCode ?? -1,
+            actions
+          });
+        });
+        proc.on("error", (_err) => {
+          current = null;
+          broadcast("action-derivation-complete", {
+            sessionId,
+            exitCode: -1,
+            actions: null
+          });
+        });
+        return { ok: true, sessionId };
+      }
+      function stop() {
+        if (!current) {
+          return { error: "not_running", status: 404 };
+        }
+        current.proc.kill("SIGTERM");
+        return { ok: true };
+      }
+      function running() {
+        return current ? current.sessionId : null;
+      }
+      return { derive, stop, 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("running:", typeof runner.running);
+      console.log("OK");
+    }
+    module2.exports = { createActionDerivationRunner };
+  }
+});
+
+// src/server/revision-runner.js
+var require_revision_runner = __commonJS({
+  "src/server/revision-runner.js"(exports2, module2) {
+    "use strict";
+    var { spawn } = require("node:child_process");
+    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.";
+    }
+    function createRevisionRunner(sseClients, cwd, onComplete) {
+      let current = null;
+      function broadcast(event, data) {
+        const payload = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+        for (const client of sseClients) {
+          try {
+            client.write(payload);
+          } catch (_) {
+            sseClients.delete(client);
+          }
+        }
+      }
+      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*$/);
+        if (fenceMatch) {
+          return fenceMatch[1];
+        }
+        return trimmed;
+      }
+      function revise(nodeId, artifactPath, artifactContent, annotations) {
+        if (current) {
+          return { error: "busy", status: 409 };
+        }
+        const sessionId = `revision-${Date.now()}`;
+        const prompt = buildRevisionPrompt(artifactContent, annotations);
+        try {
+          const annPath = path.join(cwd, ".planning", "annotations", nodeId.toUpperCase() + ".json");
+          let round = 0;
+          if (fs.existsSync(annPath)) {
+            try {
+              const annData = JSON.parse(fs.readFileSync(annPath, "utf-8"));
+              round = annData.revisionRound || 0;
+            } catch (_) {
+            }
+          }
+          const versionedPath = artifactPath.replace(".md", "") + ".v" + round + ".md";
+          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));
+        }
+        proc.on("close", (exitCode) => {
+          const completedNodeId = current ? current.nodeId : nodeId;
+          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 (_) {
+                }
+              }
+              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 (_) {
+                }
+              }
+            } catch (err) {
+              broadcast("revision-complete", {
+                sessionId,
+                nodeId: completedNodeId,
+                exitCode: -1,
+                error: true
+              });
+            }
+          } else {
+            broadcast("revision-complete", {
+              sessionId,
+              nodeId: completedNodeId,
+              exitCode: exitCode ?? -1,
+              error: true
+            });
+          }
+        });
+        proc.on("error", (_err) => {
+          current = null;
+          broadcast("revision-complete", {
+            sessionId,
+            nodeId,
+            exitCode: -1,
+            error: true
+          });
+        });
+        return { ok: true, sessionId };
+      }
+      function stop() {
+        if (!current) {
+          return { error: "not_running", status: 404 };
+        }
+        current.proc.kill("SIGTERM");
+        return { ok: true };
+      }
+      function running() {
+        return current ? current.sessionId : null;
+      }
+      return { revise, stop, running };
+    }
+    if (require.main === module2) {
+      const runner = createRevisionRunner(/* @__PURE__ */ new Set(), ".", () => {
+      });
+      console.log("revise:", typeof runner.revise);
+      console.log("stop:", typeof runner.stop);
+      console.log("running:", typeof runner.running);
+      console.log("OK");
+    }
+    module2.exports = { createRevisionRunner };
+  }
+});
+
+// src/commands/workflow-state.js
+var require_workflow_state = __commonJS({
+  "src/commands/workflow-state.js"(exports2, module2) {
+    "use strict";
+    var DONE_STATUSES = /* @__PURE__ */ new Set(["DONE", "KEPT", "HONORED"]);
+    var EXECUTING_STATUSES = /* @__PURE__ */ new Set(["EXECUTING", "IN_PROGRESS", "RUNNING"]);
+    function computeWorkflowState(graph, runningActionIds) {
+      const declarations = graph.declarations || [];
+      const milestones = graph.milestones || [];
+      const actions = graph.actions || [];
+      const running = runningActionIds || /* @__PURE__ */ new Set();
+      const actionsDone = actions.filter((a) => DONE_STATUSES.has((a.status || "").toUpperCase())).length;
+      const actionsExecuting = actions.filter(
+        (a) => EXECUTING_STATUSES.has((a.status || "").toUpperCase()) || running.has(a.id)
+      ).length;
+      const totalActions = actions.length;
+      const percentage = totalActions > 0 ? Math.round(actionsDone / totalActions * 100) : 0;
+      const progress = {
+        declarations: declarations.length,
+        milestones: milestones.length,
+        actions: totalActions,
+        actionsDone,
+        actionsExecuting,
+        percentage
+      };
+      if (declarations.length === 0) {
+        return {
+          state: "empty",
+          nextStep: {
+            label: "Create your first declaration",
+            action: "create-declaration"
+          },
+          progress
+        };
+      }
+      if (milestones.length === 0) {
+        return {
+          state: "declarations_only",
+          nextStep: {
+            label: "Derive milestones from declarations",
+            action: "derive-milestones"
+          },
+          progress
+        };
+      }
+      const milestonesWithActions = /* @__PURE__ */ new Set();
+      for (const a of actions) {
+        if (Array.isArray(a.causes)) {
+          for (const mId of a.causes) {
+            milestonesWithActions.add(mId.toUpperCase());
+          }
+        }
+      }
+      const pendingMilestones = milestones.filter((m) => {
+        const mStatus = (m.status || "").toUpperCase();
+        if (DONE_STATUSES.has(mStatus)) return false;
+        return !milestonesWithActions.has(m.id.toUpperCase());
+      });
+      if (pendingMilestones.length > 0) {
+        const target = pendingMilestones[0];
+        return {
+          state: "milestones_pending",
+          nextStep: {
+            label: `Derive actions for ${target.id}`,
+            action: "derive-actions",
+            targetId: target.id
+          },
+          progress
+        };
+      }
+      if (actionsExecuting > 0) {
+        const executingAction = actions.find(
+          (a) => EXECUTING_STATUSES.has((a.status || "").toUpperCase()) || running.has(a.id)
+        );
+        return {
+          state: "executing",
+          nextStep: {
+            label: executingAction ? `Executing ${executingAction.id}` : "Execution in progress",
+            action: "view-execution",
+            targetId: executingAction ? executingAction.id : void 0
+          },
+          progress
+        };
+      }
+      if (totalActions > 0 && actionsDone === totalActions) {
+        return {
+          state: "complete",
+          nextStep: {
+            label: "All actions complete",
+            action: "view-summary"
+          },
+          progress
+        };
+      }
+      const pendingActions = actions.filter((a) => {
+        const s = (a.status || "").toUpperCase();
+        return !DONE_STATUSES.has(s) && !EXECUTING_STATUSES.has(s);
+      });
+      const nextAction = pendingActions[0];
+      return {
+        state: "actions_pending",
+        nextStep: {
+          label: nextAction ? `Execute ${nextAction.id}` : "Plan next actions",
+          action: nextAction ? "execute-action" : "plan-actions",
+          targetId: nextAction ? nextAction.id : void 0
+        },
+        progress
+      };
+    }
+    module2.exports = { computeWorkflowState };
+  }
+});
+
+// src/commands/play.js
+var require_play = __commonJS({
+  "src/commands/play.js"(exports2, module2) {
+    "use strict";
+    var { spawn } = require("node:child_process");
+    var fs = require("node:fs");
+    var path = require("node:path");
+    var { runLoadGraph: runLoadGraph2 } = require_load_graph();
+    var { runGetExecPlan: runGetExecPlan2 } = require_get_exec_plan();
+    var { findMilestoneFolder } = require_milestone_folders();
+    var DONE_STATUSES = /* @__PURE__ */ new Set(["DONE", "KEPT", "HONORED", "RENEGOTIATED"]);
+    function computePlayOrder(graph) {
+      const milestones = graph.milestones || [];
+      const actions = graph.actions || [];
+      const candidates = milestones.filter(
+        (m) => (m.classification || "agent") === "agent" && !DONE_STATUSES.has((m.status || "").toUpperCase())
+      );
+      if (candidates.length === 0) {
+        return { waves: [] };
+      }
+      const candidateIds = new Set(candidates.map((m) => m.id.toUpperCase()));
+      const deps = /* @__PURE__ */ new Map();
+      for (const m of candidates) {
+        const mId = m.id.toUpperCase();
+        const mDeps = (m.dependsOn || []).map((d) => d.toUpperCase()).filter((d) => candidateIds.has(d));
+        deps.set(mId, mDeps);
+      }
+      const waves = [];
+      const placed = /* @__PURE__ */ new Set();
+      while (placed.size < candidates.length) {
+        const wave = [];
+        for (const m of candidates) {
+          const mId = m.id.toUpperCase();
+          if (placed.has(mId)) continue;
+          const mDeps = deps.get(mId) || [];
+          const allDepsMet = mDeps.every(
+            (d) => placed.has(d) || !candidateIds.has(d)
+          );
+          if (!allDepsMet) continue;
+          const milestoneActions = actions.filter(
+            (a) => (a.causes || []).some((c) => c.toUpperCase() === mId) && !DONE_STATUSES.has((a.status || "").toUpperCase())
+          ).map((a) => a.id);
+          if (milestoneActions.length > 0) {
+            wave.push({ milestoneId: m.id, actions: milestoneActions });
+          }
+        }
+        if (wave.length === 0) {
+          let progress = false;
+          for (const m of candidates) {
+            const mId = m.id.toUpperCase();
+            if (placed.has(mId)) continue;
+            const mDeps = deps.get(mId) || [];
+            const allDepsMet = mDeps.every(
+              (d) => placed.has(d) || !candidateIds.has(d)
+            );
+            if (allDepsMet) {
+              placed.add(mId);
+              progress = true;
+            }
+          }
+          if (!progress) break;
+          continue;
+        }
+        waves.push(wave);
+        for (const entry of wave) {
+          placed.add(entry.milestoneId.toUpperCase());
+        }
+        for (const m of candidates) {
+          const mId = m.id.toUpperCase();
+          if (placed.has(mId)) continue;
+          const mDeps = deps.get(mId) || [];
+          if (mDeps.every((d) => placed.has(d) || !candidateIds.has(d))) {
+            placed.add(mId);
+          }
+        }
+      }
+      return { waves };
+    }
+    function appendLog(logPath, line) {
+      if (!logPath) return;
+      try {
+        fs.appendFileSync(logPath, line + "\n", "utf-8");
+      } catch (_) {
+      }
+    }
+    function createPlayRunner(sseClients, cwd) {
+      let isRunning = false;
+      let stopRequested = false;
+      const activeProcesses = /* @__PURE__ */ new Map();
+      let playState = null;
+      function broadcast(event, data) {
+        const payload = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+        for (const client of sseClients) {
+          try {
+            client.write(payload);
+          } catch (_) {
+            sseClients.delete(client);
+          }
+        }
+      }
+      function executeAction(actionId, milestoneId) {
+        return new Promise((resolve) => {
+          const prompt = `Run /declare:execute ${milestoneId} for action ${actionId} only. Do not ask questions, execute autonomously.`;
+          const proc = spawn("claude", ["-p", prompt, "--no-input"], {
+            cwd,
+            env: { ...process.env, FORCE_COLOR: "0" }
+          });
+          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, `
+=== START ${actionId} (play) @ ${(/* @__PURE__ */ new Date()).toISOString()} ===`);
+          let stdoutBuf = "";
+          let stderrBuf = "";
+          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 (proc.stderr) {
+            proc.stderr.on("data", (chunk) => {
+              stderrBuf += chunk.toString();
+              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}`);
+              }
+            });
+          }
+          proc.on("close", (exitCode) => {
+            const code = exitCode ?? -1;
+            appendLog(logPath, `=== END ${actionId} (play) @ ${(/* @__PURE__ */ new Date()).toISOString()} exit=${code} ===
+`);
+            activeProcesses.delete(actionId);
+            broadcast("action-complete", { actionId, exitCode: code });
+            resolve({ actionId, exitCode: code });
+          });
+          proc.on("error", (_err) => {
+            appendLog(logPath, `=== ERROR ${actionId} (play) @ ${(/* @__PURE__ */ new Date()).toISOString()} ===
+`);
+            activeProcesses.delete(actionId);
+            broadcast("action-complete", { actionId, exitCode: -1 });
+            resolve({ actionId, exitCode: -1 });
+          });
+        });
+      }
+      function start() {
+        if (isRunning) {
+          return { error: "Play is already running" };
+        }
+        const graph = runLoadGraph2(cwd);
+        if ("error" in graph) {
+          return { error: graph.error };
+        }
+        let waves;
+        const manifest = loadManifest(cwd);
+        if (manifest) {
+          const actionStatusMap = /* @__PURE__ */ new Map();
+          for (const a of graph.actions || []) {
+            actionStatusMap.set(a.id.toUpperCase(), (a.status || "").toUpperCase());
+          }
+          waves = manifest.waves.map((w) => {
+            const milestones = w.milestones.map((m) => {
+              const pendingActions = m.actions.filter((actionId) => {
+                const status2 = actionStatusMap.get(actionId.toUpperCase()) || "";
+                return !DONE_STATUSES.has(status2);
+              });
+              return pendingActions.length > 0 ? { milestoneId: m.id, actions: pendingActions } : null;
+            }).filter(Boolean);
+            return milestones.length > 0 ? milestones : null;
+          }).filter(Boolean);
+        } else {
+          waves = computePlayOrder(graph).waves;
+        }
+        if (waves.length === 0) {
+          return { error: "No ready agent milestones with pending actions" };
+        }
+        const allActions = [];
+        for (const wave of waves) {
+          for (const entry of wave) {
+            for (const actionId of entry.actions) {
+              const action = (graph.actions || []).find((a) => a.id.toUpperCase() === actionId.toUpperCase());
+              if (action) allActions.push(action);
+            }
+          }
+        }
+        const unapprovedActions = allActions.filter((a) => a.reviewState !== "approved");
+        if (unapprovedActions.length > 0) {
+          return {
+            error: "Cannot play: unapproved actions exist",
+            unapproved: unapprovedActions.map((a) => ({ id: a.id, title: a.title, reviewState: a.reviewState || "draft" }))
+          };
+        }
+        isRunning = true;
+        stopRequested = false;
+        playState = {
+          currentWave: 0,
+          totalWaves: waves.length,
+          waveItems: [],
+          completedActions: [],
+          failedActions: []
+        };
+        broadcast("play-start", {
+          totalWaves: waves.length,
+          waves: waves.map((w, i) => ({
+            wave: i + 1,
+            milestones: w.map((e) => ({ milestoneId: e.milestoneId, actions: e.actions }))
+          }))
+        });
+        (async () => {
+          for (let wi = 0; wi < waves.length; wi++) {
+            if (stopRequested) break;
+            const wave = waves[wi];
+            playState.currentWave = wi + 1;
+            playState.waveItems = wave;
+            broadcast("play-wave-start", {
+              wave: wi + 1,
+              totalWaves: waves.length,
+              milestones: wave.map((e) => ({ milestoneId: e.milestoneId, actions: e.actions }))
+            });
+            const promises = [];
+            for (const entry of wave) {
+              for (const actionId of entry.actions) {
+                if (stopRequested) break;
+                promises.push(executeAction(actionId, entry.milestoneId));
+              }
+              if (stopRequested) break;
+            }
+            const results = await Promise.all(promises);
+            for (const r of results) {
+              if (r.exitCode === 0) {
+                playState.completedActions.push(r.actionId);
+              } else {
+                playState.failedActions.push(r.actionId);
+              }
+            }
+            broadcast("play-wave-complete", {
+              wave: wi + 1,
+              totalWaves: waves.length,
+              completed: results.filter((r) => r.exitCode === 0).map((r) => r.actionId),
+              failed: results.filter((r) => r.exitCode !== 0).map((r) => r.actionId)
+            });
+          }
+          const finalState = { ...playState };
+          isRunning = false;
+          playState = null;
+          broadcast("play-complete", {
+            completed: finalState.completedActions,
+            failed: finalState.failedActions,
+            stopped: stopRequested
+          });
+          stopRequested = false;
+        })().catch((_err) => {
+          isRunning = false;
+          playState = null;
+          broadcast("play-complete", { completed: [], failed: [], stopped: false, error: String(_err) });
+        });
+        return { ok: true, waves: waves.length };
+      }
+      function stop() {
+        if (!isRunning) {
+          return { error: "Play is not running" };
+        }
+        stopRequested = true;
+        for (const [, proc] of activeProcesses) {
+          try {
+            proc.kill("SIGTERM");
+          } catch (_) {
+          }
+        }
+        return { ok: true };
+      }
+      function running() {
+        return isRunning;
+      }
+      function status() {
+        if (!playState) return null;
+        return {
+          running: isRunning,
+          currentWave: playState.currentWave,
+          totalWaves: playState.totalWaves,
+          activeActions: [...activeProcesses.keys()],
+          completedActions: playState.completedActions,
+          failedActions: playState.failedActions
+        };
+      }
+      return { start, stop, running, status };
+    }
+    function loadManifest(cwd) {
+      const manifestPath = path.join(cwd, ".planning", "execution-manifest.json");
+      try {
+        const raw = fs.readFileSync(manifestPath, "utf8");
+        const data = JSON.parse(raw);
+        if (data && Array.isArray(data.waves) && data.waves.length > 0) {
+          return data;
+        }
+        return null;
+      } catch (_) {
+        return null;
+      }
+    }
+    module2.exports = { computePlayOrder, createPlayRunner, loadManifest };
+  }
+});
+
+// src/server/pipeline-runner.js
+var require_pipeline_runner = __commonJS({
+  "src/server/pipeline-runner.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 (_) {
+      }
+    }
+    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 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
+**Commits:** ${startSha}..${endSha}
+
+## Results
+
+| # | Action | Milestone | Status | Duration | Retried |
+|---|--------|-----------|--------|----------|---------|
+${rows}
+## Summary
+
+- **Passed:** ${passed}
+- **Failed:** ${failed}
+- **Total:** ${results.length}
+`;
+        const reportPath = path.join(cwd, ".planning", "execution-report.md");
+        fs.writeFileSync(reportPath, report, "utf8");
+        return reportPath;
+      } catch (_) {
+        return null;
+      }
+    }
+    function createPipelineRunner(sseClients, cwd) {
+      let isRunning = false;
+      let stopRequested = false;
+      const activeProcesses = /* @__PURE__ */ new Map();
+      let results = [];
+      let pipelineState = null;
+      let pausedOnFailure = null;
+      let skipResolve = null;
+      const outputBuffers = {};
+      let totalActionCount = 0;
+      function persistState() {
+        if (!pipelineState) {
+          try {
+            fs.unlinkSync(path.join(cwd, STATE_FILE));
+          } catch (_) {
+          }
+          return;
+        }
+        const state = {
+          running: isRunning,
+          currentWave: pipelineState.currentWave,
+          totalWaves: pipelineState.totalWaves,
+          totalActions: totalActionCount,
+          completedActions: pipelineState.completedActions,
+          failedActions: pipelineState.failedActions,
+          stoppedActions: pipelineState.stoppedActions,
+          activeActions: [...activeProcesses.keys()],
+          outputBuffers,
+          pausedOnFailure,
+          timestamp: Date.now()
+        };
+        try {
+          fs.writeFileSync(path.join(cwd, STATE_FILE), JSON.stringify(state, null, 2));
+        } catch (_) {
+        }
+      }
+      function broadcast(event, data) {
+        const payload = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+        for (const client of sseClients) {
+          try {
+            client.write(payload);
+          } catch (_) {
+            sseClients.delete(client);
+          }
+        }
+      }
+      function loadManifest() {
+        const manifestPath = path.join(cwd, ".planning", "execution-manifest.json");
+        if (!fs.existsSync(manifestPath)) {
+          return { error: "Execution manifest not found at .planning/execution-manifest.json" };
+        }
+        try {
+          const raw = fs.readFileSync(manifestPath, "utf8");
+          const data = JSON.parse(raw);
+          if (!data || !Array.isArray(data.waves) || data.waves.length === 0) {
+            return { error: "Execution manifest is malformed: waves must be a non-empty array" };
+          }
+          for (let i = 0; i < data.waves.length; i++) {
+            const wave = data.waves[i];
+            if (!Array.isArray(wave.milestones)) {
+              return { error: `Execution manifest malformed: waves[${i}].milestones must be an array` };
+            }
+            for (let j = 0; j < wave.milestones.length; j++) {
+              const m = wave.milestones[j];
+              if (typeof m.id !== "string" || !m.id) {
+                return { error: `Execution manifest malformed: waves[${i}].milestones[${j}].id must be a non-empty string` };
+              }
+              if (!Array.isArray(m.actions)) {
+                return { error: `Execution manifest malformed: waves[${i}].milestones[${j}].actions must be an array` };
+              }
+            }
+          }
+          return { waves: data.waves };
+        } catch (err) {
+          return { error: `Failed to parse execution manifest: ${String(err)}` };
+        }
+      }
+      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, `
+=== 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);
+                }
+              }
+            });
+          }
+          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);
+                }
+              }
+            });
+          }
+          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} ===
+`);
+            activeProcesses.delete(actionId);
+            broadcast("action-complete", { actionId, exitCode: -1, durationMs });
+            resolve({ actionId, milestoneId, exitCode: -1, stderrOutput: stderrFull, durationMs, startedAt, completedAt, retried: false, attempts: 1 });
+          });
+        });
+      }
+      function start() {
+        if (isRunning) {
+          return { error: "Pipeline is already running" };
+        }
+        const manifest = loadManifest();
+        if ("error" in manifest) {
+          return { error: manifest.error };
+        }
+        const waves = manifest.waves;
+        isRunning = true;
+        stopRequested = false;
+        results = [];
+        pipelineState = {
+          currentWave: 0,
+          totalWaves: waves.length,
+          completedActions: [],
+          failedActions: [],
+          stoppedActions: [],
+          skippedActions: []
+        };
+        let totalActions = 0;
+        for (const wave of waves) {
+          for (const m of wave.milestones) {
+            totalActions += m.actions.length;
+          }
+        }
+        totalActionCount = totalActions;
+        persistState();
+        broadcast("pipeline-start", {
+          totalWaves: waves.length,
+          totalActions,
+          waves: waves.map((w, i) => ({
+            wave: i + 1,
+            milestones: w.milestones.map((m) => ({ id: m.id, actions: m.actions }))
+          }))
+        });
+        (async () => {
+          const pipelineStartTime = Date.now();
+          let startSha = "unknown";
+          try {
+            startSha = execSync("git rev-parse --short HEAD", { cwd }).toString().trim();
+          } catch (_) {
+          }
+          for (let wi = 0; wi < waves.length; wi++) {
+            if (stopRequested) break;
+            const wave = waves[wi];
+            pipelineState.currentWave = wi + 1;
+            persistState();
+            broadcast("pipeline-wave-start", {
+              wave: wi + 1,
+              totalWaves: waves.length,
+              milestones: wave.milestones.map((m) => ({ id: m.id, actions: m.actions }))
+            });
+            const promises = [];
+            for (const milestone of wave.milestones) {
+              for (const actionId of milestone.actions) {
+                if (stopRequested) break;
+                promises.push(executeAction(actionId, milestone.id));
+              }
+              if (stopRequested) break;
+            }
+            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)) {
+                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,
+                  `
+=== RETRY ${r.actionId} (attempt 2) ===`
+                );
+                const retryResult = await executeAction(r.actionId, r.milestoneId);
+                retryResult.retried = true;
+                retryResult.attempts = 2;
+                waveResults[ri] = retryResult;
+              }
+            }
+            results.push(...waveResults);
+            for (const r of waveResults) {
+              if (r.exitCode === 0) {
+                pipelineState.completedActions.push(r.actionId);
+              } else {
+                pipelineState.failedActions.push(r.actionId);
+              }
+            }
+            persistState();
+            broadcast("pipeline-wave-complete", {
+              wave: wi + 1,
+              totalWaves: waves.length,
+              completed: waveResults.filter((r) => r.exitCode === 0).map((r) => r.actionId),
+              failed: waveResults.filter((r) => r.exitCode !== 0).map((r) => r.actionId)
+            });
+            const failedInWave = waveResults.filter((r) => r.exitCode !== 0);
+            if (failedInWave.length > 0 && !stopRequested) {
+              const firstFailed = failedInWave[0];
+              pausedOnFailure = { actionId: firstFailed.actionId, exitCode: firstFailed.exitCode, waveIndex: wi };
+              persistState();
+              broadcast("pipeline-paused", {
+                actionId: firstFailed.actionId,
+                exitCode: firstFailed.exitCode,
+                wave: wi + 1,
+                totalWaves: waves.length,
+                failedActions: failedInWave.map((r) => r.actionId)
+              });
+              const decision = await new Promise((resolve) => {
+                skipResolve = resolve;
+              });
+              skipResolve = null;
+              if (decision === "stop") {
+                stopRequested = true;
+                pausedOnFailure = null;
+                break;
+              }
+              for (const f of failedInWave) {
+                pipelineState.skippedActions.push(f.actionId);
+              }
+              pausedOnFailure = null;
+              broadcast("pipeline-resumed", { wave: wi + 1, skipped: failedInWave.map((r) => r.actionId) });
+            }
+          }
+          const finalState = { ...pipelineState };
+          const finalResults = [...results];
+          isRunning = false;
+          if (stopRequested) {
+            for (const actionId of activeProcesses.keys()) {
+              finalState.stoppedActions.push(actionId);
+            }
+          }
+          const reportPath = generateExecutionReport(cwd, finalResults, pipelineStartTime, stopRequested, startSha);
+          if (reportPath) {
+            broadcast("pipeline-report", { path: ".planning/execution-report.md" });
+          }
+          broadcast("pipeline-complete", {
+            completed: finalState.completedActions,
+            failed: finalState.failedActions,
+            stopped: stopRequested ? finalState.stoppedActions : [],
+            results: finalResults,
+            reportPath: reportPath ? ".planning/execution-report.md" : null
+          });
+          stopRequested = false;
+          pausedOnFailure = null;
+          pipelineState = null;
+          persistState();
+        })().catch((_err) => {
+          isRunning = false;
+          pausedOnFailure = null;
+          pipelineState = null;
+          persistState();
+          broadcast("pipeline-complete", {
+            completed: [],
+            failed: [],
+            stopped: [],
+            error: String(_err),
+            results
+          });
+        });
+        return { ok: true, waves: waves.length };
+      }
+      function stop() {
+        if (!isRunning) {
+          return { error: "Pipeline is not running" };
+        }
+        stopRequested = true;
+        if (pausedOnFailure && skipResolve) {
+          skipResolve("stop");
+          skipResolve = null;
+        }
+        for (const [, proc] of activeProcesses) {
+          try {
+            proc.kill("SIGTERM");
+          } catch (_) {
+          }
+        }
+        persistState();
+        return { ok: true };
+      }
+      function running() {
+        return isRunning;
+      }
+      function status() {
+        if (!pipelineState) return null;
+        return {
+          running: isRunning,
+          currentWave: pipelineState.currentWave,
+          totalWaves: pipelineState.totalWaves,
+          activeActions: [...activeProcesses.keys()],
+          completedActions: pipelineState.completedActions,
+          failedActions: pipelineState.failedActions,
+          results
+        };
+      }
+      function skip() {
+        if (!pausedOnFailure) {
+          return { error: "Pipeline is not paused" };
+        }
+        if (skipResolve) {
+          skipResolve("skip");
+          skipResolve = null;
+        }
+        return { ok: true };
+      }
+      function paused() {
+        return pausedOnFailure;
+      }
+      function getFullState() {
+        if (!isRunning && !pausedOnFailure) return null;
+        return {
+          running: isRunning,
+          currentWave: pipelineState ? pipelineState.currentWave : 0,
+          totalWaves: pipelineState ? pipelineState.totalWaves : 0,
+          totalActions: totalActionCount,
+          completedActions: pipelineState ? pipelineState.completedActions : [],
+          failedActions: pipelineState ? pipelineState.failedActions : [],
+          activeActions: [...activeProcesses.keys()],
+          outputBuffers,
+          pausedOnFailure
+        };
+      }
+      return { start, stop, skip, running, paused, status, getFullState };
+    }
+    module2.exports = { createPipelineRunner };
+  }
+});
+
+// src/server/index.js
+var require_server = __commonJS({
+  "src/server/index.js"(exports2, module2) {
+    "use strict";
+    var http = require("node:http");
+    var fs = require("node:fs");
+    var net = require("node:net");
+    var path = require("node:path");
+    var { runLoadGraph: runLoadGraph2 } = require_load_graph();
+    var { runStatus: runStatus2 } = require_status();
+    var { runGetExecPlan: runGetExecPlan2 } = require_get_exec_plan();
+    var { runAddDeclaration: runAddDeclaration2 } = require_add_declaration();
+    var { runUpdateDeclaration: runUpdateDeclaration2 } = require_update_declaration();
+    var { runDeleteDeclaration: runDeleteDeclaration2 } = require_delete_declaration();
+    var { createProcessManager } = require_process_manager();
+    var { createDerivationRunner } = require_derivation_runner();
+    var { createActionDerivationRunner } = require_action_derivation_runner();
+    var { createRevisionRunner } = require_revision_runner();
+    var { runAddMilestonesBatch: runAddMilestonesBatch2 } = require_add_milestones_batch();
+    var { buildDagFromDisk } = require_build_dag();
+    var { computeWorkabilityPath, VALID_REVIEW_STATES } = require_engine();
+    var { findMilestoneFolder } = require_milestone_folders();
+    var { parseFutureFile, writeFutureFile } = require_future();
+    var { parsePlanFile, writePlanFile, updateActionStatus } = require_plan();
+    var { parseMilestonesFile, writeMilestonesFile } = require_milestones();
+    var { computeWorkflowState } = require_workflow_state();
+    var { createPlayRunner } = require_play();
+    var { computeReadiness } = require_readiness();
+    var { createPipelineRunner } = require_pipeline_runner();
+    var MIME_TYPES = {
+      ".html": "text/html; charset=utf-8",
+      ".js": "application/javascript; charset=utf-8",
+      ".css": "text/css; charset=utf-8",
+      ".json": "application/json; charset=utf-8",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".ico": "image/x-icon"
+    };
+    function getPublicDir(cwd) {
+      const installed = path.join(cwd, ".claude", "server", "public");
+      if (fs.existsSync(installed)) return installed;
+      const bundled = path.join(__dirname, "public");
+      if (fs.existsSync(bundled)) return bundled;
+      return path.join(cwd, "src", "server", "public");
+    }
+    function sendJson(res, statusCode, data) {
+      const body = JSON.stringify(data, null, 2);
+      res.writeHead(statusCode, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Content-Length": Buffer.byteLength(body),
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type"
+      });
+      res.end(body);
+    }
+    function readJsonBody(req) {
+      return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        const MAX_SIZE = 64 * 1024;
+        req.on("data", (chunk) => {
+          size += chunk.length;
+          if (size > MAX_SIZE) {
+            reject(new Error("Request body too large (max 64KB)"));
+            req.destroy();
+            return;
+          }
+          chunks.push(chunk);
+        });
+        req.on("end", () => {
+          try {
+            const raw = Buffer.concat(chunks).toString("utf-8");
+            resolve(JSON.parse(raw));
+          } catch (err) {
+            reject(new Error("Invalid JSON body"));
+          }
+        });
+        req.on("error", reject);
+      });
+    }
+    function sendFile(res, filePath) {
+      const ext = path.extname(filePath).toLowerCase();
+      const contentType = MIME_TYPES[ext] || "application/octet-stream";
+      fs.readFile(filePath, (err, data) => {
+        if (err) {
+          res.writeHead(404, { "Content-Type": "text/plain" });
+          res.end("Not Found");
+          return;
+        }
+        res.writeHead(200, {
+          "Content-Type": contentType,
+          "Content-Length": data.length,
+          "Cache-Control": "no-cache, no-store, must-revalidate"
+        });
+        res.end(data);
+      });
+    }
+    function handleGraph(res, cwd) {
+      try {
+        const graph = runLoadGraph2(cwd);
+        if ("error" in graph) {
+          sendJson(res, 500, { error: graph.error });
+          return;
+        }
+        sendJson(res, 200, graph);
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    function handleStatus(res, cwd) {
+      try {
+        const status = runStatus2(cwd);
+        if ("error" in status) {
+          sendJson(res, 500, { error: status.error });
+          return;
+        }
+        sendJson(res, 200, status);
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    function handleMilestone(res, cwd, milestoneId) {
+      try {
+        const graph = runLoadGraph2(cwd);
+        if ("error" in graph) {
+          sendJson(res, 500, { error: graph.error });
+          return;
+        }
+        const normalizedId = milestoneId.toUpperCase();
+        const milestone = graph.milestones.find(
+          (m) => m.id.toUpperCase() === normalizedId
+        );
+        if (!milestone) {
+          sendJson(res, 404, { error: `Milestone '${milestoneId}' not found` });
+          return;
+        }
+        const milestoneActions = graph.actions.filter((a) => {
+          if (Array.isArray(a.causes)) {
+            return a.causes.some((c) => c.toUpperCase() === normalizedId);
+          }
+          return false;
+        });
+        sendJson(res, 200, {
+          milestone,
+          actions: milestoneActions
+        });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    function handleMilestoneLog(res, cwd, milestoneId) {
+      const planningDir = path.join(cwd, ".planning");
+      const milestoneFolder = findMilestoneFolder(planningDir, milestoneId);
+      if (!milestoneFolder) {
+        sendJson(res, 404, { error: "Milestone folder not found" });
+        return;
+      }
+      const logPath = path.join(milestoneFolder, "execution.log");
+      fs.readFile(logPath, "utf-8", (err, data) => {
+        if (err) {
+          res.writeHead(200, {
+            "Content-Type": "text/plain; charset=utf-8",
+            "Access-Control-Allow-Origin": "*"
+          });
+          res.end("");
+          return;
+        }
+        res.writeHead(200, {
+          "Content-Type": "text/plain; charset=utf-8",
+          "Content-Length": Buffer.byteLength(data),
+          "Access-Control-Allow-Origin": "*"
+        });
+        res.end(data);
+      });
+    }
+    function handleWorkability(res, cwd, nodeId) {
+      try {
+        const result = buildDagFromDisk(cwd);
+        if ("error" in result && !("dag" in result)) {
+          sendJson(res, 500, { error: result.error });
+          return;
+        }
+        const { dag } = result;
+        const normalizedId = nodeId.toUpperCase();
+        if (!dag.getNode(normalizedId)) {
+          sendJson(res, 404, { error: `Node '${nodeId}' not found` });
+          return;
+        }
+        const path2 = computeWorkabilityPath(dag, normalizedId);
+        sendJson(res, 200, path2);
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    function handleWorkflowState(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 = computeWorkflowState(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);
+        if (!body || !Array.isArray(body.waves) || body.waves.length === 0) {
+          sendJson(res, 400, { error: "waves must be a non-empty array" });
+          return;
+        }
+        for (let i = 0; i < body.waves.length; i++) {
+          const wave = body.waves[i];
+          if (!Array.isArray(wave.milestones)) {
+            sendJson(res, 400, { error: `waves[${i}].milestones must be an array` });
+            return;
+          }
+          for (let j = 0; j < wave.milestones.length; j++) {
+            const m = wave.milestones[j];
+            if (typeof m.id !== "string" || !m.id) {
+              sendJson(res, 400, { error: `waves[${i}].milestones[${j}].id must be a non-empty string` });
+              return;
+            }
+            if (!Array.isArray(m.actions)) {
+              sendJson(res, 400, { error: `waves[${i}].milestones[${j}].actions must be an array` });
+              return;
+            }
+          }
+        }
+        const manifest = {
+          waves: body.waves,
+          confirmedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const manifestPath = path.join(cwd, ".planning", "execution-manifest.json");
+        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+        sendJson(res, 200, { ok: true });
+      } catch (err) {
+        sendJson(res, 400, { error: String(err) });
+      }
+    }
+    function handleGetManifest(res, cwd) {
+      try {
+        const manifestPath = path.join(cwd, ".planning", "execution-manifest.json");
+        if (!fs.existsSync(manifestPath)) {
+          sendJson(res, 404, { error: "No execution manifest found" });
+          return;
+        }
+        const data = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+        sendJson(res, 200, data);
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    function handleReadiness(res, cwd) {
+      try {
+        const graph = runLoadGraph2(cwd);
+        if ("error" in graph) {
+          sendJson(res, 500, { error: graph.error });
+          return;
+        }
+        sendJson(res, 200, graph.readiness || {});
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    function handleActivity(res, cwd) {
+      const activityFile = path.join(cwd, ".planning", "activity.jsonl");
+      if (!fs.existsSync(activityFile)) {
+        sendJson(res, 200, { events: [] });
+        return;
+      }
+      try {
+        const lines = fs.readFileSync(activityFile, "utf-8").split("\n").filter(Boolean).slice(-100);
+        const events = lines.map((l) => {
+          try {
+            return JSON.parse(l);
+          } catch {
+            return null;
+          }
+        }).filter(Boolean).reverse();
+        sendJson(res, 200, { events });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    function handleFileContent(req, res, cwd) {
+      try {
+        const parsedUrl = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+        const requestedPath = parsedUrl.searchParams.get("path");
+        if (!requestedPath) {
+          sendJson(res, 400, { error: "Missing 'path' query parameter" });
+          return;
+        }
+        const resolvedPath = path.resolve(cwd, requestedPath);
+        if (resolvedPath !== cwd && !resolvedPath.startsWith(cwd + path.sep)) {
+          sendJson(res, 403, { error: "Forbidden" });
+          return;
+        }
+        if (!fs.existsSync(resolvedPath)) {
+          sendJson(res, 404, { error: "File not found" });
+          return;
+        }
+        if (fs.statSync(resolvedPath).isDirectory()) {
+          sendJson(res, 400, { error: "Path is a directory" });
+          return;
+        }
+        const fileContent = fs.readFileSync(resolvedPath, "utf-8");
+        sendJson(res, 200, { path: requestedPath, content: fileContent });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    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" });
+          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 pm = getProcessManager(cwd);
+        const execResult = pm.execute(actionId, result.milestoneId);
+        if (execResult.error) {
+          sendJson(res, execResult.status || 500, { error: execResult.error });
+          return;
+        }
+        sendJson(res, 202, { ok: true, actionId });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    async function handleDerive(req, res, cwd) {
+      try {
+        const body = await readJsonBody(req);
+        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 dr = getDerivationRunner(cwd);
+        const result = dr.derive(body.declarationId || null, declarations);
+        if (result.error) {
+          sendJson(res, result.status || 500, { error: result.error });
+          return;
+        }
+        sendJson(res, 202, { ok: true, sessionId: result.sessionId });
+      } catch (err) {
+        sendJson(res, 400, { error: String(err) });
+      }
+    }
+    function handleDeriveStop(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 });
+      }
+    }
+    async function handleDeriveAccept(req, res, cwd) {
+      try {
+        const body = await readJsonBody(req);
+        if (!body.milestones || !Array.isArray(body.milestones) || body.milestones.length === 0) {
+          sendJson(res, 400, { error: "Missing or empty milestones array" });
+          return;
+        }
+        const result = runAddMilestonesBatch2(cwd, ["--json", JSON.stringify(body.milestones)]);
+        if ("error" in result) {
+          sendJson(res, 400, { error: result.error });
+          return;
+        }
+        sendJson(res, 200, result);
+        broadcastChange();
+      } catch (err) {
+        sendJson(res, 400, { error: String(err) });
+      }
+    }
+    function handleActionDerive(res, cwd, milestoneId) {
+      try {
+        const graph = runLoadGraph2(cwd);
+        if ("error" in graph) {
+          sendJson(res, 500, { error: graph.error });
+          return;
+        }
+        const normalizedId = milestoneId.toUpperCase();
         const milestone = graph.milestones.find(
           (m) => m.id.toUpperCase() === normalizedId
         );
@@ -3918,79 +6071,850 @@ var require_server = __commonJS({
           sendJson(res, 404, { error: `Milestone '${milestoneId}' not found` });
           return;
         }
-        const milestoneActions = graph.actions.filter((a) => {
-          if (Array.isArray(a.causes)) {
-            return a.causes.some((c) => c.toUpperCase() === normalizedId);
+        const existingActions = graph.actions.filter(
+          (a) => (a.causes || []).some((c) => c.toUpperCase() === normalizedId)
+        );
+        const adr = getActionDerivationRunner(cwd);
+        const result = adr.derive(
+          { id: milestone.id, title: milestone.title, status: milestone.status, realizes: milestone.realizes || [] },
+          existingActions.map((a) => ({ id: a.id, title: a.title, status: a.status, produces: a.produces || "" }))
+        );
+        if (result.error) {
+          sendJson(res, result.status || 500, { error: result.error });
+          return;
+        }
+        sendJson(res, 202, { ok: true, sessionId: result.sessionId });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    function handleActionDeriveStop(res, cwd) {
+      const adr = getActionDerivationRunner(cwd);
+      const result = adr.stop();
+      if (result.error) {
+        sendJson(res, result.status || 500, { error: result.error });
+      } else {
+        sendJson(res, 200, { ok: true });
+      }
+    }
+    async function handleActionDeriveAccept(req, res, cwd, milestoneId) {
+      try {
+        const body = await readJsonBody(req);
+        if (!body.actions || !Array.isArray(body.actions) || body.actions.length === 0) {
+          sendJson(res, 400, { error: "Missing or empty actions array" });
+          return;
+        }
+        const graph = runLoadGraph2(cwd);
+        if ("error" in graph) {
+          sendJson(res, 500, { error: graph.error });
+          return;
+        }
+        const normalizedId = milestoneId.toUpperCase();
+        const milestone = graph.milestones.find(
+          (m) => m.id.toUpperCase() === normalizedId
+        );
+        if (!milestone) {
+          sendJson(res, 404, { error: `Milestone '${milestoneId}' not found` });
+          return;
+        }
+        const planningDir = path.join(cwd, ".planning");
+        const milestoneFolder = findMilestoneFolder(planningDir, milestone.id);
+        let existingActions = [];
+        let planContent = "";
+        const planPath = milestoneFolder ? path.join(milestoneFolder, "PLAN.md") : null;
+        if (planPath && fs.existsSync(planPath)) {
+          planContent = fs.readFileSync(planPath, "utf-8");
+          const parsed = parsePlanFile(planContent);
+          existingActions = parsed.actions || [];
+        }
+        let maxActionNum = 0;
+        for (const a of graph.actions) {
+          const num = parseInt(a.id.split("-")[1], 10);
+          if (!isNaN(num) && num > maxActionNum) maxActionNum = num;
+        }
+        const newActions = [];
+        for (const input of body.actions) {
+          maxActionNum++;
+          const id = `A-${maxActionNum < 10 ? "0" + maxActionNum : maxActionNum}`;
+          newActions.push({
+            id,
+            title: input.title,
+            status: "PENDING",
+            produces: input.produces || ""
+          });
+        }
+        const allActions = [...existingActions, ...newActions];
+        const { ensureMilestoneFolder } = require_milestone_folders();
+        const folder = ensureMilestoneFolder(planningDir, milestone.id, milestone.title);
+        const targetPlanPath = path.join(folder, "PLAN.md");
+        const realizes = milestone.realizes || [];
+        const output = writePlanFile(milestone.id, milestone.title, realizes, allActions);
+        fs.writeFileSync(targetPlanPath, output, "utf-8");
+        const milestonesPath = path.join(planningDir, "MILESTONES.md");
+        if (fs.existsSync(milestonesPath)) {
+          let milestonesContent = fs.readFileSync(milestonesPath, "utf-8");
+          const rowPattern = new RegExp(`(\\|\\s*${milestone.id}\\s*\\|.*?)\\s*NO\\s*\\|\\s*$`, "m");
+          if (rowPattern.test(milestonesContent)) {
+            milestonesContent = milestonesContent.replace(rowPattern, "$1 YES |");
+            fs.writeFileSync(milestonesPath, milestonesContent, "utf-8");
+          }
+        }
+        sendJson(res, 200, {
+          actions: newActions,
+          milestoneId: milestone.id
+        });
+        broadcastChange();
+      } catch (err) {
+        sendJson(res, 400, { error: String(err) });
+      }
+    }
+    function setReviewState(cwd, nodeId, reviewState) {
+      if (!reviewState || !VALID_REVIEW_STATES.has(reviewState)) {
+        return { error: `Invalid reviewState. Must be one of: ${[...VALID_REVIEW_STATES].join(", ")}`, status: 400 };
+      }
+      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");
+        if (!fs.existsSync(futurePath)) return { error: "FUTURE.md not found", status: 404 };
+        const content = fs.readFileSync(futurePath, "utf-8");
+        const declarations = parseFutureFile(content);
+        const decl = declarations.find((d) => d.id === id);
+        if (!decl) return { error: `Declaration ${id} not found`, status: 404 };
+        decl.reviewState = reviewState;
+        const headerMatch = content.match(/^# Future: (.+)/m);
+        const projectName = headerMatch ? headerMatch[1].trim() : "Project";
+        fs.writeFileSync(futurePath, writeFutureFile(declarations, projectName), "utf-8");
+      } else if (prefix === "M") {
+        const milestonesPath = path.join(planningDir, "MILESTONES.md");
+        if (!fs.existsSync(milestonesPath)) return { error: "MILESTONES.md not found", status: 404 };
+        const content = fs.readFileSync(milestonesPath, "utf-8");
+        const { milestones } = parseMilestonesFile(content);
+        const mile = milestones.find((m) => m.id === id);
+        if (!mile) return { error: `Milestone ${id} not found`, status: 404 };
+        mile.reviewState = reviewState;
+        const nameMatch = content.match(/^# Milestones:\s*(.+)/m);
+        const pName = nameMatch ? nameMatch[1].trim() : "Project";
+        fs.writeFileSync(milestonesPath, writeMilestonesFile(milestones, pName), "utf-8");
+      } else if (prefix === "A") {
+        const milestonesDir = path.join(planningDir, "milestones");
+        if (!fs.existsSync(milestonesDir)) return { error: "No milestones directory", status: 404 };
+        let found = false;
+        const entries = fs.readdirSync(milestonesDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory() || entry.name.startsWith("_")) continue;
+          const planPath = path.join(milestonesDir, entry.name, "PLAN.md");
+          if (!fs.existsSync(planPath)) continue;
+          const content = fs.readFileSync(planPath, "utf-8");
+          const parsed = parsePlanFile(content);
+          const action = parsed.actions.find((a) => a.id === id);
+          if (!action) continue;
+          const lines = content.split("\n");
+          let inSection = false;
+          let patched = false;
+          for (let i = 0; i < lines.length; i++) {
+            if (lines[i].startsWith("### ")) {
+              inSection = lines[i].startsWith(`### ${id}:`);
+            }
+            if (inSection && !patched && /^\*\*Review:\*\*/i.test(lines[i].trim())) {
+              lines[i] = `**Review:** ${reviewState}`;
+              patched = true;
+              break;
+            }
+            if (inSection && !patched && /^\*\*Status:\*\*/i.test(lines[i].trim())) {
+              if (i + 1 < lines.length && /^\*\*Review:\*\*/i.test(lines[i + 1].trim())) {
+                lines[i + 1] = `**Review:** ${reviewState}`;
+                patched = true;
+              } else {
+                lines.splice(i + 1, 0, `**Review:** ${reviewState}`);
+                patched = true;
+              }
+              break;
+            }
+          }
+          if (patched) {
+            fs.writeFileSync(planPath, lines.join("\n"), "utf-8");
+            found = true;
+          }
+          break;
+        }
+        if (!found) return { error: `Action ${id} not found in any PLAN.md`, status: 404 };
+      } else {
+        return { error: `Unknown node type prefix: ${prefix}`, status: 400 };
+      }
+      return { ok: true, id, reviewState };
+    }
+    async function handleUpdateReviewState(req, res, cwd, nodeId) {
+      try {
+        const body = await readJsonBody(req);
+        const result = setReviewState(cwd, nodeId, body.reviewState);
+        if ("error" in result) {
+          sendJson(res, result.status || 500, { error: result.error });
+          return;
+        }
+        try {
+          const activityFile = path.join(cwd, ".planning", "activity.jsonl");
+          const entry = {
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            tool: "Review",
+            phase: "end",
+            desc: body.reviewState === "approved" ? `Approved ${nodeId}` : `Revision needed: ${nodeId}`,
+            nodeId,
+            reviewState: body.reviewState
+          };
+          fs.appendFileSync(activityFile, JSON.stringify(entry) + "\n");
+        } catch (_) {
+        }
+        sendJson(res, 200, result);
+        broadcastChange();
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    function getAnnotationsPath(cwd, nodeId) {
+      return path.join(cwd, ".planning", "annotations", `${nodeId.toUpperCase()}.json`);
+    }
+    function readAnnotations(cwd, nodeId) {
+      const filePath = getAnnotationsPath(cwd, nodeId);
+      if (!fs.existsSync(filePath)) {
+        return { nodeId: nodeId.toUpperCase(), annotations: [], revisionRound: 0 };
+      }
+      try {
+        const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        data.revisionRound = data.revisionRound || 0;
+        return data;
+      } catch (_) {
+        return { nodeId: nodeId.toUpperCase(), annotations: [], revisionRound: 0 };
+      }
+    }
+    function writeAnnotations(cwd, nodeId, data) {
+      const filePath = getAnnotationsPath(cwd, nodeId);
+      const dir = path.dirname(filePath);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+    }
+    function handleGetAnnotations(res, cwd, nodeId) {
+      try {
+        const data = readAnnotations(cwd, nodeId);
+        sendJson(res, 200, data);
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    async function handleAddAnnotation(req, res, cwd, nodeId) {
+      try {
+        const body = await readJsonBody(req);
+        const { line, text } = body;
+        if (typeof line !== "number" || line < 1) {
+          sendJson(res, 400, { error: "line must be a number >= 1" });
+          return;
+        }
+        if (typeof text !== "string" || text.trim().length === 0) {
+          sendJson(res, 400, { error: "text must be a non-empty string" });
+          return;
+        }
+        const id = "ann-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8);
+        const annotation = {
+          id,
+          line,
+          text: text.trim(),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          resolved: false
+        };
+        const data = readAnnotations(cwd, nodeId);
+        data.annotations.push(annotation);
+        writeAnnotations(cwd, nodeId, data);
+        setReviewState(cwd, nodeId, "revision_needed");
+        broadcastChange();
+        sendJson(res, 201, annotation);
+      } catch (err) {
+        sendJson(res, 400, { error: String(err) });
+      }
+    }
+    function handleDeleteAnnotation(res, cwd, nodeId, annotationId) {
+      try {
+        const data = readAnnotations(cwd, nodeId);
+        const before = data.annotations.length;
+        data.annotations = data.annotations.filter((a) => a.id !== annotationId);
+        if (data.annotations.length === before) {
+          sendJson(res, 404, { error: "Annotation not found" });
+          return;
+        }
+        writeAnnotations(cwd, nodeId, data);
+        broadcastChange();
+        sendJson(res, 200, { ok: true, id: annotationId });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    function handleIncrementRevisionRound(res, cwd, nodeId) {
+      try {
+        const data = readAnnotations(cwd, nodeId);
+        data.revisionRound = (data.revisionRound || 0) + 1;
+        writeAnnotations(cwd, nodeId, data);
+        broadcastChange();
+        sendJson(res, 200, { ok: true, revisionRound: data.revisionRound });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    var sseClients = /* @__PURE__ */ new Set();
+    var processManager = null;
+    function getProcessManager(cwd) {
+      if (!processManager) processManager = createProcessManager(sseClients, cwd);
+      return processManager;
+    }
+    var derivationRunner = null;
+    function getDerivationRunner(cwd) {
+      if (!derivationRunner) derivationRunner = createDerivationRunner(sseClients, cwd);
+      return derivationRunner;
+    }
+    var actionDerivationRunner = null;
+    function getActionDerivationRunner(cwd) {
+      if (!actionDerivationRunner) actionDerivationRunner = createActionDerivationRunner(sseClients, cwd);
+      return actionDerivationRunner;
+    }
+    var playRunner = null;
+    function getPlayRunner(cwd) {
+      if (!playRunner) playRunner = createPlayRunner(sseClients, cwd);
+      return playRunner;
+    }
+    var pipelineRunnerInstance = null;
+    function getPipelineRunner(cwd) {
+      if (!pipelineRunnerInstance) pipelineRunnerInstance = createPipelineRunner(sseClients, cwd);
+      return pipelineRunnerInstance;
+    }
+    var revisionRunner = null;
+    function getRevisionRunner(cwd) {
+      if (!revisionRunner) {
+        revisionRunner = createRevisionRunner(sseClients, cwd, (nodeId) => {
+          setReviewState(cwd, nodeId, "in_review");
+          broadcastChange();
+        });
+      }
+      return revisionRunner;
+    }
+    function broadcastChange() {
+      for (const client of sseClients) {
+        try {
+          client.write("event: change\ndata: {}\n\n");
+        } catch (_) {
+          sseClients.delete(client);
+        }
+      }
+    }
+    function watchPlanning(cwd) {
+      const planningDir = path.join(cwd, ".planning");
+      if (!fs.existsSync(planningDir)) return;
+      let graphTimer = null;
+      let activityTimer = null;
+      const activityFile = path.join(planningDir, "activity.jsonl");
+      try {
+        fs.watch(planningDir, { recursive: true }, (_evt, filename) => {
+          if (filename && filename.endsWith("activity.jsonl")) {
+            if (activityTimer) clearTimeout(activityTimer);
+            activityTimer = setTimeout(() => {
+              for (const client of sseClients) {
+                try {
+                  client.write("event: activity\ndata: {}\n\n");
+                } catch {
+                  sseClients.delete(client);
+                }
+              }
+              activityTimer = null;
+            }, 50);
+          } else {
+            if (graphTimer) clearTimeout(graphTimer);
+            graphTimer = setTimeout(() => {
+              broadcastChange();
+              graphTimer = null;
+            }, 200);
+          }
+        });
+      } catch (_) {
+      }
+    }
+    function handleGetRevisions(res, cwd, nodeId) {
+      try {
+        const id = nodeId.toUpperCase();
+        const prefix = id.split("-")[0];
+        const planningDir = path.join(cwd, ".planning");
+        let artifactPath = null;
+        if (prefix === "D") {
+          artifactPath = path.join(planningDir, "FUTURE.md");
+        } else if (prefix === "M") {
+          const folder = findMilestoneFolder(planningDir, id);
+          if (folder) artifactPath = path.join(folder, "PLAN.md");
+        } else if (prefix === "A") {
+          const graph = runLoadGraph2(cwd);
+          if (!("error" in graph)) {
+            const action = graph.actions.find((a) => a.id.toUpperCase() === id);
+            if (action) {
+              const milestoneId = (action.causes || [])[0];
+              if (milestoneId) {
+                const folder = findMilestoneFolder(planningDir, milestoneId);
+                if (folder) {
+                  const aNum = id.replace(/^A-/, "");
+                  artifactPath = path.join(folder, `A-${aNum}-EXEC-PLAN.md`);
+                  if (!fs.existsSync(artifactPath)) {
+                    artifactPath = path.join(folder, "PLAN.md");
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (!artifactPath || !fs.existsSync(artifactPath)) {
+          sendJson(res, 404, { error: "Artifact not found for node " + id });
+          return;
+        }
+        const current = fs.readFileSync(artifactPath, "utf-8");
+        const annData = readAnnotations(cwd, id);
+        const revisionRound = annData.revisionRound || 0;
+        let previous = null;
+        if (revisionRound >= 1) {
+          const prevRound = revisionRound - 1;
+          const prevPath = artifactPath.replace(".md", "") + ".v" + prevRound + ".md";
+          if (fs.existsSync(prevPath)) {
+            previous = fs.readFileSync(prevPath, "utf-8");
+          }
+        }
+        sendJson(res, 200, { current, previous, revisionRound });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    async function handleRevise(req, res, cwd, nodeId) {
+      try {
+        const id = nodeId.toUpperCase();
+        const prefix = id.split("-")[0];
+        const planningDir = path.join(cwd, ".planning");
+        let artifactPath = null;
+        if (prefix === "D") {
+          artifactPath = path.join(planningDir, "FUTURE.md");
+        } else if (prefix === "M") {
+          const folder = findMilestoneFolder(planningDir, id);
+          if (folder) artifactPath = path.join(folder, "PLAN.md");
+        } else if (prefix === "A") {
+          const graph = runLoadGraph2(cwd);
+          if (!("error" in graph)) {
+            const action = graph.actions.find((a) => a.id.toUpperCase() === id);
+            if (action) {
+              const milestoneId = (action.causes || [])[0];
+              if (milestoneId) {
+                const folder = findMilestoneFolder(planningDir, milestoneId);
+                if (folder) {
+                  const aNum = id.replace(/^A-/, "");
+                  artifactPath = path.join(folder, `A-${aNum}-EXEC-PLAN.md`);
+                  if (!fs.existsSync(artifactPath)) {
+                    artifactPath = path.join(folder, "PLAN.md");
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (!artifactPath || !fs.existsSync(artifactPath)) {
+          sendJson(res, 404, { error: "Artifact not found for node " + id });
+          return;
+        }
+        const artifactContent = fs.readFileSync(artifactPath, "utf-8");
+        const annData = readAnnotations(cwd, id);
+        const annotations = annData.annotations || [];
+        if (annotations.length === 0) {
+          sendJson(res, 400, { error: "no_annotations" });
+          return;
+        }
+        const rr = getRevisionRunner(cwd);
+        const result = rr.revise(id, artifactPath, artifactContent, annotations);
+        if (result.error) {
+          sendJson(res, result.status || 500, { error: result.error });
+          return;
+        }
+        sendJson(res, 202, { ok: true, sessionId: result.sessionId });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
+      }
+    }
+    function handleReviseStop(res, cwd) {
+      const rr = getRevisionRunner(cwd);
+      const result = rr.stop();
+      if (result.error) {
+        sendJson(res, result.status || 500, { error: result.error });
+      } else {
+        sendJson(res, 200, { ok: true });
+      }
+    }
+    var refineSession = null;
+    function buildRefinePrompt(nodeId, graph, mode, userMessage) {
+      const id = nodeId.toUpperCase();
+      const prefix = id.split("-")[0];
+      let nodeContent = "";
+      let parentContent = "";
+      let siblingsContent = "";
+      let nodeType = "";
+      if (prefix === "D") {
+        nodeType = "declaration";
+        const decl = graph.declarations.find((d) => d.id.toUpperCase() === id);
+        if (!decl) return null;
+        nodeContent = `${decl.id}: ${decl.title}
+Statement: ${decl.statement || decl.title}`;
+        siblingsContent = graph.declarations.filter((d) => d.id !== decl.id).map((d) => `${d.id}: ${d.title}`).join("\n");
+        parentContent = "This is a top-level declaration (no parent).";
+      } else if (prefix === "M") {
+        nodeType = "milestone";
+        const mile = graph.milestones.find((m) => m.id.toUpperCase() === id);
+        if (!mile) return null;
+        nodeContent = `${mile.id}: ${mile.title}
+Produces: ${mile.produces || "(none)"}`;
+        const parentDecls = graph.declarations.filter((d) => (mile.realizes || []).some((r) => r === d.id));
+        parentContent = parentDecls.map((d) => `${d.id}: ${d.title}
+Statement: ${d.statement || d.title}`).join("\n\n");
+        const siblingMiles = graph.milestones.filter((m) => m.id !== mile.id && (mile.realizes || []).some((r) => (m.realizes || []).includes(r)));
+        siblingsContent = siblingMiles.map((m) => `${m.id}: ${m.title} [${m.status}]`).join("\n");
+      } else if (prefix === "A") {
+        nodeType = "action";
+        const action = graph.actions.find((a) => a.id.toUpperCase() === id);
+        if (!action) return null;
+        nodeContent = `${action.id}: ${action.title}
+Produces: ${action.produces || "(none)"}`;
+        const parentMiles = graph.milestones.filter((m) => (action.causes || []).includes(m.id));
+        parentContent = parentMiles.map((m) => `${m.id}: ${m.title}
+Produces: ${m.produces || "(none)"}`).join("\n\n");
+        const milestoneIds = action.causes || [];
+        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"}
+
+${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 {
+        if (refineSession) {
+          sendJson(res, 409, { error: "A refine session is already running" });
+          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 prompt = buildRefinePrompt(nodeId, graph, mode, userMessage);
+        if (!prompt) {
+          sendJson(res, 404, { error: "Node not found: " + nodeId });
+          return;
+        }
+        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"], {
+          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 })}
+
+`;
+            for (const client of sseClients) {
+              try {
+                client.write(payload);
+              } catch (_) {
+                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 })}
+
+`;
+          for (const client of sseClients) {
+            try {
+              client.write(payload);
+            } catch (_) {
+              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 };
+          try {
+            fs.appendFileSync(activityFile, JSON.stringify(doneEntry) + "\n");
+          } catch (_) {
           }
-          return false;
-        });
-        sendJson(res, 200, {
-          milestone,
-          actions: milestoneActions
         });
+        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 handleActivity(res, cwd) {
-      const activityFile = path.join(cwd, ".planning", "activity.jsonl");
-      if (!fs.existsSync(activityFile)) {
-        sendJson(res, 200, { events: [] });
+    function handleRefineStop(res) {
+      if (!refineSession) {
+        sendJson(res, 404, { error: "No refine session running" });
         return;
       }
       try {
-        const lines = fs.readFileSync(activityFile, "utf-8").split("\n").filter(Boolean).slice(-100);
-        const events = lines.map((l) => {
-          try {
-            return JSON.parse(l);
-          } catch {
-            return null;
+        refineSession.proc.kill();
+      } catch (_) {
+      }
+      refineSession = null;
+      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");
           }
-        }).filter(Boolean).reverse();
-        sendJson(res, 200, { events });
+        } 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 sseClients = /* @__PURE__ */ new Set();
-    function broadcastChange() {
-      for (const client of sseClients) {
-        try {
-          client.write("event: change\ndata: {}\n\n");
-        } catch (_) {
-          sseClients.delete(client);
+    function handleArchiveNode(res, cwd, nodeId) {
+      const id = nodeId.toUpperCase();
+      const prefix = id.split("-")[0];
+      const planningDir = path.join(cwd, ".planning");
+      try {
+        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) {
+            decl.status = "DONE";
+            decl.reviewState = "approved";
+            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) {
+            mile.status = "DONE";
+            mile.reviewState = "approved";
+            const projectNameMatch = content.match(/^# Milestones:\s*(.+)/m);
+            const projectName = projectNameMatch ? projectNameMatch[1].trim() : "Project";
+            fs.writeFileSync(msPath, writeMilestonesFile(milestones, projectName), "utf-8");
+          }
+        } else if (prefix === "A") {
+          const graph = runLoadGraph2(cwd);
+          if (!("error" in graph)) {
+            const action = graph.actions.find((a) => a.id.toUpperCase() === id);
+            if (action) {
+              for (const mId of action.causes || []) {
+                const folder = findMilestoneFolder(planningDir, mId);
+                if (folder) {
+                  const planPath = path.join(folder, "PLAN.md");
+                  if (fs.existsSync(planPath)) {
+                    const content = fs.readFileSync(planPath, "utf-8");
+                    const updated = updateActionStatus(content, id, "DONE");
+                    fs.writeFileSync(planPath, updated, "utf-8");
+                  }
+                }
+              }
+            }
+          }
         }
+        const activityFile = path.join(planningDir, "activity.jsonl");
+        const entry = { ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Review", phase: "end", desc: `Archived ${id}`, nodeId: id };
+        fs.appendFileSync(activityFile, JSON.stringify(entry) + "\n");
+        const payload = `event: change
+data: ${JSON.stringify({ reason: "archive", nodeId: id })}
+
+`;
+        for (const client of sseClients) {
+          try {
+            client.write(payload);
+          } catch (_) {
+            sseClients.delete(client);
+          }
+        }
+        sendJson(res, 200, { ok: true });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
       }
     }
-    function watchPlanning(cwd) {
+    function handleDeleteNode(res, cwd, nodeId) {
+      const id = nodeId.toUpperCase();
+      const prefix = id.split("-")[0];
       const planningDir = path.join(cwd, ".planning");
-      if (!fs.existsSync(planningDir)) return;
-      let graphTimer = null;
-      let activityTimer = null;
-      const activityFile = path.join(planningDir, "activity.jsonl");
       try {
-        fs.watch(planningDir, { recursive: true }, (_evt, filename) => {
-          if (filename && filename.endsWith("activity.jsonl")) {
-            if (activityTimer) clearTimeout(activityTimer);
-            activityTimer = setTimeout(() => {
-              for (const client of sseClients) {
-                try {
-                  client.write("event: activity\ndata: {}\n\n");
-                } catch {
-                  sseClients.delete(client);
+        if (prefix === "D") {
+          const futurePath = path.join(planningDir, "FUTURE.md");
+          const content = fs.readFileSync(futurePath, "utf-8");
+          const declarations = parseFutureFile(content);
+          const filtered = declarations.filter((d) => d.id !== id);
+          if (filtered.length === declarations.length) {
+            sendJson(res, 404, { error: "Declaration not found: " + id });
+            return;
+          }
+          const projectNameMatch = content.match(/^# Future:\s*(.+)/m);
+          const projectName = projectNameMatch ? projectNameMatch[1].trim() : "Project";
+          fs.writeFileSync(futurePath, writeFutureFile(filtered, 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 filtered = milestones.filter((m) => m.id !== id);
+          if (filtered.length === milestones.length) {
+            sendJson(res, 404, { error: "Milestone not found: " + id });
+            return;
+          }
+          const projectNameMatch = content.match(/^# Milestones:\s*(.+)/m);
+          const projectName = projectNameMatch ? projectNameMatch[1].trim() : "Project";
+          fs.writeFileSync(msPath, writeMilestonesFile(filtered, projectName), "utf-8");
+        } else if (prefix === "A") {
+          const graph = runLoadGraph2(cwd);
+          if (!("error" in graph)) {
+            const action = graph.actions.find((a) => a.id.toUpperCase() === id);
+            if (action) {
+              for (const mId of action.causes || []) {
+                const folder = findMilestoneFolder(planningDir, mId);
+                if (folder) {
+                  const planPath = path.join(folder, "PLAN.md");
+                  if (fs.existsSync(planPath)) {
+                    let content = fs.readFileSync(planPath, "utf-8");
+                    const regex = new RegExp(`### ${id}:[\\s\\S]*?(?=### |$)`, "i");
+                    content = content.replace(regex, "");
+                    fs.writeFileSync(planPath, content, "utf-8");
+                  }
                 }
               }
-              activityTimer = null;
-            }, 50);
-          } else {
-            if (graphTimer) clearTimeout(graphTimer);
-            graphTimer = setTimeout(() => {
-              broadcastChange();
-              graphTimer = null;
-            }, 200);
+            }
           }
-        });
-      } catch (_) {
+        }
+        const activityFile = path.join(planningDir, "activity.jsonl");
+        const entry = { ts: (/* @__PURE__ */ new Date()).toISOString(), tool: "Review", phase: "end", desc: `Deleted ${id}`, nodeId: id };
+        fs.appendFileSync(activityFile, JSON.stringify(entry) + "\n");
+        const payload2 = `event: change
+data: ${JSON.stringify({ reason: "delete", nodeId: id })}
+
+`;
+        for (const client of sseClients) {
+          try {
+            client.write(payload2);
+          } catch (_) {
+            sseClients.delete(client);
+          }
+        }
+        sendJson(res, 200, { ok: true });
+      } catch (err) {
+        sendJson(res, 500, { error: String(err) });
       }
     }
     function route(req, res, cwd) {
@@ -4000,16 +6924,352 @@ var require_server = __commonJS({
       if (method === "OPTIONS") {
         res.writeHead(204, {
           "Access-Control-Allow-Origin": "*",
-          "Access-Control-Allow-Methods": "GET, OPTIONS",
+          "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
           "Access-Control-Allow-Headers": "Content-Type"
         });
         res.end();
         return;
       }
-      if (method !== "GET") {
+      if (method !== "GET" && method !== "POST" && method !== "PUT" && method !== "DELETE") {
         sendJson(res, 405, { error: "Method Not Allowed" });
         return;
       }
+      if (method === "POST" && urlPath === "/api/declarations") {
+        readJsonBody(req).then((body) => {
+          if (!body.title || !body.statement) {
+            sendJson(res, 400, { error: "Missing required fields: title and statement" });
+            return;
+          }
+          const result = runAddDeclaration2(cwd, ["--title", body.title, "--statement", body.statement]);
+          if ("error" in result) {
+            sendJson(res, 400, result);
+            return;
+          }
+          sendJson(res, 201, result);
+          broadcastChange();
+        }).catch((err) => sendJson(res, 400, { error: String(err) }));
+        return;
+      }
+      const declRefPutMatch = method === "PUT" && urlPath.match(/^\/api\/declarations\/([^/]+)\/ref$/);
+      if (declRefPutMatch) {
+        readJsonBody(req).then((body) => {
+          const declId = declRefPutMatch[1].toUpperCase();
+          const planningDir = path.join(cwd, ".planning");
+          const futurePath = path.join(planningDir, "FUTURE.md");
+          if (!fs.existsSync(futurePath)) {
+            sendJson(res, 404, { error: "FUTURE.md not found" });
+            return;
+          }
+          const futureContent = fs.readFileSync(futurePath, "utf-8");
+          const declarations = parseFutureFile(futureContent);
+          const decl = declarations.find((d) => d.id === declId);
+          if (!decl) {
+            sendJson(res, 404, { error: `Declaration not found: ${declId}` });
+            return;
+          }
+          const ref = {};
+          if (body.url != null) ref.url = body.url || void 0;
+          if (body.path != null) ref.path = body.path || void 0;
+          decl.ref = ref.url || ref.path ? ref : void 0;
+          const headerMatch = futureContent.match(/^# Future: (.+)/m);
+          const projectName = headerMatch ? headerMatch[1].trim() : "Project";
+          const content = writeFutureFile(declarations, projectName);
+          fs.writeFileSync(futurePath, content, "utf-8");
+          sendJson(res, 200, { id: declId, ref: decl.ref || null });
+          broadcastChange();
+        }).catch((err) => sendJson(res, 400, { error: String(err) }));
+        return;
+      }
+      const getAnnotationsMatch = method === "GET" && urlPath.match(/^\/api\/node\/([^/]+)\/annotations$/);
+      if (getAnnotationsMatch) {
+        handleGetAnnotations(res, cwd, getAnnotationsMatch[1]);
+        return;
+      }
+      const getRevisionsMatch = method === "GET" && urlPath.match(/^\/api\/node\/([^/]+)\/revisions$/);
+      if (getRevisionsMatch) {
+        handleGetRevisions(res, cwd, getRevisionsMatch[1]);
+        return;
+      }
+      const incrementRoundMatch = method === "POST" && urlPath.match(/^\/api\/node\/([^/]+)\/annotations\/increment-round$/);
+      if (incrementRoundMatch) {
+        handleIncrementRevisionRound(res, cwd, incrementRoundMatch[1]);
+        return;
+      }
+      const postAnnotationsMatch = method === "POST" && urlPath.match(/^\/api\/node\/([^/]+)\/annotations$/);
+      if (postAnnotationsMatch) {
+        handleAddAnnotation(req, res, cwd, postAnnotationsMatch[1]);
+        return;
+      }
+      const deleteAnnotationMatch = method === "DELETE" && urlPath.match(/^\/api\/node\/([^/]+)\/annotations\/([^/]+)$/);
+      if (deleteAnnotationMatch) {
+        handleDeleteAnnotation(res, cwd, deleteAnnotationMatch[1], deleteAnnotationMatch[2]);
+        return;
+      }
+      const reviewStateMatch = method === "PUT" && urlPath.match(/^\/api\/node\/([^/]+)\/review-state$/);
+      if (reviewStateMatch) {
+        handleUpdateReviewState(req, res, cwd, reviewStateMatch[1]);
+        return;
+      }
+      const declPutMatch = method === "PUT" && urlPath.match(/^\/api\/declarations\/([^/]+)$/);
+      if (declPutMatch) {
+        readJsonBody(req).then((body) => {
+          const args = ["--id", declPutMatch[1]];
+          if (body.title) {
+            args.push("--title", body.title);
+          }
+          if (body.statement) {
+            args.push("--statement", body.statement);
+          }
+          if (body.status) {
+            args.push("--status", body.status);
+          }
+          if (!body.title && !body.statement && !body.status) {
+            sendJson(res, 400, { error: "At least one of title, statement, or status must be provided" });
+            return;
+          }
+          const result = runUpdateDeclaration2(cwd, args);
+          if ("error" in result) {
+            const status = result.error.includes("not found") ? 404 : 400;
+            sendJson(res, status, result);
+            return;
+          }
+          sendJson(res, 200, result);
+          broadcastChange();
+        }).catch((err) => sendJson(res, 400, { error: String(err) }));
+        return;
+      }
+      const classifyMatch = method === "PUT" && urlPath.match(/^\/api\/milestones\/([^/]+)\/classify$/);
+      if (classifyMatch) {
+        readJsonBody(req).then((body) => {
+          const milestoneId = classifyMatch[1].toUpperCase();
+          const newClassification = body.classification === "human" ? "human" : "agent";
+          try {
+            const milestonesPath = path.join(cwd, ".planning", "MILESTONES.md");
+            if (!fs.existsSync(milestonesPath)) {
+              sendJson(res, 404, { error: "MILESTONES.md not found" });
+              return;
+            }
+            const { parseMilestonesFile: parseMF, writeMilestonesFile: writeMF } = require_milestones();
+            const content = fs.readFileSync(milestonesPath, "utf-8");
+            const { milestones: allM } = parseMF(content);
+            const target = allM.find((m) => m.id.toUpperCase() === milestoneId);
+            if (!target) {
+              sendJson(res, 404, { error: `Milestone '${milestoneId}' not found` });
+              return;
+            }
+            target.classification = newClassification;
+            const nameMatch = content.match(/^# Milestones:\s*(.+)/m);
+            const pName = nameMatch ? nameMatch[1].trim() : "Project";
+            fs.writeFileSync(milestonesPath, writeMF(allM, pName));
+            sendJson(res, 200, { ok: true, id: target.id, classification: newClassification });
+            broadcastChange();
+          } catch (err) {
+            sendJson(res, 500, { error: String(err) });
+          }
+        }).catch((err) => sendJson(res, 400, { error: String(err) }));
+        return;
+      }
+      const depsMatch = method === "PUT" && urlPath.match(/^\/api\/milestones\/([^/]+)\/depends-on$/);
+      if (depsMatch) {
+        readJsonBody(req).then((body) => {
+          const milestoneId = depsMatch[1].toUpperCase();
+          const deps = Array.isArray(body.dependsOn) ? body.dependsOn.map((d) => d.toUpperCase()) : [];
+          try {
+            const milestonesPath = path.join(cwd, ".planning", "MILESTONES.md");
+            if (!fs.existsSync(milestonesPath)) {
+              sendJson(res, 404, { error: "MILESTONES.md not found" });
+              return;
+            }
+            const { parseMilestonesFile: parseMF, writeMilestonesFile: writeMF } = require_milestones();
+            const content = fs.readFileSync(milestonesPath, "utf-8");
+            const { milestones: allM } = parseMF(content);
+            const target = allM.find((m) => m.id.toUpperCase() === milestoneId);
+            if (!target) {
+              sendJson(res, 404, { error: `Milestone '${milestoneId}' not found` });
+              return;
+            }
+            for (const depId of deps) {
+              if (!allM.find((m) => m.id.toUpperCase() === depId)) {
+                sendJson(res, 400, { error: `Dependency '${depId}' not found` });
+                return;
+              }
+            }
+            if (deps.includes(milestoneId)) {
+              sendJson(res, 400, { error: "Cannot depend on self" });
+              return;
+            }
+            target.dependsOn = deps;
+            const nameMatch = content.match(/^# Milestones:\s*(.+)/m);
+            const pName = nameMatch ? nameMatch[1].trim() : "Project";
+            fs.writeFileSync(milestonesPath, writeMF(allM, pName));
+            sendJson(res, 200, { ok: true, id: target.id, dependsOn: deps });
+            broadcastChange();
+          } catch (err) {
+            sendJson(res, 500, { error: String(err) });
+          }
+        }).catch((err) => sendJson(res, 400, { error: String(err) }));
+        return;
+      }
+      const declDeleteMatch = method === "DELETE" && urlPath.match(/^\/api\/declarations\/([^/]+)$/);
+      if (declDeleteMatch) {
+        const result = runDeleteDeclaration2(cwd, ["--id", declDeleteMatch[1]]);
+        if ("error" in result) {
+          const status = result.error.includes("not found") ? 404 : 400;
+          sendJson(res, status, result);
+          return;
+        }
+        sendJson(res, 200, result);
+        broadcastChange();
+        return;
+      }
+      const nodeDeleteMatch = method === "DELETE" && urlPath.match(/^\/api\/node\/([^/]+)$/);
+      if (nodeDeleteMatch) {
+        handleDeleteNode(res, cwd, nodeDeleteMatch[1]);
+        return;
+      }
+      if (method === "POST") {
+        const executeMatch = urlPath.match(/^\/api\/action\/([^/]+)\/execute$/);
+        if (executeMatch) {
+          handleExecuteAction(res, cwd, executeMatch[1]);
+          return;
+        }
+        const stopMatch = urlPath.match(/^\/api\/action\/([^/]+)\/stop$/);
+        if (stopMatch) {
+          const pm = getProcessManager(cwd);
+          const result = pm.stop(stopMatch[1]);
+          if (result.error) {
+            sendJson(res, result.status || 500, { error: result.error });
+          } else {
+            sendJson(res, 200, { ok: true });
+          }
+          return;
+        }
+        if (urlPath === "/api/milestones/derive") {
+          handleDerive(req, res, cwd);
+          return;
+        }
+        if (urlPath === "/api/milestones/derive/stop") {
+          handleDeriveStop(res, cwd);
+          return;
+        }
+        if (urlPath === "/api/milestones/derive/accept") {
+          handleDeriveAccept(req, res, cwd);
+          return;
+        }
+        const actionDeriveMatch = urlPath.match(/^\/api\/milestones\/([^/]+)\/actions\/derive$/);
+        if (actionDeriveMatch) {
+          handleActionDerive(res, cwd, actionDeriveMatch[1]);
+          return;
+        }
+        const actionDeriveStopMatch = urlPath.match(/^\/api\/milestones\/([^/]+)\/actions\/derive\/stop$/);
+        if (actionDeriveStopMatch) {
+          handleActionDeriveStop(res, cwd);
+          return;
+        }
+        const actionDeriveAcceptMatch = urlPath.match(/^\/api\/milestones\/([^/]+)\/actions\/derive\/accept$/);
+        if (actionDeriveAcceptMatch) {
+          handleActionDeriveAccept(req, res, cwd, actionDeriveAcceptMatch[1]);
+          return;
+        }
+        if (urlPath === "/api/play") {
+          const manifestPath = path.join(cwd, ".planning", "execution-manifest.json");
+          const hasManifest = fs.existsSync(manifestPath);
+          if (hasManifest) {
+            const graph = runLoadGraph2(cwd);
+            if ("error" in graph) {
+              sendJson(res, 500, { error: graph.error });
+              return;
+            }
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+            const actionIds = /* @__PURE__ */ new Set();
+            for (const wave of manifest.waves || []) {
+              for (const m of wave.milestones || []) {
+                for (const aid of m.actions || []) actionIds.add(aid.toUpperCase());
+              }
+            }
+            const unapproved = (graph.actions || []).filter((a) => actionIds.has(a.id.toUpperCase()) && a.reviewState !== "approved");
+            if (unapproved.length > 0) {
+              sendJson(res, 403, {
+                error: "Cannot play: unapproved actions exist",
+                unapproved: unapproved.map((a) => ({ id: a.id, title: a.title, reviewState: a.reviewState || "draft" }))
+              });
+              return;
+            }
+            const plr = getPipelineRunner(cwd);
+            const result = plr.start();
+            if (result.error) {
+              sendJson(res, 409, { error: result.error });
+            } else {
+              sendJson(res, 202, { ok: true, waves: result.waves });
+            }
+          } else {
+            const pr = getPlayRunner(cwd);
+            const result = pr.start();
+            if (result.error) {
+              const status = result.unapproved ? 403 : 409;
+              sendJson(res, status, { error: result.error, ...result.unapproved && { unapproved: result.unapproved } });
+            } else {
+              sendJson(res, 202, { ok: true, waves: result.waves });
+            }
+          }
+          return;
+        }
+        if (urlPath === "/api/play/stop") {
+          const pr = getPlayRunner(cwd);
+          const result = pr.stop();
+          const plr = getPipelineRunner(cwd);
+          if (plr.running()) plr.stop();
+          if (result.error && !plr.running()) {
+            sendJson(res, 400, { error: result.error });
+          } else {
+            sendJson(res, 200, { ok: true });
+          }
+          return;
+        }
+        if (urlPath === "/api/pipeline/skip-action") {
+          const plr = getPipelineRunner(cwd);
+          const result = plr.skip();
+          if (result.error) {
+            sendJson(res, 400, { error: result.error });
+          } else {
+            sendJson(res, 200, { ok: true });
+          }
+          return;
+        }
+        const reviseMatch = urlPath.match(/^\/api\/node\/([^/]+)\/revise$/);
+        if (reviseMatch) {
+          handleRevise(req, res, cwd, reviseMatch[1]);
+          return;
+        }
+        if (urlPath === "/api/revise/stop") {
+          handleReviseStop(res, cwd);
+          return;
+        }
+        const archiveMatch = urlPath.match(/^\/api\/node\/([^/]+)\/archive$/);
+        if (archiveMatch) {
+          handleArchiveNode(res, cwd, archiveMatch[1]);
+          return;
+        }
+        const refineMatch = urlPath.match(/^\/api\/node\/([^/]+)\/refine$/);
+        if (refineMatch) {
+          handleRefine(req, res, cwd, refineMatch[1]);
+          return;
+        }
+        if (urlPath === "/api/refine/stop") {
+          handleRefineStop(res);
+          return;
+        }
+        if (urlPath === "/api/refine/accept") {
+          handleRefineAccept(req, res, cwd);
+          return;
+        }
+        if (urlPath === "/api/execution-manifest") {
+          handleSaveManifest(req, res, cwd);
+          return;
+        }
+        sendJson(res, 404, { error: `Route not found: ${urlPath}` });
+        return;
+      }
       if (urlPath === "/events") {
         res.writeHead(200, {
           "Content-Type": "text/event-stream",
@@ -4030,15 +7290,95 @@ var require_server = __commonJS({
         handleStatus(res, cwd);
         return;
       }
+      if (urlPath === "/api/project") {
+        try {
+          const projectPath = path.join(cwd, ".planning", "PROJECT.md");
+          const content = fs.existsSync(projectPath) ? fs.readFileSync(projectPath, "utf-8") : "";
+          const titleMatch = content.match(/^#\s+(.+)/m);
+          const title = titleMatch ? titleMatch[1].trim() : path.basename(cwd);
+          const whatMatch = content.match(/## What This Is\s*\n([\s\S]*?)(?=\n##|\n$|$)/);
+          const description = whatMatch ? whatMatch[1].trim() : "";
+          const coreMatch = content.match(/## Core Value\s*\n([\s\S]*?)(?=\n##|\n$|$)/);
+          const coreValue = coreMatch ? coreMatch[1].trim() : "";
+          const stateMatch = content.match(/## Current State\s*\n([\s\S]*?)(?=\n##|\n---|$)/);
+          let currentState = "";
+          if (stateMatch) {
+            const lines = stateMatch[1].trim().split("\n").filter((l) => l.trim());
+            currentState = lines.slice(0, 3).map((l) => l.replace(/^\*\*/, "").replace(/\*\*/, "")).join(" | ");
+          }
+          sendJson(res, 200, { title, description, coreValue, currentState, folder: path.basename(cwd) });
+        } catch (err) {
+          sendJson(res, 500, { error: String(err) });
+        }
+        return;
+      }
+      const workabilityMatch = urlPath.match(/^\/api\/workability\/([^/]+)$/);
+      if (workabilityMatch) {
+        handleWorkability(res, cwd, workabilityMatch[1]);
+        return;
+      }
+      const milestoneLogMatch = urlPath.match(/^\/api\/milestone\/([^/]+)\/log$/);
+      if (milestoneLogMatch) {
+        handleMilestoneLog(res, cwd, milestoneLogMatch[1]);
+        return;
+      }
       const milestoneMatch = urlPath.match(/^\/api\/milestone\/([^/]+)$/);
       if (milestoneMatch) {
         handleMilestone(res, cwd, milestoneMatch[1]);
         return;
       }
+      if (urlPath === "/api/running") {
+        const pm = getProcessManager(cwd);
+        sendJson(res, 200, { running: pm.running() });
+        return;
+      }
+      if (urlPath === "/api/play/status") {
+        const pr = getPlayRunner(cwd);
+        const plr = getPipelineRunner(cwd);
+        sendJson(res, 200, { running: pr.running() || plr.running(), paused: plr.paused(), status: pr.status() || plr.status() });
+        return;
+      }
+      if (urlPath === "/api/pipeline/state") {
+        const plr = getPipelineRunner(cwd);
+        const state = plr.getFullState();
+        if (state) {
+          sendJson(res, 200, { active: true, ...state });
+        } else {
+          sendJson(res, 200, { active: false });
+        }
+        return;
+      }
+      if (urlPath === "/api/derivation/running") {
+        const dr = getDerivationRunner(cwd);
+        sendJson(res, 200, { running: dr.running() });
+        return;
+      }
+      const actionDeriveRunningMatch = urlPath.match(/^\/api\/milestones\/([^/]+)\/actions\/derive\/running$/);
+      if (actionDeriveRunningMatch) {
+        const adr = getActionDerivationRunner(cwd);
+        sendJson(res, 200, { running: adr.running() });
+        return;
+      }
+      if (urlPath === "/api/workflow/state") {
+        handleWorkflowState(res, cwd);
+        return;
+      }
       if (urlPath === "/api/activity") {
         handleActivity(res, cwd);
         return;
       }
+      if (urlPath === "/api/readiness") {
+        handleReadiness(res, cwd);
+        return;
+      }
+      if (urlPath === "/api/execution-manifest") {
+        handleGetManifest(res, cwd);
+        return;
+      }
+      if (urlPath === "/api/files") {
+        handleFileContent(req, res, cwd);
+        return;
+      }
       const actionMatch = urlPath.match(/^\/api\/action\/([^/]+)$/);
       if (actionMatch) {
         const result = runGetExecPlan2(cwd, ["--action", actionMatch[1]]);
@@ -4125,6 +7465,73 @@ var require_serve = __commonJS({
   }
 });
 
+// src/commands/open.js
+var require_open = __commonJS({
+  "src/commands/open.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var http = require("http");
+    var { spawn } = require("child_process");
+    function checkServer(port) {
+      return new Promise((resolve) => {
+        const req = http.get(`http://localhost:${port}/api/graph`, (res) => {
+          resolve(res.statusCode >= 200 && res.statusCode < 300);
+          res.resume();
+        });
+        req.on("error", () => resolve(false));
+        req.setTimeout(2e3, () => {
+          req.destroy();
+          resolve(false);
+        });
+      });
+    }
+    async function waitForServer(port, maxAttempts = 10, intervalMs = 100) {
+      for (let i = 0; i < maxAttempts; i++) {
+        if (await checkServer(port)) return true;
+        await new Promise((r) => setTimeout(r, intervalMs));
+      }
+      return false;
+    }
+    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);
+      }
+      const portFile = path.join(cwd, ".planning", "server.port");
+      const port = fs.existsSync(portFile) ? parseInt(fs.readFileSync(portFile, "utf8").trim(), 10) : 3847;
+      const isRunning = await checkServer(port);
+      if (!isRunning) {
+        const bundlePath = path.resolve(__dirname, "declare-tools.cjs");
+        const child = spawn(process.execPath, [bundlePath, "serve", "--port", String(port)], {
+          cwd,
+          detached: true,
+          stdio: "ignore"
+        });
+        child.unref();
+        const ready = await waitForServer(port);
+        if (!ready) {
+          console.error("[declare] Warning: server may not be ready yet");
+        }
+      }
+      const url = `http://localhost:${port}`;
+      const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      spawn(opener, [url], { stdio: "ignore", detached: true }).unref();
+      console.log(`Dashboard: ${url}`);
+    }
+    module2.exports = { runOpen: runOpen2 };
+  }
+});
+
 // src/declare-tools.js
 var { commitPlanningDocs } = require_commit();
 var { readState, recordSession } = require_state();
@@ -4132,6 +7539,8 @@ var { runInit } = require_init();
 var { runStatus } = require_status();
 var { runHelp } = require_help();
 var { runAddDeclaration } = require_add_declaration();
+var { runUpdateDeclaration } = require_update_declaration();
+var { runDeleteDeclaration } = require_delete_declaration();
 var { runAddMilestone } = require_add_milestone();
 var { runAddMilestonesBatch } = require_add_milestones_batch();
 var { runAddAction } = require_add_action();
@@ -4158,6 +7567,7 @@ var { runConfigGet } = require_config_get();
 var { runConfigSet } = require_config_set();
 var { runHealthCheck, runHealthCheckRepair } = require_health_check();
 var { runServe } = require_serve();
+var { runOpen } = require_open();
 function parseCwdFlag(argv) {
   const idx = argv.indexOf("--cwd");
   if (idx === -1 || idx + 1 >= argv.length) return null;
@@ -4199,9 +7609,18 @@ function parseNamedFlag(argv, flag) {
 function main() {
   const args = process.argv.slice(2);
   const command = args[0];
-  if (!command) {
-    console.log(JSON.stringify({ error: "No command specified. Use: commit, init, status, add-declaration, add-milestone, add-milestones, create-plan, load-graph, trace, prioritize, visualize, compute-waves, generate-exec-plan, verify-wave, verify-milestone, execute, check-drift, check-occurrence, compute-performance, renegotiate, complete-milestone, sync-status, serve, record-session, get-state, quick-task, add-todo, check-todos, complete-todo, config-get, config-set, health-check, help" }));
-    process.exit(1);
+  const sub = args[0];
+  const isDefaultOpen = !sub || sub === "." || (sub.startsWith("/") || sub.startsWith("~"));
+  if (isDefaultOpen) {
+    let projectRoot = process.cwd();
+    if (sub && sub !== ".") {
+      projectRoot = sub.startsWith("~") ? sub.replace("~", require("os").homedir()) : sub;
+    }
+    runOpen(projectRoot, args.slice(1)).catch((err) => {
+      console.error("[declare] " + err.message);
+      process.exit(1);
+    });
+    return;
   }
   try {
     switch (command) {
@@ -4244,6 +7663,20 @@ function main() {
         if (result.error) process.exit(1);
         break;
       }
+      case "update-declaration": {
+        const cwdUpdateDecl = parseCwdFlag(args) || process.cwd();
+        const result = runUpdateDeclaration(cwdUpdateDecl, args.slice(1));
+        console.log(JSON.stringify(result));
+        if (result.error) process.exit(1);
+        break;
+      }
+      case "delete-declaration": {
+        const cwdDeleteDecl = parseCwdFlag(args) || process.cwd();
+        const result = runDeleteDeclaration(cwdDeleteDecl, args.slice(1));
+        console.log(JSON.stringify(result));
+        if (result.error) process.exit(1);
+        break;
+      }
       case "add-milestone": {
         const cwdAddMs = parseCwdFlag(args) || process.cwd();
         const result = runAddMilestone(cwdAddMs, args.slice(1));
@@ -4469,7 +7902,7 @@ function main() {
         break;
       }
       default:
-        console.log(JSON.stringify({ error: `Unknown command: ${command}. Use: commit, init, status, add-declaration, add-milestone, add-milestones, create-plan, load-graph, trace, prioritize, visualize, compute-waves, generate-exec-plan, verify-wave, verify-milestone, execute, check-drift, check-occurrence, compute-performance, renegotiate, complete-milestone, sync-status, serve, record-session, get-state, quick-task, add-todo, check-todos, complete-todo, config-get, config-set, health-check, help` }));
+        console.log(JSON.stringify({ error: `Unknown command: ${command}. Use: commit, init, status, add-declaration, update-declaration, delete-declaration, add-milestone, add-milestones, create-plan, load-graph, trace, prioritize, visualize, compute-waves, generate-exec-plan, verify-wave, verify-milestone, execute, check-drift, check-occurrence, compute-performance, renegotiate, complete-milestone, sync-status, serve, record-session, get-state, quick-task, add-todo, check-todos, complete-todo, config-get, config-set, health-check, help` }));
         process.exit(1);
     }
   } catch (err) {