@davidbalzan/groundwork-console 0.1.0

package/dist/server.js

@@ -0,0 +1,818 @@
+import "./env.js";
+import { Hono } from "hono";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execP = promisify(execFile);
+import { cors } from "hono/cors";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { loadConfig, saveProjects, validateProjectPath, CONFIG_FILE } from "./config.js";
+import { boardOf, docOf, docsIndex, phaseTasksOf } from "./seam.js";
+import { DocWriteError, sha256, writeDoc } from "./docwrite.js";
+import { agents, agentsAsync, rooms, roomMessages, roomMessageCount, statusStream, scopes, prefixOf } from "./bus.js";
+import { capturePane } from "./tmux.js";
+import { spawnAgent, suggestId, fleetStatus, FLEET_TEMPLATES, HARNESS_CMD, ROLE_SKILL } from "./provision.js";
+import { doctor, status, list, playbookList } from "./groundwork.js";
+import { groundworkSkills, playbookCards } from "./skills.js";
+import { extensionsOf } from "./extensions.js";
+import { parseWorkDoc, workstreamsExtensionsOf } from "@davidbalzan/groundwork-seam";
+import { EventEngine } from "./events.js";
+import { docGit, docsStatus, lastDocsCommit } from "./gitinfo.js";
+import { Notifier } from "./notify.js";
+import { Runs } from "./runs.js";
+import { BusClient, AGENT_ID, busWrites, seamWrites, saveSwitches, SWITCHES_FILE } from "./mcp.js";
+import { addQueueItem, reverifyFact, scopeAllows } from "./seamwrite.js";
+import { fileURLToPath } from "node:url";
+import { saveUpload, uploadPath, UPLOAD_DIR } from "./uploads.js";
+import { answered, markAnswered, isAnswered } from "./answered.js";
+import { requireAuth, login, logout, isAuthed, authEnabled, tokenFile } from "./auth.js";
+import { knowledgeIndex, knowledgeDoc, knowledgePath } from "./knowledge.js";
+import { requiresReport, groundworkCli, REQUIRES } from "./kitresolve.js";
+let cfg = loadConfig();
+const port = Number(process.env.PORT ?? 8790);
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const RULES = process.env.GROUNDWORK_CONSOLE_RULES ?? [path.join(process.env.HOME ?? "", ".groundwork-console", "rules.json"), path.resolve(HERE, "../groundwork-console.rules.json"), path.resolve(HERE, "../../../groundwork-console.rules.json")].find((f) => existsSync(f)) ?? path.resolve(HERE, "../../../groundwork-console.rules.json");
+const PKG = JSON.parse(readFileSync(path.resolve(HERE, "../package.json"), "utf8"));
+const runs = new Runs();
+const bus = new BusClient(cfg.kitPath, cfg.coordDir, "groundwork-console", process.env.AGENT_COORD_MCP);
+const events = new EventEngine(cfg, RULES, runs, (args, log) => bus.call("send_message", args, log));
+const notifier = new Notifier(cfg, runs, events);
+const busDavid = new BusClient(cfg.kitPath, cfg.coordDir, "david", process.env.AGENT_COORD_MCP);
+const clientFor = (id) => (id === "david" ? busDavid : bus);
+const PUBLIC_DIR = path.resolve(HERE, "../public");
+const root = new Hono();
+const app = new Hono().basePath("/api");
+app.use("*", cors({ origin: (o) => o ?? "*", credentials: true }));
+app.use("*", requireAuth());
+app.get("/auth/status", (c) => c.json({ enabled: authEnabled, authed: isAuthed(c) }));
+app.post("/auth/login", async (c) => { const b = (await c.req.json().catch(() => ({}))); if (!b.token || !login(c, b.token))
+    return c.json({ error: "wrong token — it's in ~/.groundwork-console/token (or GROUNDWORK_CONSOLE_TOKEN)" }, 401); return c.json({ ok: true }); });
+app.post("/auth/logout", (c) => { logout(c); return c.json({ ok: true }); });
+// One-click sign-in link printed by the bin (`groundwork-console` opens it): sets the cookie and redirects to the app. Token is the secret either way; the API is loopback by default.
+app.get("/auth/login", (c) => { const t = c.req.query("token") ?? ""; if (!login(c, t))
+    return c.json({ error: "wrong token" }, 401); return c.redirect(c.req.query("next") ?? "/"); });
+const project = (name) => cfg.projects.find((p) => p.name === name);
+app.get("/health", (c) => c.json({ ok: true, readOnly: !busWrites.enabled, busWrites: busWrites.enabled, version: PKG.version, requires: requiresReport(cfg.kitPath), config: CONFIG_FILE }));
+app.get("/admin/bus-writes", (c) => c.json(busWrites));
+app.get("/admin/seam-writes", (c) => c.json(seamWrites));
+app.post("/admin/seam-writes", async (c) => {
+    const b = (await c.req.json());
+    const r = await runs.exec({ kind: "cli", label: `seam writes ${b.enabled ? "ON" : "OFF"}`, sideEffects: true, args: { enabled: b.enabled } }, async (log) => { seamWrites.enabled = !!b.enabled; seamWrites.changedAt = Date.now(); seamWrites.by = "console"; saveSwitches(); log(`persisted → ${SWITCHES_FILE}`); log(`seam writes now ${seamWrites.enabled ? "ENABLED — Add item / Re-verify write through the seam" : "disabled"}`); return { ...seamWrites }; });
+    return c.json(r);
+});
+/* ---- v0.2 seam writes (through @davidbalzan/groundwork-seam only; round-trip guarded; scope-checked) ---- */
+app.post("/actions/queue-add/:name", async (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    if (!seamWrites.enabled)
+        return c.json({ error: "seam writes are off (header → seam)" }, 403);
+    const b = (await c.req.json());
+    if (!["P1", "P2", "P3"].includes(b.priority) || !b.text?.trim())
+        return c.json({ error: "priority P1|P2|P3 and text required" }, 400);
+    const sc = scopeAllows(scopes(cfg.coordDir), "docs/QUEUE.md");
+    if (!sc.ok)
+        return c.json({ error: sc.reason }, 403);
+    const r = await runs.exec({ kind: "seam", label: `queue add (${b.priority}) · ${p.name}`, project: p.name, sideEffects: true, args: { priority: b.priority, text: b.text.slice(0, 200) } }, async (log) => { log(`scope: ${sc.reason}`); return addQueueItem(p.path, b, log); });
+    return c.json(r, r.status === "ok" ? 200 : 500);
+});
+app.post("/actions/fact-reverify/:name", async (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    if (!seamWrites.enabled)
+        return c.json({ error: "seam writes are off (header → seam)" }, 403);
+    const b = (await c.req.json());
+    if (!b.id || !b.method?.trim())
+        return c.json({ error: "id and method required" }, 400);
+    const sc = scopeAllows(scopes(cfg.coordDir), "docs/FACTS.md");
+    if (!sc.ok)
+        return c.json({ error: sc.reason }, 403);
+    const r = await runs.exec({ kind: "seam", label: `re-verify fact ${b.id} · ${p.name}`, project: p.name, sideEffects: true, args: { id: b.id, method: b.method } }, async (log) => { log(`scope: ${sc.reason}`); return reverifyFact(p.path, { id: b.id, claim: b.claim, by: b.by ?? "david", method: b.method }, log); });
+    return c.json(r, r.status === "ok" ? 200 : 500);
+});
+app.post("/admin/bus-writes", async (c) => {
+    const b = (await c.req.json());
+    const r = await runs.exec({ kind: "cli", label: `bus writes ${b.enabled ? "ON" : "OFF"}`, sideEffects: true, args: { enabled: b.enabled } }, async (log) => { busWrites.enabled = !!b.enabled; busWrites.changedAt = Date.now(); busWrites.by = "console"; saveSwitches(); log(`persisted → ${SWITCHES_FILE}`); log(`bus writes now ${busWrites.enabled ? "ENABLED — groundwork-console + david may send_message" : "disabled"}`); return { ...busWrites }; });
+    return c.json(r);
+});
+/* Send a message on the bus. Rooms require a playbook prefix (room rules); DMs are free text. `as` picks the identity. */
+app.post("/actions/send", async (c) => {
+    const b = (await c.req.json());
+    const who = b.as === "groundwork-console" ? "groundwork-console" : "david";
+    if (!b.text?.trim())
+        return c.json({ error: "text required" }, 400);
+    if (!b.room && !b.to)
+        return c.json({ error: "room or to required" }, 400);
+    const PREFIX_RE = /^(BLOCKER|RISK|DONE|FYI|AGENT_ACTION|GO|SCOPE CHANGE|VERDICT|DAVID_DECISION)\b/;
+    if (b.room && !PREFIX_RE.test(b.text))
+        return c.json({ error: "room posts need a prefix (FYI / AGENT_ACTION / DAVID_DECISION / BLOCKER / RISK / DONE / GO / SCOPE CHANGE / VERDICT)" }, 400);
+    const target = b.to ? `→ ${b.to}` : `#${b.room.replace(/^#/, "")}`;
+    const r = await runs.exec({ kind: "bus", label: `send as ${who} ${target}`, sideEffects: true, args: { as: who, room: b.room, to: b.to, kind: b.kind, text: b.text.slice(0, 200) } }, async (log) => {
+        const out = await clientFor(who).call("send_message", { ...(b.to ? { to: b.to } : { room: b.room.replace(/^#/, "") }), text: b.text, ...(b.kind ? { kind: b.kind } : {}) }, log);
+        // Answered bookkeeping (console-owned, until the bus has inReplyTo): explicit ids from the UI, plus — for a DM as David — every open DAVID_DECISION DM from that agent.
+        if (who === "david") {
+            const ids = [...(b.answers ?? [])];
+            if (b.to) {
+                const f = path.join(cfg.coordDir, "inbox", "david.jsonl");
+                if (existsSync(f))
+                    for (const l of readFileSync(f, "utf8").split("\n").filter(Boolean)) {
+                        try {
+                            const m = JSON.parse(l);
+                            if (m.from === b.to && typeof m.text === "string" && m.text.startsWith("DAVID_DECISION") && m.id)
+                                ids.push(m.id);
+                        }
+                        catch { /* skip */ }
+                    }
+            }
+            const n = markAnswered(ids, { by: "david", to: b.to ?? b.room, note: b.text.slice(0, 80) });
+            if (n)
+                log(`answered: ${n} decision packet${n === 1 ? "" : "s"} marked (console-owned ~/.groundwork-console/answered.json)`);
+        }
+        return out;
+    });
+    return c.json(r, r.status === "ok" ? 200 : 403);
+});
+/* Uploads — pasted images for DMs. Path + served URL both go into the message text as `[image: <path> · <url>]`.
+   Gated like DMs (bus writes) since the only purpose is to send them; the store is console-owned (~/.groundwork-console/uploads). */
+app.post("/uploads", async (c) => {
+    if (!busWrites.enabled)
+        return c.json({ error: "bus writes are off — uploads are only for DMs" }, 403);
+    const form = await c.req.formData().catch(() => null);
+    const f = form?.get("file");
+    if (!(f instanceof File))
+        return c.json({ error: "multipart field 'file' required" }, 400);
+    try {
+        const apiBase = process.env.GROUNDWORK_CONSOLE_PUBLIC_API ?? `http://localhost:${port}/api`; // the API's own port — stable for agents; the web dev proxy is not
+        const u = saveUpload(Buffer.from(await f.arrayBuffer()), f.type, apiBase, new Date().toISOString().slice(0, 10));
+        return c.json(u);
+    }
+    catch (e) {
+        return c.json({ error: e.message }, 400);
+    }
+});
+app.get("/uploads/:name", (c) => {
+    const u = uploadPath(c.req.param("name"));
+    if (!u)
+        return c.json({ error: "not found" }, 404);
+    return c.body(readFileSync(u.path), 200, { "Content-Type": u.mime, "Content-Length": String(u.bytes), "Cache-Control": "public, max-age=31536000, immutable" });
+});
+app.get("/uploads", (c) => c.json({ dir: UPLOAD_DIR }));
+/* Global knowledge repo (cross-project ADRs + notes) — resolved like `groundwork knowledge path`. Read-only. */
+app.get("/knowledge", (c) => c.json(knowledgeIndex()));
+app.get("/knowledge/doc/*", async (c) => {
+    const rel = decodeURIComponent(c.req.path.split("/knowledge/doc/")[1] ?? "");
+    const d = knowledgeDoc(rel);
+    if (!d)
+        return c.json({ error: "not found" }, 404);
+    const root = knowledgePath().path;
+    const git = await docGit(root, d.path);
+    return c.json({ path: d.path, source: d.source, git, sha: sha256(d.source), root });
+});
+app.get("/kit", (c) => {
+    const p = path.join(cfg.kitPath, "kit.json");
+    if (existsSync(p))
+        return c.json({ ...JSON.parse(readFileSync(p, "utf8")), source: "kit checkout", requires: requiresReport(cfg.kitPath) });
+    // No kit checkout on this machine: synthesize the manifest from what is installed (npm) so the Home strip / Release still say something true.
+    const r = requiresReport(cfg.kitPath);
+    return c.json({ name: "groundwork-kit", kitVersion: null, source: "installed packages", packages: { seam: { name: "@davidbalzan/groundwork-seam", version: r.seam.installed }, groundwork: { name: "@davidbalzan/groundwork", version: r.groundwork.installed }, playbook: { name: "agent-coordination", version: r.playbook.installed }, mcp: { name: "agent-coord-mcp", version: r.mcp.installed } }, requires: r, schemas: ["queue.v1", "done.v1", "facts.v1", "workstreams.v1"], consoleRequires: REQUIRES });
+});
+app.get("/projects", (c) => {
+    const sc = scopes(cfg.coordDir);
+    const kitGw = (() => { try {
+        return JSON.parse(readFileSync(path.join(cfg.kitPath, "packages/groundwork/package.json"), "utf8")).version;
+    }
+    catch {
+        return null;
+    } })();
+    const liveAgents = agents(cfg.coordDir).filter((a) => a.liveness !== "dead");
+    return c.json(cfg.projects.map((p) => {
+        const b = boardOf(p.path);
+        const fleet = fleetStatus(liveAgents.filter((a) => a.project === p.room || a.project === p.name));
+        const seamM = ["WORKSTREAMS.md", "QUEUE.md", "DONE.md", "FACTS.md"].map((f) => path.join(p.path, "docs", f)).filter(existsSync).map((f) => statSync(f).mtimeMs);
+        const roomM = p.room ? (rooms(cfg.coordDir).find((r) => r.room === p.room)?.lastTs ?? 0) : 0;
+        const lastActive = Math.max(0, ...seamM, roomM) || null;
+        const lastActiveSource = lastActive === roomM ? "bus" : lastActive ? "seam" : null;
+        const markerPath = path.join(p.path, "docs/.groundwork/VERSION");
+        const versionMarker = existsSync(markerPath) ? readFileSync(markerPath, "utf8").trim() : null;
+        return { name: p.name, path: p.path, room: p.room, files: b.files, schema: b.workstreams.schema, versionMarker, kitGroundwork: kitGw, behind: !!versionMarker && !!kitGw && versionMarker !== kitGw, lastActive, lastActiveSource, fleet, counts: { streams: b.workstreams.rows.filter((r) => !("malformed" in r && r.malformed)).length, queue: b.queue.filter((q) => !q.done).length, done: b.done.length, staleFacts: b.facts?.entries.filter((e) => e.stale).length ?? 0, malformed: b.workstreams.rows.filter((r) => "malformed" in r).length }, phases: b.phases.length, phaseStrip: b.phases.map((ph) => ({ n: ph.n, state: ph.state, done: ph.done, total: ph.total })), scopesDeclared: Object.keys(sc).length };
+    }));
+});
+app.get("/projects/:name/board", (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    return c.json({ ...boardOf(p.path), scopes: scopes(cfg.coordDir) });
+});
+app.get("/projects/:name/phases/:phase/tasks", (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    const t = phaseTasksOf(path.join(p.path, "docs"), c.req.param("phase"));
+    return t ? c.json(t) : c.json({ error: "no such phase" }, 404);
+});
+app.get("/projects/:name/docs", async (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    const [status, last] = await Promise.all([docsStatus(p.path), lastDocsCommit(p.path)]);
+    return c.json({ files: docsIndex(p.path), status, lastCommit: last });
+});
+app.get("/projects/:name/docs/*", async (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    const rel = decodeURIComponent(c.req.path.split(`/docs/`)[1] ?? "");
+    const src = docOf(p.path, rel);
+    if (src === null)
+        return c.json({ error: "not found" }, 404);
+    const git = await docGit(p.path, `docs/${rel}`);
+    return c.json({ path: `docs/${rel}`, source: src, git, sha: sha256(src) });
+});
+app.put("/projects/:name/docs/*", async (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    if (!seamWrites.enabled)
+        return c.json({ error: "seam writes are off (header → seam)" }, 403);
+    const rel = decodeURIComponent(c.req.path.split(`/docs/`)[1] ?? "");
+    const b = (await c.req.json().catch(() => ({})));
+    if (typeof b.content !== "string")
+        return c.json({ error: "content (string) required" }, 400);
+    if (!b.ifMatch || typeof b.ifMatch !== "string")
+        return c.json({ error: "ifMatch (sha256 of last GET) required" }, 400);
+    if (b.content.length > 2_000_000)
+        return c.json({ error: "content exceeds 2 MB" }, 400);
+    const content = b.content;
+    const ifMatch = b.ifMatch;
+    const r = await runs.exec({ kind: "seam", label: `docs write ${rel}`, project: p.name, sideEffects: true, args: { file: rel, bytes: Buffer.byteLength(content, "utf8") } }, async (log) => {
+        const sc = scopeAllows(scopes(cfg.coordDir), `docs/${rel}`);
+        log(`scope: ${sc.reason}`);
+        if (!sc.ok)
+            throw new DocWriteError(sc.reason, 403);
+        return writeDoc(p.path, rel, content, ifMatch, log);
+    });
+    const result = r.result;
+    if (r.status !== "ok") {
+        const err = r.error ?? "write failed";
+        const status = err.startsWith("conflict:") ? 409 : err === "not found" ? 404 : /scope owner is|seam writes are off/.test(err) ? 403 : 400;
+        const sha = status === 409 ? sha256(docOf(p.path, rel) ?? "") : undefined;
+        return c.json({ error: err, sha, run: r }, status);
+    }
+    return c.json({ sha: result?.sha, run: r });
+});
+app.get("/projects/:name/doctor", async (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    return c.json(await doctor(cfg.kitPath, p.path));
+});
+app.get("/projects/:name/status", async (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    return c.json(await status(cfg.kitPath, p.path));
+});
+app.get("/projects/:name/skills", async (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    const [gl, pl] = await Promise.all([list(cfg.kitPath, p.path), playbookList(cfg.kitPath)]);
+    const sync = groundworkSkills(cfg.kitPath, p.path);
+    const cards = playbookCards(cfg.kitPath);
+    return c.json({
+        groundwork: { versionMarker: gl.version || sync.versionMarker, kitVersion: sync.kitVersion, driftedVersion: (gl.version || sync.versionMarker) !== sync.kitVersion, error: gl.error,
+            skills: gl.skills.map((s) => ({ ...s, tier: s.set, inSync: sync.skills.find((x) => x.name === s.name)?.inSync ?? null })) },
+        playbook: { kitVersion: pl.version || cards.kitVersion, globalDir: cards.globalDir, homes: cards.homes, legacyDirs: cards.legacyDirs, error: pl.error,
+            cards: pl.cards.map((k) => { const x = cards.cards.find((y) => y.name === k.name); const kh = k.harness; return { ...k, inSync: x?.inSync ?? null, slices: x?.slices ?? 0, legacyEssay: x?.legacyEssay ?? false, homes: x?.homes ?? {}, mirrors: { cursor: kh.cursor, vscode: kh.vscode, opencode: kh.opencode, grok: kh.grok ?? x?.homes?.grok?.installed ?? false } }; }) },
+    });
+});
+app.get("/projects/:name/release", (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    const ws = path.join(p.path, "docs/WORKSTREAMS.md");
+    const src = existsSync(ws) ? readFileSync(ws, "utf8") : null;
+    const room = p.room ? roomMessages(cfg.coordDir, p.room, 200) : [];
+    const verdicts = room.filter((m) => typeof m.text === "string" && /^(VERDICT|DONE)\b/.test(m.text)).slice(-20).reverse();
+    const ext = src ? workstreamsExtensionsOf(parseWorkDoc(src)) : null;
+    const toSec = (title, rows) => ({ title, table: rows.length ? { headers: Object.keys(rows[0]), rows } : undefined, raw: "" });
+    const extensions = ext ? [toSec("Open PRs", ext.openPrs), toSec("Cutover Gates", ext.cutoverGates), toSec("Needs David", ext.needsDavid), toSec("Risks", ext.risks), toSec("Rooms", ext.rooms), { title: "Decisions Recorded", bullets: ext.decisions, raw: "" }].filter((s) => s.table || s.bullets?.length) : extensionsOf(src);
+    return c.json({ extensions, telemetry: verdicts, source: ext ? "seam workstreamsExtensionsOf" : "interim parser" });
+});
+app.get("/needs-david", (c) => {
+    const out = [];
+    for (const p of cfg.projects) {
+        const ws = path.join(p.path, "docs/WORKSTREAMS.md");
+        const wsSrc = existsSync(ws) ? readFileSync(ws, "utf8") : null;
+        const rows = wsSrc ? workstreamsExtensionsOf(parseWorkDoc(wsSrc)).needsDavid : [];
+        const wsTs = existsSync(ws) ? statSync(ws).mtimeMs : undefined; // best available age for a table row: when the board file last changed
+        for (const r of rows) {
+            const [title, ...rest] = Object.values(r);
+            if (title)
+                out.push({ project: p.name, source: "WORKSTREAMS ## Needs David", title, detail: rest.filter(Boolean).join(" · "), ts: wsTs });
+        }
+        if (p.room)
+            for (const m of roomMessages(cfg.coordDir, p.room, 100))
+                if (typeof m.text === "string" && m.text.startsWith("DAVID_DECISION"))
+                    out.push({ project: p.name, source: `#${p.room} DAVID_DECISION`, title: m.text.replace(/^DAVID_DECISION:?\s*/, "").slice(0, 200), ts: m.ts, from: m.from, msgId: m.id, room: p.room });
+    }
+    // DAVID_DECISION DMs (inbox/david.jsonl) — the aide's decision packets arrive here, not in a room.
+    const inboxFile = path.join(cfg.coordDir, "inbox", "david.jsonl");
+    if (existsSync(inboxFile)) {
+        const ag = agents(cfg.coordDir);
+        for (const l of readFileSync(inboxFile, "utf8").split("\n").filter(Boolean)) {
+            let m;
+            try {
+                m = JSON.parse(l);
+            }
+            catch {
+                continue;
+            }
+            if (typeof m.text !== "string" || !m.text.startsWith("DAVID_DECISION"))
+                continue;
+            const from = String(m.from ?? "");
+            const ap = ag.find((a) => a.agentId === from)?.project;
+            const proj = cfg.projects.find((p) => p.name === ap || p.room === ap)?.name ?? ap ?? "—";
+            out.push({ project: proj, source: `DM from ${from} · DAVID_DECISION`, title: m.text.replace(/^DAVID_DECISION:?\s*/, "").slice(0, 200), ts: m.ts, from, msgId: m.id });
+        }
+    }
+    return c.json(out.filter((n) => !isAnswered(n.msgId)).sort((a, b) => (b.ts ?? 0) - (a.ts ?? 0)));
+});
+app.get("/events", (c) => c.json({ config: events.config, recent: events.recent(Number(c.req.query("limit") ?? 100)) }));
+app.post("/events/config", async (c) => {
+    const b = (await c.req.json());
+    if (b.dryRun === false && b.confirm !== "LIVE")
+        return c.json({ error: "confirm must be LIVE to turn dryRun off" }, 400);
+    const r = await runs.exec({ kind: "cli", label: b.rule ? `rule ${b.rule} ${b.enabled ? "enabled" : "disabled"}` : `events dryRun ${b.dryRun ? "ON" : "OFF"}`, sideEffects: true, args: b }, async (log) => {
+        if (typeof b.dryRun === "boolean") {
+            events.setDryRun(b.dryRun);
+            log(`dryRun=${b.dryRun}`);
+        }
+        if (b.rule) {
+            events.setRuleEnabled(b.rule, !!b.enabled);
+            log(`rule ${b.rule} enabled=${!!b.enabled}`);
+        }
+        log(`live sends: ${events.config.live ? "YES (writes on + dryRun off) for enabled rules" : "no"}`);
+        return events.config;
+    });
+    return c.json(r, r.status === "ok" ? 200 : 400);
+});
+app.get("/events/stream", (c) => {
+    const stream = new ReadableStream({
+        start(controller) {
+            const enc = new TextEncoder();
+            const send = (e) => controller.enqueue(enc.encode(`data: ${JSON.stringify(e)}\n\n`));
+            send({ type: "hello", config: events.config });
+            const off = events.subscribe(send);
+            const ka = setInterval(() => controller.enqueue(enc.encode(": keepalive\n\n")), 25_000);
+            c.req.raw.signal.addEventListener("abort", () => { off(); clearInterval(ka); try {
+                controller.close();
+            }
+            catch { /* closed */ } });
+        },
+    });
+    return new Response(stream, { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" } });
+});
+/* ---- Project registry (console-owned config; writing it is allowed) ---- */
+/* Path completion for Add project: directories under the typed prefix (home-relative), flagged with docs/ + registered. Read-only, never lists files. */
+app.get("/projects/browse", (c) => {
+    const raw = c.req.query("prefix") ?? "~/";
+    const home = process.env.HOME ?? "";
+    const expand = (p) => (p.startsWith("~") ? path.join(home, p.slice(1)) : p);
+    const abs = expand(raw);
+    const dir = raw.endsWith("/") ? abs : path.dirname(abs);
+    const part = raw.endsWith("/") ? "" : path.basename(abs).toLowerCase();
+    if (!existsSync(dir))
+        return c.json({ dirs: [] });
+    const registered = new Set(cfg.projects.map((p) => p.path));
+    const dirs = readdirSync(dir, { withFileTypes: true })
+        .filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules" && e.name.toLowerCase().startsWith(part))
+        .slice(0, 40)
+        .map((e) => { const full = path.join(dir, e.name); const shown = raw.startsWith("~") ? "~" + full.slice(home.length) : full; return { path: shown + "/", name: e.name, hasDocs: existsSync(path.join(full, "docs")), isGit: existsSync(path.join(full, ".git")), registered: registered.has(full) }; })
+        .sort((a, b) => Number(b.hasDocs) - Number(a.hasDocs) || a.name.localeCompare(b.name));
+    return c.json({ dirs });
+});
+app.post("/projects/validate", async (c) => { const b = (await c.req.json()); return c.json(validateProjectPath(b.path ?? "")); });
+app.post("/projects", async (c) => {
+    const b = (await c.req.json());
+    if (!b.name || !/^[a-z0-9][a-z0-9-_]*$/i.test(b.name))
+        return c.json({ error: "name: letters, digits, - _" }, 400);
+    if (cfg.projects.some((p) => p.name === b.name))
+        return c.json({ error: "name already registered" }, 409);
+    const v = validateProjectPath(b.path ?? "");
+    if (!v.ok)
+        return c.json({ error: v.reason }, 400);
+    const next = [...cfg.projects, { name: b.name, path: v.path, room: b.room || undefined }];
+    const r = await runs.exec({ kind: "cli", label: `add project · ${b.name}`, project: b.name, sideEffects: true, args: { path: v.path, room: b.room } }, async (log) => { saveProjects(next); cfg = loadConfig(); log(`groundwork-console.config.json: +${b.name} (${v.path})${b.room ? ` · room #${b.room}` : ""}`); return { added: b.name, seam: v.hasSeam, isGit: v.isGit }; });
+    return c.json(r, r.status === "ok" ? 200 : 500);
+});
+app.delete("/projects/:name", async (c) => {
+    const name = c.req.param("name");
+    if (!cfg.projects.some((p) => p.name === name))
+        return c.json({ error: "unknown project" }, 404);
+    const r = await runs.exec({ kind: "cli", label: `remove project · ${name}`, project: name, sideEffects: true }, async (log) => { saveProjects(cfg.projects.filter((p) => p.name !== name)); cfg = loadConfig(); log(`groundwork-console.config.json: -${name} (repo untouched)`); return { removed: name }; });
+    return c.json(r);
+});
+/* ---- Decommission a fleet + channel: bus writes, gated by GROUNDWORK_CONSOLE_BUS_WRITES ---- */
+app.post("/actions/decommission", async (c) => {
+    const b = (await c.req.json());
+    const room = b.room;
+    if (!room)
+        return c.json({ error: "room required" }, 400);
+    if (b.confirm !== room)
+        return c.json({ error: "confirm must equal the room name" }, 400);
+    const dry = b.dryRun ?? !busWrites.enabled;
+    const members = (rooms(cfg.coordDir).find((r) => r.room === room)?.members ?? []);
+    const proj = cfg.projects.find((p) => p.room === room);
+    const agentsOf = agents(cfg.coordDir).filter((a) => members.includes(a.agentId) || a.project === room || (proj && a.project === proj.name)).map((a) => a.agentId);
+    const r = await runs.exec({ kind: "mcp", label: `decommission #${room}${dry ? " (dry-run)" : ""}`, project: proj?.name, sideEffects: !dry, args: { room, agents: agentsOf, removeProject: !!b.removeProject, dryRun: dry } }, async (log) => {
+        log(`plan: force_unregister ${agentsOf.length} agent(s) → delete_room #${room}${b.removeProject && proj ? ` → remove project ${proj.name} from config` : ""}`);
+        if (dry) {
+            log("dry-run: bus writes are off; nothing sent");
+            return { dryRun: true, wouldUnregister: agentsOf, wouldDeleteRoom: room, wouldRemoveProject: b.removeProject ? proj?.name : null };
+        }
+        for (const id of agentsOf) {
+            await bus.call("force_unregister", { targetAgentId: id }, log);
+        }
+        await bus.call("delete_room", { room, force: true }, log);
+        if (b.removeProject && proj) {
+            saveProjects(cfg.projects.filter((p) => p.name !== proj.name));
+            cfg = loadConfig();
+            log(`config: -${proj.name}`);
+        }
+        return { unregistered: agentsOf, deletedRoom: room, removedProject: b.removeProject ? proj?.name : null };
+    });
+    return c.json(r, r.status === "ok" ? 200 : 500);
+});
+/* ---- Inbox as david (read-only tool, but needs the david identity → session spawns even with writes off) ---- */
+/* Inbox as david: peek reads (not Runs) with the bus's own unread count (`totalNew` vs david's cursor); marking read advances the cursor (a Run). */
+app.get("/bus/inbox", async (c) => {
+    try {
+        const out = (await busDavid.call("read_messages", { source: "inbox", peek: true, limit: Number(c.req.query("limit") ?? 100) }));
+        // peek returns only unread; add the already-read tail from the file so the view is complete, flagged.
+        const file = path.join(cfg.coordDir, "inbox", "david.jsonl");
+        const all = existsSync(file) ? readFileSync(file, "utf8").split("\n").filter(Boolean).map((l) => { try {
+            return JSON.parse(l);
+        }
+        catch {
+            return null;
+        } }).filter(Boolean) : [];
+        const unreadIds = new Set(out.messages.map((m) => m.id));
+        const messages = all.map((m) => ({ ...m, unread: unreadIds.has(m.id) && !isAnswered(m.id), answered: isAnswered(m.id), prefix: prefixOf(String(m.text ?? "")) }));
+        // Pending decisions per sender: unread, unanswered DAVID_DECISION DMs — the avatar cue.
+        const decisions = {};
+        for (const m of messages)
+            if (m.unread && m.prefix === "DAVID_DECISION" && typeof m.from === "string")
+                decisions[m.from] = (decisions[m.from] ?? 0) + 1;
+        return c.json({ ok: true, unread: messages.filter((m) => m.unread).length, messages, decisions });
+    }
+    catch (e) {
+        return c.json({ error: e.message }, 500);
+    }
+});
+/* DM thread with one agent, both directions: their DMs to david (inbox/david.jsonl) + david's DMs to them (inbox/<agent>.jsonl).
+   Read-only file scan (no cursor consumed) — this is a view, the Bus inbox stays the place that marks read. */
+app.get("/bus/answered", (c) => c.json(answered()));
+app.post("/bus/answered", async (c) => { const b = (await c.req.json()); const n = markAnswered(b.ids ?? [], { by: "david", note: b.note }); return c.json({ ok: true, marked: n }); });
+app.get("/bus/dm/:agent", (c) => {
+    const agent = c.req.param("agent");
+    const limit = Number(c.req.query("limit") ?? 80);
+    const readJsonl = (f) => existsSync(f) ? readFileSync(f, "utf8").split("\n").filter(Boolean).map((l) => { try {
+        return JSON.parse(l);
+    }
+    catch {
+        return null;
+    } }).filter(Boolean) : [];
+    const mine = readJsonl(path.join(cfg.coordDir, "inbox", "david.jsonl")).filter((m) => m.from === agent);
+    const theirs = readJsonl(path.join(cfg.coordDir, "inbox", `${agent}.jsonl`)).filter((m) => m.from === "david");
+    const messages = [...mine, ...theirs].sort((a, b) => Number(a.ts ?? 0) - Number(b.ts ?? 0)).slice(-limit).map((m) => ({ ...m, prefix: prefixOf(String(m.text ?? "")) }));
+    return c.json({ agent, messages, lastFromAgent: mine.length ? Number(mine[mine.length - 1].ts ?? 0) : 0 });
+});
+app.post("/bus/inbox/read", async (c) => {
+    const r = await runs.exec({ kind: "mcp", label: "mark inbox read · david", sideEffects: true, args: { source: "inbox" } }, (log) => busDavid.call("read_messages", { source: "inbox", peek: false, limit: 500 }, log));
+    return c.json(r, r.status === "ok" ? 200 : 500);
+});
+app.get("/bus/unread", async (c) => {
+    try {
+        const out = (await busDavid.call("read_messages", { source: "inbox", peek: true, limit: 200 }));
+        return c.json({ inbox: out.messages.filter((m) => !isAnswered(m.id)).length });
+    }
+    catch {
+        return c.json({ inbox: 0, error: "inbox unavailable" });
+    }
+});
+/* ---- CLI updates (repo / global writes) as shell Runs; playbook has native --dry-run; groundwork update reports git status after ---- */
+app.post("/actions/groundwork-update/:name", async (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    const b = (await c.req.json().catch(() => ({})));
+    if (b.confirm !== p.name)
+        return c.json({ error: "confirm must equal the project name" }, 400);
+    const cli = groundworkCli(cfg.kitPath) ?? path.join(cfg.kitPath, "packages/groundwork/src/cli.mjs");
+    const argv = [cli, "update", p.path, ...(b.all ? ["--all"] : []), ...(b.docs ? ["--docs"] : [])];
+    const r = await runs.exec({ kind: "shell", label: `groundwork update · ${p.name}${b.all ? " --all" : ""}${b.docs ? " --docs" : ""}`, project: p.name, sideEffects: true, args: { argv: argv.slice(1) } }, async (log) => {
+        log(`$ node ${argv.map((a) => a.replace(cfg.kitPath, "<kit>").replace(p.path, "<repo>")).join(" ")}`);
+        const out = await execP("node", argv, { timeout: 120_000, maxBuffer: 8 << 20 }).catch((e) => { log(`exit: ${e.message}`); return { stdout: e.stdout ?? "", stderr: e.stderr ?? "" }; });
+        for (const l of (out.stdout + out.stderr).replace(/\x1b\[[0-9;]*m/g, "").split("\n").filter(Boolean).slice(0, 80))
+            log(l);
+        const st = await execP("git", ["status", "--porcelain"], { cwd: p.path }).then((x) => x.stdout).catch(() => "");
+        const changed = st.split("\n").filter(Boolean);
+        log(`git status: ${changed.length} path(s) changed`);
+        return { changed, cli: "groundwork update" };
+    });
+    return c.json(r, r.status === "ok" ? 200 : 500);
+});
+app.post("/actions/playbook-update", async (c) => {
+    const b = (await c.req.json().catch(() => ({})));
+    const dry = b.dryRun !== false;
+    if (!dry && b.confirm !== "UPDATE")
+        return c.json({ error: "confirm must be UPDATE to apply" }, 400);
+    const cli = path.join(cfg.kitPath, "packages/coord-playbook/bin/install.mjs");
+    const argv = [cli, "update", ...(dry ? ["--dry-run"] : [])];
+    const r = await runs.exec({ kind: "shell", label: `agent-coordination update${dry ? " (dry-run)" : ""}`, sideEffects: !dry, args: { argv: argv.slice(1) } }, async (log) => {
+        log(`$ node ${argv.map((a) => a.replace(cfg.kitPath, "<kit>")).join(" ")}`);
+        const out = await execP("node", argv, { timeout: 120_000, maxBuffer: 8 << 20 }).catch((e) => { log(`exit: ${e.message}`); return { stdout: e.stdout ?? "", stderr: e.stderr ?? "" }; });
+        const lines = (out.stdout + out.stderr).replace(/\x1b\[[0-9;]*m/g, "").split("\n").filter(Boolean);
+        for (const l of lines.slice(0, 120))
+            log(l);
+        return { lines: lines.length, dryRun: dry };
+    });
+    return c.json(r, r.status === "ok" ? 200 : 500);
+});
+/* ---- Spawn agent (v0.3): tmux pane + harness + role skill; gated by bus writes; a shell Run ---- */
+app.get("/projects/:name/fleet", async (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    const live = (await agentsAsync(cfg.coordDir)).filter((a) => a.liveness !== "dead" && (a.project === p.room || a.project === p.name));
+    return c.json({ ...fleetStatus(live), templates: FLEET_TEMPLATES, window: `fleet-${p.name}` });
+});
+app.post("/actions/spawn-fleet", async (c) => {
+    if (!busWrites.enabled)
+        return c.json({ error: "bus writes are off (header toggle)" }, 403);
+    const b = (await c.req.json());
+    const p = project(b.project);
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    const t = FLEET_TEMPLATES.find((x) => x.id === b.template);
+    if (!t)
+        return c.json({ error: "unknown template" }, 400);
+    if (!HARNESS_CMD[b.harness])
+        return c.json({ error: "harness invalid" }, 400);
+    const ids = () => agents(cfg.coordDir).map((a) => a.agentId);
+    const attached = (id) => existsSync(path.join(cfg.coordDir, "transports", `${id}.json`));
+    const workers = Math.min(Math.max(b.workers ?? t.workers, 0), 8);
+    const plan = [...t.roles.map((role) => ({ role, harness: role === "ci" ? (b.ciHarness ?? b.harness) : b.harness })), ...Array.from({ length: workers }, (_, i) => ({ role: "worker", harness: b.harness, lane: b.lanes?.[i] }))];
+    const r = runs.execAsync({ kind: "shell", label: `spawn fleet · ${t.id} · ${p.name} (${plan.length} agents)`, project: p.name, sideEffects: true, args: { template: t.id, harness: b.harness, workers, lanes: b.lanes } }, async (log) => {
+        const out = [];
+        for (const step of plan) {
+            const agentId = suggestId(p.name, step.role, [...ids(), ...out.map((o) => o.agentId)]);
+            log(`── ${step.role} → ${agentId} (${step.harness})`);
+            const res = await spawnAgent({ project: p.name, repoPath: p.path, room: p.room, role: step.role, harness: step.harness, agentId, lane: step.lane, waitSeconds: b.waitSeconds }, (id) => ids().includes(id), log, attached);
+            out.push({ agentId: res.agentId, pane: res.pane, registered: res.registered, attached: res.attached });
+        }
+        log(`fleet ${t.id}: ${out.filter((o) => o.registered).length}/${out.length} registered · ${out.filter((o) => o.attached).length}/${out.length} attached`);
+        return { template: t.id, agents: out };
+    });
+    return c.json(r);
+});
+app.get("/actions/spawn/options", (c) => {
+    const p = c.req.query("project") ? project(c.req.query("project")) : undefined;
+    const ids = agents(cfg.coordDir).map((a) => a.agentId);
+    return c.json({ harnesses: Object.entries(HARNESS_CMD).map(([k, v]) => ({ id: k, cmd: v })), roles: Object.entries(ROLE_SKILL).map(([k, v]) => ({ id: k, skill: v })), suggest: p ? Object.fromEntries(Object.keys(ROLE_SKILL).map((r) => [r, suggestId(p.name, r, ids)])) : {}, room: p?.room ?? null, repoPath: p?.path ?? null, tmux: !!process.env.TMUX || true });
+});
+app.post("/actions/spawn", async (c) => {
+    if (!busWrites.enabled)
+        return c.json({ error: "bus writes are off (header toggle)" }, 403);
+    const b = (await c.req.json());
+    const p = project(b.project);
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    if (!ROLE_SKILL[b.role] || !HARNESS_CMD[b.harness])
+        return c.json({ error: "role/harness invalid" }, 400);
+    const ids = () => agents(cfg.coordDir).map((a) => a.agentId);
+    const attached = (id) => existsSync(path.join(cfg.coordDir, "transports", `${id}.json`));
+    const agentId = b.agentId?.trim() || suggestId(p.name, b.role, ids());
+    const r = runs.execAsync({ kind: "shell", label: `spawn ${agentId} (${b.role} · ${b.harness}) → fleet-${p.name}`, project: p.name, sideEffects: true, args: { role: b.role, harness: b.harness, agentId, lane: b.lane, model: b.model } }, (log) => spawnAgent({ project: p.name, repoPath: p.path, room: p.room, role: b.role, harness: b.harness, agentId, lane: b.lane, model: b.model, note: b.note, waitSeconds: b.waitSeconds }, (id) => ids().includes(id), log, attached));
+    return c.json(r);
+});
+/* ---- Gated bus admin: prune stale, unregister one (writes; require switch + confirm) ---- */
+app.post("/actions/prune", async (c) => {
+    const b = (await c.req.json().catch(() => ({})));
+    const dry = b.dryRun !== false;
+    if (!dry && b.confirm !== "PRUNE")
+        return c.json({ error: "confirm must be PRUNE to apply" }, 400);
+    const args = { ...(b.olderThanDays ? { olderThanDays: b.olderThanDays } : {}), ...(b.targets?.length ? { targets: b.targets } : {}), ...(b.room ? { room: b.room } : {}), ...(b.removeOrphanInboxes ? { removeOrphanInboxes: true } : {}), ...(b.archiveEmptyRooms ? { archiveEmptyRooms: true } : {}), dryRun: dry };
+    const r = await runs.exec({ kind: "mcp", label: `prune bus data${dry ? " (dry-run)" : ""}`, sideEffects: !dry, args }, (log) => bus.call("prune", args, log));
+    return c.json(r, r.status === "ok" ? 200 : 403);
+});
+app.post("/actions/unregister-dead", async (c) => {
+    const b = (await c.req.json().catch(() => ({})));
+    const dead = agents(cfg.coordDir).filter((a) => a.liveness === "dead" && !["groundwork-console", "david"].includes(a.agentId)).map((a) => a.agentId);
+    const ids = (b.agentIds?.length ? b.agentIds.filter((id) => dead.includes(id)) : dead);
+    if (b.confirm !== "UNREGISTER")
+        return c.json({ error: "confirm must be UNREGISTER", wouldUnregister: ids }, 400);
+    const r = await runs.exec({ kind: "mcp", label: `unregister ${ids.length} dead agent(s)`, sideEffects: true, args: { agentIds: ids } }, async (log) => { const done = []; for (const id of ids) {
+        await bus.call("force_unregister", { targetAgentId: id }, log);
+        done.push(id);
+    } return { unregistered: done }; });
+    return c.json(r, r.status === "ok" ? 200 : 403);
+});
+app.post("/actions/unregister", async (c) => {
+    const b = (await c.req.json());
+    if (!b.agentId)
+        return c.json({ error: "agentId required" }, 400);
+    if (b.confirm !== b.agentId)
+        return c.json({ error: "confirm must equal agentId" }, 400);
+    if (b.agentId === "groundwork-console" || b.agentId === "david")
+        return c.json({ error: "refusing to unregister the console's own identities" }, 400);
+    const r = await runs.exec({ kind: "mcp", label: `unregister ${b.agentId}`, sideEffects: true, args: { agentId: b.agentId } }, (log) => bus.call("force_unregister", { targetAgentId: b.agentId }, log));
+    return c.json(r, r.status === "ok" ? 200 : 403);
+});
+/* ---- Roadmap actions: message the project's aide (plan) or coordinator (kick off) as david ---- */
+const roleAgent = (projectName, room, roleRe) => agents(cfg.coordDir).find((a) => roleRe.test(a.role ?? "") && (a.project === room || a.project === projectName) && a.liveness !== "dead")?.agentId ?? null;
+app.get("/projects/:name/agents", (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    return c.json({ aide: roleAgent(p.name, p.room, /aide|liaison|curator/i), coordinator: roleAgent(p.name, p.room, /coordinator/i), qa: roleAgent(p.name, p.room, /\bqa\b|quality/i) });
+});
+app.post("/actions/phase/:name/:phase/:verb", async (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    const phase = c.req.param("phase");
+    const verb = c.req.param("verb");
+    const b = (await c.req.json().catch(() => ({})));
+    const target = verb === "plan" ? roleAgent(p.name, p.room, /aide|liaison|curator/i) : roleAgent(p.name, p.room, /coordinator/i);
+    if (!target)
+        return c.json({ error: `no live ${verb === "plan" ? "aide" : "coordinator"} for ${p.name}` }, 409);
+    const n = phase.match(/(\d+(?:\.\d+)?)/)?.[1] ?? phase;
+    const text = verb === "plan"
+        ? `AGENT_ACTION: plan ${phase} in ${p.name} — run /plan-phase ${n} (PRODUCTION_ROADMAP → docs/phases/${phase}/PHASE${n}_TASKS.md), then append one queue.v1 item.${b.note ? " Note: " + b.note : ""}`
+        : verb === "kickoff" ? `GO: start ${phase} in ${p.name} — route the first tasks to lane owners; board row per stream.${b.note ? " Note: " + b.note : ""}`
+            : verb === "audit" ? `AGENT_ACTION: ${phase} in ${p.name} — run /coord-audit and report before the next phase.${b.note ? " Note: " + b.note : ""}`
+                : null;
+    if (!text)
+        return c.json({ error: "verb must be plan | kickoff | audit" }, 400);
+    const r = await runs.exec({ kind: "bus", label: `${verb} ${phase} → ${target}`, project: p.name, sideEffects: true, args: { to: target, text: text.slice(0, 200) } }, (log) => busDavid.call("send_message", { to: target, text }, log));
+    return c.json(r, r.status === "ok" ? 200 : 403);
+});
+/* ---- Doctor → Fix: route a doctor finding to the role that owns it (live agent required); sent as david ---- */
+const DOCTOR_OWNER = {
+    "orphan-wikilinks": { role: "aide", re: /aide|liaison|curator/i, how: "fix the orphan wikilinks (create the target doc or correct the link); docs are your lane" },
+    "spec-coverage": { role: "aide", re: /aide|liaison|curator/i, how: "run /plan-phase for the phases without PHASE*_TASKS.md, then append one queue.v1 item each" },
+    "phase-progress": { role: "aide", re: /aide|liaison|curator/i, how: "reconcile phase task checkboxes with reality (check-task) or plan the phase" },
+    "stack-map-freshness": { role: "coordinator", re: /coordinator/i, how: "route /check-versions to a worker and refresh docs/STACK_MAP.md" },
+    "workstreams": { role: "coordinator", re: /coordinator/i, how: "bring docs/WORKSTREAMS.md to workstreams.v1 (6-col Active Streams); the seam refuses the current rows" },
+    "facts-freshness": { role: "coordinator", re: /coordinator/i, how: "re-verify or delete the stale facts (set-fact); one writer per fact" },
+    "adr-tripwire": { role: "coordinator", re: /coordinator/i, how: "an Accepted ADR is contradicted — run /coord-audit and either amend the ADR or revert the drift" },
+};
+app.get("/projects/:name/doctor/fixers", async (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    const live = (await agentsAsync(cfg.coordDir)).filter((a) => a.liveness !== "dead" && (a.project === p.room || a.project === p.name));
+    const out = {};
+    for (const [check, o] of Object.entries(DOCTOR_OWNER)) {
+        const a = live.find((x) => o.re.test(x.role ?? ""));
+        out[check] = { role: o.role, agent: a?.agentId ?? null, how: o.how };
+    }
+    return c.json({ fixers: out, versionMarker: { self: true, how: "console runs groundwork update (Skills)" } });
+});
+app.post("/actions/doctor-fix/:name", async (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    const b = (await c.req.json());
+    const o = DOCTOR_OWNER[b.check];
+    if (!o)
+        return c.json({ error: "no fixer role for this check" }, 400);
+    const live = (await agentsAsync(cfg.coordDir)).filter((a) => a.liveness !== "dead" && (a.project === p.room || a.project === p.name));
+    const target = live.find((x) => o.re.test(x.role ?? ""))?.agentId;
+    if (!target)
+        return c.json({ error: `no live ${o.role} for ${p.name}` }, 409);
+    const items = (b.items ?? []).slice(0, 8).map((i) => `  - ${i}`).join("\n");
+    const text = `AGENT_ACTION: groundwork doctor · ${b.check} in ${p.name} — ${o.how}.${items ? "\n" + items : ""}${(b.items?.length ?? 0) > 8 ? `\n  … +${b.items.length - 8} more (run groundwork doctor --json)` : ""}${b.note ? "\nNote: " + b.note : ""}`;
+    const r = await runs.exec({ kind: "bus", label: `fix ${b.check} → ${target}`, project: p.name, sideEffects: true, args: { check: b.check, to: target, items: b.items?.length ?? 0 } }, (log) => busDavid.call("send_message", { to: target, text }, log));
+    return c.json(r, r.status === "ok" ? 200 : 403);
+});
+/* ---- Notifications ---- */
+app.get("/notifications", (c) => c.json(notifier.recent(Number(c.req.query("limit") ?? 100))));
+app.get("/notifications/stream", (c) => {
+    const stream = new ReadableStream({
+        start(controller) {
+            const enc = new TextEncoder();
+            const send = (e) => { try {
+                controller.enqueue(enc.encode(`data: ${JSON.stringify(e)}\n\n`));
+            }
+            catch { /* closed */ } };
+            send({ type: "hello" });
+            const off = notifier.subscribe(send);
+            const ka = setInterval(() => { try {
+                controller.enqueue(enc.encode(": keepalive\n\n"));
+            }
+            catch { /* closed */ } }, 25_000);
+            c.req.raw.signal.addEventListener("abort", () => { off(); clearInterval(ka); try {
+                controller.close();
+            }
+            catch { /* closed */ } });
+        },
+    });
+    return new Response(stream, { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" } });
+});
+/* ---- Runs: every side-effecting or long-running action ---- */
+app.get("/runs", (c) => c.json({ running: runs.running().length, runs: runs.list(Number(c.req.query("limit") ?? 50)) }));
+app.get("/runs/:id", (c) => { const r = runs.get(c.req.param("id")); return r ? c.json(r) : c.json({ error: "not found" }, 404); });
+app.get("/runs/stream", (c) => {
+    const stream = new ReadableStream({
+        start(controller) {
+            const enc = new TextEncoder();
+            const send = (e) => { try {
+                controller.enqueue(enc.encode(`data: ${JSON.stringify(e)}\n\n`));
+            }
+            catch { /* closed */ } };
+            send({ type: "hello", running: runs.running().length });
+            const off = runs.subscribe(send);
+            const ka = setInterval(() => { try {
+                controller.enqueue(enc.encode(": keepalive\n\n"));
+            }
+            catch { /* closed */ } }, 25_000);
+            c.req.raw.signal.addEventListener("abort", () => { off(); clearInterval(ka); try {
+                controller.close();
+            }
+            catch { /* closed */ } });
+        },
+    });
+    return new Response(stream, { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" } });
+});
+/* Actions (allow-listed; each becomes a Run). Read-only build: only read-only MCP tools + read-only CLIs. */
+app.post("/actions/bus-doctor", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    if (body.fix)
+        return c.json({ error: "fix=true is a write; disabled in read-only build" }, 403);
+    const r = await runs.exec({ kind: "mcp", label: "bus doctor", sideEffects: false, args: { tool: "doctor", agentId: AGENT_ID } }, (log) => bus.call("doctor", {}, log));
+    return c.json(r, r.status === "ok" ? 200 : 500);
+});
+app.post("/actions/project-doctor/:name", async (c) => {
+    const p = project(c.req.param("name"));
+    if (!p)
+        return c.json({ error: "unknown project" }, 404);
+    const r = await runs.exec({ kind: "cli", label: `groundwork doctor · ${p.name}`, project: p.name, sideEffects: false }, async (log) => { log(`node groundwork/src/cli.mjs doctor ${p.path} --json`); const out = await doctor(cfg.kitPath, p.path); log(`${out.checks.length} checks · ok=${out.ok}`); return out; });
+    return c.json(r);
+});
+app.post("/actions/mcp/:tool", async (c) => {
+    const tool = c.req.param("tool");
+    const args = (await c.req.json().catch(() => ({})));
+    const r = await runs.exec({ kind: "mcp", label: `${tool}`, sideEffects: false, args: { tool, ...args } }, (log) => bus.call(tool, args, log));
+    return c.json(r, r.status === "ok" ? 200 : 403);
+});
+app.get("/bus/agents", async (c) => c.json(await agentsAsync(cfg.coordDir)));
+/* Monitor: tail of every pane-attached agent (optionally scoped to a project) in one call. */
+app.get("/bus/panes", async (c) => {
+    const proj = c.req.query("project");
+    const lines = Number(c.req.query("lines") ?? 40);
+    const p = proj ? project(proj) : undefined;
+    const all = await agentsAsync(cfg.coordDir);
+    const scoped = all.filter((a) => a.pane && a.liveness !== "dead" && (!p || a.project === p.name || (p.room && a.project === p.room)));
+    const colors = c.req.query("colors") === "1";
+    const out = await Promise.all(scoped.map(async (a) => ({ agentId: a.agentId, role: a.role ?? null, project: a.project ?? null, pane: a.pane, command: a.paneCommand, active: a.active, paneActivity: a.paneActivity, liveness: a.liveness, capture: await capturePane(a.pane, lines, colors) })));
+    return c.json(out);
+});
+/* Pane viewer: read-only capture of an agent's tmux pane (never sends keys). */
+app.get("/bus/agents/:id/pane", async (c) => {
+    const a = (await agentsAsync(cfg.coordDir)).find((x) => x.agentId === c.req.param("id"));
+    if (!a)
+        return c.json({ error: "unknown agent" }, 404);
+    if (!a.pane)
+        return c.json({ error: "agent has no tmux pane (transport not tmux-push)" }, 409);
+    const cap = await capturePane(a.pane, Number(c.req.query("lines") ?? 200), c.req.query("colors") === "1");
+    if (!cap)
+        return c.json({ error: "pane not found (session gone?)" }, 410);
+    return c.json({ agentId: a.agentId, pane: a.pane, command: a.paneCommand, active: a.active, paneActivity: a.paneActivity, ...cap });
+});
+app.get("/bus/rooms", (c) => c.json(rooms(cfg.coordDir)));
+app.get("/bus/rooms/:room/messages", (c) => {
+    const limit = Number(c.req.query("limit") ?? 100);
+    const before = c.req.query("before") ? Number(c.req.query("before")) : undefined;
+    const room = c.req.param("room");
+    const msgs = roomMessages(cfg.coordDir, room, limit, before).map((m) => ({ ...m, prefix: typeof m.text === "string" ? prefixOf(m.text) : null, answered: isAnswered(m.id) }));
+    return c.json({ room, total: roomMessageCount(cfg.coordDir, room), messages: msgs, oldestTs: msgs[0]?.ts ?? null });
+});
+app.get("/bus/status", (c) => c.json(statusStream(cfg.coordDir, Number(c.req.query("limit") ?? 50))));
+app.get("/bus/scopes", (c) => c.json(scopes(cfg.coordDir)));
+events.start(15_000);
+notifier.start(15_000);
+/* Packaged mode: the built web UI lives in ../public (copied at prepack) and is served by the same process at / — one port, no Vite. Dev keeps using Vite on :5173 with the /api proxy. */
+root.route("/", app);
+if (existsSync(PUBLIC_DIR)) {
+    root.use("/*", serveStatic({ root: PUBLIC_DIR }));
+    root.get("*", (c) => c.html(readFileSync(path.join(PUBLIC_DIR, "index.html"), "utf8"))); // hash router → index for everything else
+}
+// Bind loopback only: the console can write to the bus and to docs/ and has no auth yet. Set GROUNDWORK_CONSOLE_HOST=0.0.0.0 to expose (put auth in front first).
+const hostname = process.env.GROUNDWORK_CONSOLE_HOST ?? "127.0.0.1";
+serve({ fetch: root.fetch, port, hostname }, () => { const rq = requiresReport(cfg.kitPath); console.log(`kit resolve: ${rq.paths.kitCheckout ? "checkout " + rq.paths.kitCheckout : "installed packages (no kit checkout)"} · seam ${rq.seam.installed ?? "?"} mcp ${rq.mcp.installed ?? "?"} groundwork ${rq.groundwork.installed ?? "?"} playbook ${rq.playbook.installed ?? "?"} · requires ${rq.ok ? "OK" : "MISMATCH " + JSON.stringify(REQUIRES)}`); console.log(`groundwork-console api → http://${hostname}:${port}/api  store=${cfg.coordDir}  auth=${authEnabled ? `token (${tokenFile})` : "OFF"}`); });