declare-cc 0.4.0 → 0.4.5

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 });

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/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/commands/declare/plan.md

@@ -181,10 +181,14 @@ Repeat until VERIFICATION PASSED or revision count reaches 3.
 
 **Step 9: Commit EXEC-PLANs.**
 
+Pass each file as a separate `--files` argument (not space-separated in one argument):
+
 ```bash
-node dist/declare-tools.cjs commit "docs(${MILESTONE}): create exec-plans for milestone actions" --files [space-separated list of EXEC-PLAN file paths]
+node dist/declare-tools.cjs commit "docs(${MILESTONE}): create exec-plans for milestone actions" --files [path/to/A-01-EXEC-PLAN.md] --files [path/to/A-02-EXEC-PLAN.md]
 ```
 
+If the commit reports `nothing_to_commit`, the planner already committed the files — that is fine, continue.
+
 **Step 10: Present results.**
 
 Display final summary:
@@ -211,11 +215,59 @@ Display final summary:
 
 ### Next Steps
 
-Execute: `/declare:execute M-XX`
-
-/clear first — fresh context window
 ```
 
+After displaying the summary, reload the graph and check for milestones that still have no EXEC-PLANs (hasPlan is false OR actions array for that milestone has no EXEC-PLAN files):
+
+- If **other milestones still need planning**, list them and suggest planning those next:
+  ```
+  Remaining milestones to plan:
+    /declare:plan M-02  — [title]
+    /declare:plan M-03  — [title]
+
+  Plan all milestones before executing. Run /declare:execute only when all are planned.
+  ```
+
+- If **this was the last milestone to plan**, compute dependency waves before spawning anything — do not blindly parallelize all milestones.
+
+  **Step A: Compute milestone dependency waves.**
+
+  Load the graph, then read each milestone's PLAN.md. For each action, check its `dependsOn` field. If an action in M-02 lists `dependsOn: ["A-01"]` and A-01 belongs to M-01, then M-02 depends on M-01.
+
+  Build a milestone-level dependency graph from these cross-milestone action references. Run a topological sort (Kahn's algorithm) to group milestones into waves:
+  - Wave 1: milestones with no dependencies on other pending milestones
+  - Wave 2: milestones whose dependencies are all in wave 1
+  - …and so on
+
+  If no cross-milestone `dependsOn` edges exist, all milestones go into wave 1 (full parallelism). Show the wave plan before executing:
+
+  ```
+  ## Milestone Execution Waves
+
+  Wave 1 (parallel): M-01 [title], M-03 [title]
+  Wave 2 (after wave 1): M-02 [title]
+  ```
+
+  **Step B: Execute wave by wave using the Task tool.**
+
+  For each wave, spawn one Task agent per milestone **in the same response** so they execute in parallel:
+
+  Subagent type: `gsd-executor`
+  Prompt per milestone:
+  ```
+  Execute milestone [M-XX] "[title]" for the Declare project.
+  Working directory: [absolute path to cwd]
+  Run: /declare:execute [M-XX]
+  EXEC-PLANs are in: [absolute path to milestone folder]
+  ```
+
+  Wait for the entire wave to complete before spawning the next wave.
+
+  After all waves finish, propagate statuses:
+  ```bash
+  node dist/declare-tools.cjs sync-status
+  ```
+
 If max revisions reached with issues remaining, display blocker list prominently:
 
 ```

package/dist/declare-tools.cjs

@@ -1329,7 +1329,7 @@ var require_help = __commonJS({
             usage: "/declare:help"
           }
         ],
-        version: "0.3.9"
+        version: "0.4.4"
       };
     }
     module2.exports = { runHelp: runHelp2 };
@@ -1537,7 +1537,8 @@ var require_add_milestones_batch = __commonJS({
         dag.addNode(m.id, "milestone", m.title, m.status || "PENDING");
       }
       for (let i = 0; i < inputs.length; i++) {
-        const realizes = inputs[i].realizes.split(",").map((s) => s.trim()).filter(Boolean);
+        const realizesRaw = inputs[i].realizes;
+        const realizes = Array.isArray(realizesRaw) ? realizesRaw.map((s) => String(s).trim()).filter(Boolean) : String(realizesRaw).split(",").map((s) => s.trim()).filter(Boolean);
         for (const declId of realizes) {
           if (!dag.getNode(declId)) {
             return { error: `Item ${i}: declaration not found: ${declId}` };
@@ -3676,7 +3677,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) {
@@ -3759,6 +3762,31 @@ var require_server = __commonJS({
         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 debounceTimer = null;
+      try {
+        fs.watch(planningDir, { recursive: true }, () => {
+          if (debounceTimer) clearTimeout(debounceTimer);
+          debounceTimer = setTimeout(() => {
+            broadcastChange();
+            debounceTimer = null;
+          }, 200);
+        });
+      } catch (_) {
+      }
+    }
     function route(req, res, cwd) {
       const method = req.method || "GET";
       const url = req.url || "/";
@@ -3776,6 +3804,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;
@@ -3817,6 +3857,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 };