declare-cc 0.4.3 → 0.4.8

package/bin/install.js

@@ -1465,8 +1465,9 @@ function install(isGlobal, runtime = 'claude') {
     console.log(`  ${green}✓${reset} Installed workflows/`);
   }
 
-  // Copy dashboard static files (src/server/public/) → .claude/server/public/
-  const publicSrc = path.join(src, 'src', 'server', 'public');
+  // Copy dashboard static files (dist/public/) → .claude/server/public/
+  // dist/public/ ships in the npm package (built by esbuild.config.js)
+  const publicSrc = path.join(src, 'dist', 'public');
   if (fs.existsSync(publicSrc)) {
     const publicDest = path.join(targetDir, 'server', 'public');
     fs.mkdirSync(publicDest, { recursive: true });
@@ -1563,6 +1564,9 @@ function install(isGlobal, runtime = 'claude') {
   const updateCheckCommand = isGlobal
     ? buildHookCommand(targetDir, 'declare-check-update.js')
     : 'node ' + dirName + '/hooks/declare-check-update.js';
+  const activityCommand = isGlobal
+    ? buildHookCommand(targetDir, 'declare-activity.js')
+    : 'node ' + dirName + '/hooks/declare-activity.js';
 
   // Enable experimental agents for Gemini CLI (required for custom sub-agents)
   if (isGemini) {
@@ -1599,6 +1603,21 @@ function install(isGlobal, runtime = 'claude') {
       });
       console.log(`  ${green}✓${reset} Configured update check hook`);
     }
+
+    // Configure PreToolUse + PostToolUse hooks for activity feed (Claude Code only)
+    if (!isOpencode && !isGemini) {
+      if (!settings.hooks.PreToolUse)  settings.hooks.PreToolUse  = [];
+      if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = [];
+
+      const hasActivityPre = settings.hooks.PreToolUse.some(e =>
+        e.hooks && e.hooks.some(h => h.command && h.command.includes('declare-activity'))
+      );
+      if (!hasActivityPre) {
+        settings.hooks.PreToolUse.push({ hooks: [{ type: 'command', command: activityCommand }] });
+        settings.hooks.PostToolUse.push({ hooks: [{ type: 'command', command: activityCommand }] });
+        console.log(`  ${green}✓${reset} Configured activity feed hooks`);
+      }
+    }
   }
 
   // Write file manifest for future modification detection

package/commands/declare/actions.md

@@ -95,11 +95,16 @@ After all milestones processed:
 node dist/declare-tools.cjs load-graph
 ```
 
-2. Show summary: milestones processed, plans created, total actions derived.
-3. Suggest the next step clearly:
+2. Start the dashboard if not already running:
+```bash
+curl -sf http://localhost:3847/api/graph -o /dev/null || (node dist/declare-tools.cjs serve --port 3847 > /tmp/declare-dashboard.log 2>&1 & sleep 1 && open http://localhost:3847 2>/dev/null || true)
+```
+
+3. Show summary: milestones processed, plans created, total actions derived.
+4. Suggest the next step clearly:
 
 ```
-Actions defined. Next: create executable plans.
+Actions and edges are live in the dashboard → http://localhost:3847
 
   /declare:plan M-XX    — research + planner + checker loop → EXEC-PLAN files
   /declare:execute M-XX — once plans exist, execute with wave scheduling

package/commands/declare/execute.md

@@ -188,25 +188,28 @@ If `--confirm` flag was set, pause after successful verification:
 - "Wave N complete and verified. Proceed to Wave N+1? (yes/no)"
 - Wait for user confirmation before continuing.
 
-**3e. Update action statuses in PLAN.md:**
+**3e. Propagate statuses after each wave:**
 
-After successful wave verification, update each completed action's status in the milestone's PLAN.md file:
+After successful wave verification, run sync-status to update PLAN.md, MILESTONES.md, and FUTURE.md atomically. This keeps the dashboard live as waves complete:
 
-1. Use the `milestoneFolderPath` from Step 2 to locate the PLAN.md file.
-2. Read the PLAN.md file.
-3. For each action in the completed wave, find `**Status:** PENDING` (or `**Status:** ACTIVE`) for that action and change it to `**Status:** DONE`.
-4. Write the updated PLAN.md back.
+```bash
+node dist/declare-tools.cjs sync-status
+```
+
+Do not manually edit PLAN.md or MILESTONES.md — sync-status handles all of it correctly.
+
+**Step 4: After all waves complete, propagate statuses.**
 
-**Step 4: After all waves complete, check milestone completion.**
+Run sync-status to propagate action → milestone → declaration completion automatically:
+
+```bash
+node dist/declare-tools.cjs sync-status
+```
 
-If `milestoneCompletable` is true from the final verify-wave result:
-1. Read `.planning/MILESTONES.md`.
-2. Find the row for M-XX in the milestones table.
-3. Change its Status from PENDING or ACTIVE to DONE.
-4. Write the updated MILESTONES.md back.
-5. Display: "Milestone M-XX marked as DONE (pending verification)."
+Parse the result. It will show which actions, milestones, and declarations were marked DONE.
+Display: "Status propagated — [summary from sync-status result]."
 
-Proceed to Step 5. Do NOT display a completion banner yet -- that happens in Step 8 after verification.
+Proceed to Step 5. Do NOT display a completion banner yet — that happens in Step 8 after verification.
 
 **Step 5: Milestone truth verification.**
 

package/commands/declare/future.md

@@ -44,9 +44,29 @@ node dist/declare-tools.cjs add-declaration --title "Short Title" --statement "F
 
 Parse the JSON output to confirm the declaration was created and note its assigned ID (e.g., D-01).
 
-**Step 5: Show summary and suggest next step.**
+**Step 5: Launch dashboard and show summary.**
 
 After all declarations are captured:
 
-1. List all declarations with their IDs and statements.
-2. Suggest: "Run `/declare:milestones` to work backward from these declarations to milestones and actions."
+1. Start the dashboard server (if not already running):
+
+```bash
+node dist/declare-tools.cjs serve --port 3847 > /tmp/declare-dashboard.log 2>&1 &
+sleep 1 && curl -sf http://localhost:3847/api/graph -o /dev/null && echo "RUNNING" || echo "FAILED"
+```
+
+If RUNNING, open it:
+```bash
+open http://localhost:3847 2>/dev/null || true
+```
+
+2. List all declarations with their IDs and statements.
+
+3. Suggest next step:
+
+```
+Your declarations are live in the dashboard → http://localhost:3847
+The graph updates every 5 seconds as you add milestones and actions.
+
+Run /declare:milestones to work backward from these declarations.
+```

package/commands/declare/milestones.md

@@ -77,5 +77,10 @@ After all declarations processed:
 node dist/declare-tools.cjs load-graph
 ```
 
-2. Show summary: declarations processed, milestones derived.
-3. Suggest: "Run `/declare:actions` to derive action plans for each milestone."
+2. Start the dashboard if not already running (dashboard updates live when files change):
+```bash
+curl -sf http://localhost:3847/api/graph -o /dev/null || (node dist/declare-tools.cjs serve --port 3847 > /tmp/declare-dashboard.log 2>&1 & sleep 1 && open http://localhost:3847 2>/dev/null || true)
+```
+
+3. Show summary: declarations processed, milestones derived.
+4. Suggest: "Milestones are live in the dashboard → http://localhost:3847 — Run `/declare:actions` to derive action plans."

package/dist/declare-tools.cjs

@@ -1329,7 +1329,7 @@ var require_help = __commonJS({
             usage: "/declare:help"
           }
         ],
-        version: "0.4.0"
+        version: "0.4.7"
       };
     }
     module2.exports = { runHelp: runHelp2 };
@@ -3096,6 +3096,167 @@ var require_sync_status = __commonJS({
   }
 });
 
+// src/commands/get-exec-plan.js
+var require_get_exec_plan = __commonJS({
+  "src/commands/get-exec-plan.js"(exports2, module2) {
+    "use strict";
+    var { existsSync, readFileSync, readdirSync } = require("node:fs");
+    var { join } = require("node:path");
+    var { parseFlag } = require_parse_args();
+    var { buildDagFromDisk } = require_build_dag();
+    var { findMilestoneFolder } = require_milestone_folders();
+    function parseFrontmatter(fmText) {
+      const result = {};
+      const lines = fmText.split("\n");
+      let i = 0;
+      while (i < lines.length) {
+        const line = lines[i];
+        const keyMatch = line.match(/^(\w[\w_]*):\s*(.*)/);
+        if (!keyMatch) {
+          i++;
+          continue;
+        }
+        const [, key, rest] = keyMatch;
+        if (rest.trim() === "") {
+          const children = [];
+          i++;
+          while (i < lines.length && (lines[i].startsWith("  ") || lines[i].trim() === "")) {
+            const child = lines[i];
+            const listItem = child.match(/^\s+-\s+(.*)/);
+            const nestedKey = child.match(/^\s+(\w[\w_]*):\s*(.*)/);
+            if (listItem) {
+              children.push({ type: "item", value: listItem[1].replace(/^["']|["']$/g, "") });
+            } else if (nestedKey) {
+              children.push({ type: "key", key: nestedKey[1], value: nestedKey[2] });
+            }
+            i++;
+          }
+          if (children.length > 0 && children[0].type === "item") {
+            result[key] = children.map((c) => c.value);
+          } else if (children.length > 0 && children[0].type === "key") {
+            result[key] = {};
+            let subKey = null;
+            let subItems = [];
+            for (const c of children) {
+              if (c.type === "key") {
+                if (subKey) result[key][subKey] = subItems;
+                subKey = c.key;
+                subItems = c.value.trim() ? [c.value.replace(/^["']|["']$/g, "")] : [];
+              } else if (c.type === "item") {
+                subItems.push(c.value);
+              }
+            }
+            if (subKey) result[key][subKey] = subItems;
+          }
+        } else {
+          result[key] = rest.trim().replace(/^["']|["']$/g, "");
+          i++;
+        }
+      }
+      return result;
+    }
+    function extractTag(content, tag) {
+      const re = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i");
+      const m = content.match(re);
+      return m ? m[1].trim() : null;
+    }
+    function parseTasks(tasksContent) {
+      const tasks = [];
+      const taskRe = /<task([^>]*)>([\s\S]*?)<\/task>/gi;
+      let m;
+      while ((m = taskRe.exec(tasksContent)) !== null) {
+        const attrs = m[1];
+        const body = m[2];
+        const typeMatch = attrs.match(/type="([^"]+)"/);
+        const taskType = typeMatch ? typeMatch[1] : "auto";
+        tasks.push({
+          type: taskType,
+          name: extractTag(body, "name") || "",
+          action: extractTag(body, "action"),
+          verify: extractTag(body, "verify"),
+          done: extractTag(body, "done"),
+          howToVerify: extractTag(body, "how-to-verify"),
+          resumeSignal: extractTag(body, "resume-signal"),
+          whatBuilt: extractTag(body, "what-built")
+        });
+      }
+      return tasks;
+    }
+    function findExecPlan(milestoneFolder, actionId) {
+      if (!existsSync(milestoneFolder)) return null;
+      const entries = readdirSync(milestoneFolder);
+      const match = entries.find(
+        (f) => f.toUpperCase().startsWith(actionId.toUpperCase() + "-EXEC-PLAN") || f.toUpperCase().startsWith("EXEC-PLAN-" + actionId.replace(/^A-/, ""))
+      );
+      return match ? join(milestoneFolder, match) : null;
+    }
+    function runGetExecPlan2(cwd, args) {
+      const actionId = parseFlag(args, "action");
+      if (!actionId) {
+        return { error: "Missing --action flag. Usage: get-exec-plan --action A-XX" };
+      }
+      const graphResult = buildDagFromDisk(cwd);
+      if ("error" in graphResult) return graphResult;
+      const { dag } = graphResult;
+      const action = dag.getNode(actionId);
+      if (!action) return { error: `Action not found: ${actionId}` };
+      const upstreamMilestones = dag.getUpstream(actionId).filter((n) => n.type === "milestone");
+      if (upstreamMilestones.length === 0) return { error: `No milestone found for action ${actionId}` };
+      const milestone = upstreamMilestones[0];
+      const planningDir = join(cwd, ".planning");
+      const milestoneFolder = findMilestoneFolder(planningDir, milestone.id);
+      if (!milestoneFolder) {
+        return { error: `Milestone folder not found for ${milestone.id}` };
+      }
+      const execPlanPath = findExecPlan(milestoneFolder, actionId);
+      if (!execPlanPath) {
+        return {
+          actionId,
+          actionTitle: action.title,
+          status: action.status,
+          milestoneId: milestone.id,
+          milestoneTitle: milestone.title,
+          execPlan: null,
+          summaryExists: false
+        };
+      }
+      const raw = readFileSync(execPlanPath, "utf-8");
+      const fmMatch = raw.match(/^---\n([\s\S]*?)\n---/);
+      const frontmatter = fmMatch ? parseFrontmatter(fmMatch[1]) : {};
+      const objective = extractTag(raw, "objective");
+      const tasksRaw = extractTag(raw, "tasks");
+      const tasks = tasksRaw ? parseTasks(tasksRaw) : [];
+      const successCriteria = extractTag(raw, "success_criteria");
+      const verification = extractTag(raw, "verification");
+      const summaryPath = join(milestoneFolder, `${actionId}-SUMMARY.md`);
+      const summaryExists = existsSync(summaryPath);
+      const summaryContent = summaryExists ? readFileSync(summaryPath, "utf-8") : null;
+      return {
+        actionId,
+        actionTitle: action.title,
+        status: action.status,
+        milestoneId: milestone.id,
+        milestoneTitle: milestone.title,
+        execPlan: {
+          wave: frontmatter.wave ? Number(frontmatter.wave) : null,
+          autonomous: frontmatter.autonomous === "true" || frontmatter.autonomous === true,
+          dependsOn: Array.isArray(frontmatter.depends_on) ? frontmatter.depends_on : [],
+          filesModified: Array.isArray(frontmatter.files_modified) ? frontmatter.files_modified : [],
+          declarations: Array.isArray(frontmatter.declarations) ? frontmatter.declarations : [],
+          mustHaves: frontmatter.must_haves || null,
+          objective,
+          tasks,
+          successCriteria,
+          verification
+        },
+        summaryExists,
+        summaryContent
+      };
+    }
+    module2.exports = { runGetExecPlan: runGetExecPlan2 };
+  }
+});
+
 // src/commands/quick-task.js
 var require_quick_task = __commonJS({
   "src/commands/quick-task.js"(exports2, module2) {
@@ -3666,6 +3827,7 @@ var require_server = __commonJS({
     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",
@@ -3677,7 +3839,9 @@ var require_server = __commonJS({
     };
     function getPublicDir(cwd) {
       const installed = path.join(cwd, ".claude", "server", "public");
-      if (require("fs").existsSync(installed)) return installed;
+      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) {
@@ -3760,6 +3924,67 @@ var require_server = __commonJS({
         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) });
+      }
+    }
+    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 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 route(req, res, cwd) {
       const method = req.method || "GET";
       const url = req.url || "/";
@@ -3777,6 +4002,18 @@ var require_server = __commonJS({
         sendJson(res, 405, { error: "Method Not Allowed" });
         return;
       }
+      if (urlPath === "/events") {
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+          "Access-Control-Allow-Origin": "*"
+        });
+        res.write("retry: 3000\n\n");
+        sseClients.add(res);
+        req.on("close", () => sseClients.delete(res));
+        return;
+      }
       if (urlPath === "/api/graph") {
         handleGraph(res, cwd);
         return;
@@ -3790,6 +4027,16 @@ var require_server = __commonJS({
         handleMilestone(res, cwd, milestoneMatch[1]);
         return;
       }
+      if (urlPath === "/api/activity") {
+        handleActivity(res, cwd);
+        return;
+      }
+      const actionMatch = urlPath.match(/^\/api\/action\/([^/]+)$/);
+      if (actionMatch) {
+        const result = runGetExecPlan2(cwd, ["--action", actionMatch[1]]);
+        sendJson(res, result.error ? 404 : 200, result);
+        return;
+      }
       const publicDir = getPublicDir(cwd);
       if (urlPath === "/") {
         const indexPath = path.join(publicDir, "index.html");
@@ -3818,6 +4065,7 @@ var require_server = __commonJS({
       const resolvedPort = port || parseInt(process.env.PORT || "", 10) || 3847;
       const server = createServer(cwd, resolvedPort);
       server.listen(resolvedPort, "127.0.0.1", () => {
+        watchPlanning(cwd);
       });
       const url = `http://localhost:${resolvedPort}`;
       return { server, port: resolvedPort, url };
@@ -3878,6 +4126,7 @@ var { runComputePerformance } = require_compute_performance();
 var { runRenegotiate } = require_renegotiate();
 var { runCompleteMilestone } = require_complete_milestone();
 var { runSyncStatus } = require_sync_status();
+var { runGetExecPlan } = require_get_exec_plan();
 var { runQuickTask } = require_quick_task();
 var { runAddTodo, runCheckTodos, runCompleteTodo } = require_todo();
 var { runConfigGet } = require_config_get();
@@ -4054,6 +4303,13 @@ function main() {
         if (result.error) process.exit(1);
         break;
       }
+      case "get-exec-plan": {
+        const cwdGep = parseCwdFlag(args) || process.cwd();
+        const result = runGetExecPlan(cwdGep, args.slice(1));
+        console.log(JSON.stringify(result));
+        if (result.error) process.exit(1);
+        break;
+      }
       case "execute": {
         const cwdExecute = parseCwdFlag(args) || process.cwd();
         const result = runExecute(cwdExecute, args.slice(1));