npm - conductor-board - Versions diffs - 1.3.0 → 2.1.0 - Mend

conductor-board 1.3.0 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/bin/cli.js +101 -12
package/cli/check.js +89 -0
package/cli/clean.js +121 -0
package/cli/complete.js +169 -0
package/cli/discover.js +42 -0
package/cli/ps.js +38 -0
package/cli/setup.js +19 -6
package/cli/stop.js +71 -0
package/cli/validate.js +22 -3
package/cli/writer.js +218 -0
package/dist/assets/index-D0azgMCk.css +1 -0
package/dist/assets/index-DV9PNUB3.js +34 -0
package/dist/index.html +2 -2
package/package.json +1 -1
package/server/server.js +277 -12
package/dist/assets/index-Dauby4vm.js +0 -34
package/dist/assets/index-nvl4ljRP.css +0 -1

package/dist/index.html CHANGED Viewed

@@ -6,10 +6,10 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="theme-color" content="#0a0a0f" />
     <title>Agent Conductor — Board</title>
-    <script type="module" crossorigin src="./assets/index-Dauby4vm.js"></script>
+    <script type="module" crossorigin src="./assets/index-DV9PNUB3.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/motion-Dmvx5jlk.js">
     <link rel="modulepreload" crossorigin href="./assets/yaml-NA7d4LV6.js">
-    <link rel="stylesheet" crossorigin href="./assets/index-nvl4ljRP.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-D0azgMCk.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "conductor-board",
-  "version": "1.3.0",
+  "version": "2.1.0",
   "description": "Gated workflows for AI agents — live Kanban board included",
   "license": "MIT",
   "author": "mettafive",

package/server/server.js CHANGED Viewed

@@ -200,6 +200,22 @@ function archiveIfDone(historyDir, snapshot, archived) {
   const status = snapshot.status;
   if (!status || (status.status !== "done" && status.status !== "failed")) return null;
+  // Mandatory suggestions: a successful run must capture what it learned before
+  // it's saved to history. A done run with no suggestions doesn't archive (the
+  // loop has to feed itself) — failed runs are exempt.
+  if (status.status === "done") {
+    const sug = status.suggestions;
+    if (!Array.isArray(sug) || sug.length === 0) {
+      if (!status._noSuggestionsWarned) {
+        console.warn(
+          `[conductor-board] "${status.workflow || "workflow"}" is done but has no suggestions — not archiving until it captures 3–5. (spec §9.2)`,
+        );
+        status._noSuggestionsWarned = true;
+      }
+      return null;
+    }
+  }
   const runId =
     status.run_id ||
     (status.started_at ? safeId(status.started_at).replace(/-\d+Z$/, "") : null);
@@ -240,6 +256,113 @@ function archiveIfDone(historyDir, snapshot, archived) {
   }
 }
+// ---------------------------------------------------------------------------
+// Insights ledger — a persistent, accumulating memory per workflow.
+//
+// insights.json is the source of truth (structured, with apply/dismiss state);
+// insights.md is a human- and agent-readable view regenerated on every change.
+// Suggestions from each completed run are merged in (deduped) as `open`; the
+// board lets the user apply or dismiss them, which updates both files.
+// ---------------------------------------------------------------------------
+const insightsPaths = (wf) => ({
+  json: path.join(wf.dir, "insights.json"),
+  md: path.join(wf.dir, "insights.md"),
+});
+const insightKey = (s) =>
+  `${s.type || "note"}::${s.step || ""}::${String(s.title || "")
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, " ")}`;
+function loadInsights(wf) {
+  try {
+    const l = JSON.parse(fs.readFileSync(insightsPaths(wf).json, "utf8"));
+    if (l && Array.isArray(l.items)) return l;
+  } catch {
+    /* fresh ledger */
+  }
+  return { workflow: wf.name, items: [] };
+}
+function renderInsightsMd(ledger) {
+  const of = (st) => ledger.items.filter((i) => i.status === st);
+  const line = (i) =>
+    `- [${i.type}] ${i.title}${i.confidence ? ` · ${i.confidence}` : ""}${
+      i.provenance ? ` · _${i.provenance}_` : ""
+    }`;
+  const sect = (title, items) =>
+    `## ${title}\n${items.length ? items.map(line).join("\n") : "_none yet_"}\n`;
+  return (
+    `# Conductor insights — ${ledger.workflow}\n\n` +
+    `_Accumulated across runs. The agent reads this at the start of each run to carry ` +
+    `learnings forward; the board appends new insights and tracks which you apply or dismiss._\n\n` +
+    sect("Open", of("open")) +
+    `\n` +
+    sect("Applied", of("applied")) +
+    `\n` +
+    sect("Dismissed", of("dismissed"))
+  );
+}
+function saveInsights(wf, ledger) {
+  const { json, md } = insightsPaths(wf);
+  try {
+    fs.mkdirSync(wf.dir, { recursive: true });
+    fs.writeFileSync(json, JSON.stringify(ledger, null, 2));
+    fs.writeFileSync(md, renderInsightsMd(ledger));
+  } catch (e) {
+    console.warn(`[conductor-board] could not write insights: ${e.message}`);
+  }
+}
+/** Merge a run's suggestions into the ledger as `open`, deduped by key. */
+function mergeInsights(wf, suggestions, runId, at) {
+  if (!Array.isArray(suggestions) || suggestions.length === 0) return false;
+  const ledger = loadInsights(wf);
+  const have = new Set(ledger.items.map(insightKey));
+  let added = 0;
+  for (const s of suggestions) {
+    if (!s || !s.title) continue;
+    const key = insightKey(s);
+    if (have.has(key)) continue;
+    have.add(key);
+    ledger.items.push({
+      key,
+      type: s.type || "note",
+      step: s.step,
+      title: s.title,
+      rationale: s.rationale,
+      current: s.current,
+      proposed: s.proposed,
+      confidence: s.confidence,
+      source_heartbeat: s.source_heartbeat,
+      status: "open",
+      provenance: `run ${runId || "?"}`,
+      first_seen_at: at || new Date().toISOString(),
+    });
+    added += 1;
+  }
+  if (added) saveInsights(wf, ledger);
+  return added > 0;
+}
+/** Mark ledger items applied/dismissed/open by key. */
+function decideInsights(wf, keys, status) {
+  const ledger = loadInsights(wf);
+  let changed = 0;
+  for (const it of ledger.items) {
+    if (keys.includes(it.key) && it.status !== status) {
+      it.status = status;
+      it.decided_at = new Date().toISOString();
+      changed += 1;
+    }
+  }
+  if (changed) saveInsights(wf, ledger);
+  return changed;
+}
 function serveStatic(req, res) {
   let urlPath = decodeURIComponent((req.url || "/").split("?")[0]);
   if (urlPath === "/") urlPath = "/index.html";
@@ -363,7 +486,11 @@ export function startServer({ statusPath, conductorPath: explicitConductor, port
     for (const wf of discoverWorkflows(conductorDir, absStatus, explicitConductor)) {
       const snap = snapshotFor(wf);
       sendAll("update", snap);
-      if (archiveIfDone(wf.historyDir, snap, archivedSetFor(wf))) {
+      const rec = archiveIfDone(wf.historyDir, snap, archivedSetFor(wf));
+      if (rec) {
+        if (mergeInsights(wf, rec.snapshot?.status?.suggestions, rec.run_id, rec.completed_at)) {
+          sendAll("insights", { workflow: wf.name, ledger: loadInsights(wf) });
+        }
         sendAll("history", { workflow: wf.name, runs: listHistory(wf.historyDir) });
       }
     }
@@ -395,6 +522,12 @@ export function startServer({ statusPath, conductorPath: explicitConductor, port
           runs: listHistory(wf.historyDir),
         })}\n\n`,
       );
+      res.write(
+        `event: insights\ndata: ${JSON.stringify({
+          workflow: wf.name,
+          ledger: loadInsights(wf),
+        })}\n\n`,
+      );
     }
   };
@@ -408,12 +541,53 @@ export function startServer({ statusPath, conductorPath: explicitConductor, port
     const wfs = () => discoverWorkflows(conductorDir, absStatus, explicitConductor);
     if (url === "/health") {
+      const workflows = {};
+      for (const wf of wfs()) {
+        let kb = 0;
+        let beats = 0;
+        let st = null;
+        try {
+          kb = Math.round(fs.statSync(wf.statusPath).size / 1024);
+        } catch {
+          /* no status file yet */
+        }
+        try {
+          const s = JSON.parse(fs.readFileSync(wf.statusPath, "utf8"));
+          st = s.status ?? "idle";
+          beats = Object.values(s.steps || {}).reduce(
+            (n, x) => n + (Array.isArray(x && x.heartbeat) ? x.heartbeat.length : 0),
+            0,
+          );
+        } catch {
+          /* unreadable / not started */
+        }
+        let archiveLines = 0;
+        try {
+          archiveLines = fs
+            .readFileSync(path.join(wf.dir, "heartbeat-archive.jsonl"), "utf8")
+            .split("\n")
+            .filter(Boolean).length;
+        } catch {
+          /* no archive */
+        }
+        workflows[wf.name] = {
+          status: st ?? "idle",
+          status_file_kb: kb,
+          heartbeat_count: beats,
+          archive_lines: archiveLines,
+          history_count: listHistory(wf.historyDir).length,
+        };
+      }
       return json(res, 200, {
         status: "ok",
         version: VERSION,
-        watching: path.relative(process.cwd(), conductorDir) || conductorDir,
+        pid: process.pid,
         port: server.address()?.port ?? null,
-        workflows: wfs().map((w) => w.name),
+        uptime_seconds: Math.round(process.uptime()),
+        memory_mb: Math.round(process.memoryUsage().rss / 1024 / 1024),
+        watching: path.relative(process.cwd(), conductorDir) || conductorDir,
+        workflows,
+        sse_connections: clients.size,
       });
     }
@@ -448,23 +622,32 @@ export function startServer({ statusPath, conductorPath: explicitConductor, port
       const wf = findWf(decodeURIComponent(m[1]));
       if (!wf) return json(res, 404, { error: "workflow not found" });
       readBody(req).then((bodyStr) => {
-        let ids;
+        let payload;
         try {
-          ids = JSON.parse(bodyStr || "{}").suggestions;
+          payload = JSON.parse(bodyStr || "{}").suggestions;
         } catch {
           return json(res, 400, { error: "invalid request body" });
         }
-        if (!Array.isArray(ids)) return json(res, 400, { error: "suggestions must be an array" });
+        if (!Array.isArray(payload) || payload.length === 0)
+          return json(res, 400, { error: "suggestions must be a non-empty array" });
         if (!wf.conductorPath || !fs.existsSync(wf.conductorPath))
           return json(res, 400, { error: "no conductor file for this workflow" });
-        let status;
-        try {
-          status = JSON.parse(fs.readFileSync(wf.statusPath, "utf8"));
-        } catch {
-          return json(res, 500, { error: "could not read status.json" });
+        // Accept either a list of ids (resolved against the live status) or full
+        // suggestion objects — the latter lets a past run's suggestions apply
+        // even after the live status has moved on to another run.
+        let chosen;
+        if (payload.every((x) => typeof x === "string")) {
+          let status;
+          try {
+            status = JSON.parse(fs.readFileSync(wf.statusPath, "utf8"));
+          } catch {
+            return json(res, 500, { error: "could not read status.json" });
+          }
+          chosen = (status.suggestions || []).filter((s) => payload.includes(s.id));
+        } else {
+          chosen = payload.filter((x) => x && typeof x === "object");
         }
-        const chosen = (status.suggestions || []).filter((s) => ids.includes(s.id));
         if (chosen.length === 0) return json(res, 400, { error: "no matching suggestions" });
         const original = fs.readFileSync(wf.conductorPath, "utf8");
@@ -498,6 +681,9 @@ export function startServer({ statusPath, conductorPath: explicitConductor, port
           }
           return json(res, 500, { error: `write failed, rolled back: ${e.message}` });
         }
+        // record the decision in the persistent ledger and push it to clients
+        decideInsights(wf, chosen.map(insightKey), "applied");
+        sendAll("insights", { workflow: wf.name, ledger: loadInsights(wf) });
         return json(res, 200, {
           ok: true,
           applied: chosen.map((s) => s.id),
@@ -511,6 +697,80 @@ export function startServer({ statusPath, conductorPath: explicitConductor, port
       const wf = findWf(decodeURIComponent(m[1]));
       return wf ? json(res, 200, snapshotFor(wf)) : json(res, 404, { error: "not found" });
     }
+    if (req.method === "GET" && (m = url.match(/^\/api\/workflow\/([^/]+)\/insights$/))) {
+      const wf = findWf(decodeURIComponent(m[1]));
+      return wf ? json(res, 200, loadInsights(wf)) : json(res, 404, { error: "not found" });
+    }
+    if (req.method === "POST" && (m = url.match(/^\/api\/workflow\/([^/]+)\/insights\/decide$/))) {
+      const wf = findWf(decodeURIComponent(m[1]));
+      if (!wf) return json(res, 404, { error: "not found" });
+      readBody(req).then((bodyStr) => {
+        let body;
+        try {
+          body = JSON.parse(bodyStr || "{}");
+        } catch {
+          return json(res, 400, { error: "invalid request body" });
+        }
+        const keys = Array.isArray(body.keys) ? body.keys : [];
+        if (!["open", "applied", "dismissed"].includes(body.status))
+          return json(res, 400, { error: "status must be open | applied | dismissed" });
+        const changed = decideInsights(wf, keys, body.status);
+        sendAll("insights", { workflow: wf.name, ledger: loadInsights(wf) });
+        return json(res, 200, { ok: true, changed });
+      });
+      return;
+    }
+    // human approval — record the decisions into status.json (§4.4)
+    if (req.method === "POST" && (m = url.match(/^\/api\/workflow\/([^/]+)\/approve$/))) {
+      const wf = findWf(decodeURIComponent(m[1]));
+      if (!wf) return json(res, 404, { error: "not found" });
+      readBody(req).then((bodyStr) => {
+        let body;
+        try {
+          body = JSON.parse(bodyStr || "{}");
+        } catch {
+          return json(res, 400, { error: "invalid request body" });
+        }
+        const stepId = body.step;
+        const decisions = Array.isArray(body.decisions) ? body.decisions : [];
+        let status;
+        try {
+          status = JSON.parse(fs.readFileSync(wf.statusPath, "utf8"));
+        } catch {
+          return json(res, 500, { error: "could not read status.json" });
+        }
+        const step = status.steps && status.steps[stepId];
+        if (!step) return json(res, 404, { error: `no such step "${stepId}"` });
+        step.approval = step.approval || {};
+        const items = Array.isArray(step.approval.items) ? step.approval.items : [];
+        const byLabel = new Map(items.map((i) => [i.label, i]));
+        for (const d of decisions) {
+          if (!d || !d.label) continue;
+          const dec = d.decision === "approved" ? "approved" : "rejected";
+          if (byLabel.has(d.label)) byLabel.get(d.label).decision = dec;
+          else {
+            const it = { label: d.label, decision: dec };
+            items.push(it);
+            byLabel.set(d.label, it);
+          }
+        }
+        step.approval.items = items;
+        step.approval.decided_at = new Date().toISOString();
+        const anyRejected = items.some((i) => i.decision === "rejected");
+        step.approval.resolution = anyRejected ? "rejected" : "approved";
+        step.gate = anyRejected ? "rejected" : "approved";
+        try {
+          fs.writeFileSync(wf.statusPath, JSON.stringify(status, null, 2));
+        } catch (e) {
+          return json(res, 500, { error: `write failed: ${e.message}` });
+        }
+        return json(res, 200, { ok: true, resolution: step.approval.resolution });
+      });
+      return;
+    }
     if ((m = url.match(/^\/api\/workflow\/([^/]+)\/history$/))) {
       const wf = findWf(decodeURIComponent(m[1]));
       return wf ? json(res, 200, listHistory(wf.historyDir)) : json(res, 404, { error: "not found" });
@@ -537,6 +797,11 @@ export function startServer({ statusPath, conductorPath: explicitConductor, port
     }
     if (url === "/events") {
+      if (clients.size >= 5) {
+        // cap concurrent streams so stray tabs can't silently pile up memory
+        res.writeHead(429, { "content-type": "text/plain" });
+        return res.end("Too many board connections (max 5). Close a tab and reload.");
+      }
       res.writeHead(200, {
         "content-type": "text/event-stream",
         "cache-control": "no-cache",