@davidbalzan/groundwork-console 0.1.6 → 0.1.7

package/bin/groundwork-console.mjs

@@ -58,6 +58,8 @@ if (sub === "doctor") {
   console.log(`groundwork-console ${pkg.version} · config ${CONFIG_FILE} · store ${cfg.coordDir}`);
   for (const k of ["seam", "mcp", "groundwork", "playbook"]) console.log(`  ${r[k].ok === false ? "✗" : r[k].ok ? "✓" : "?"} ${k.padEnd(10)} ${String(r[k].installed ?? "missing").padEnd(8)} needs ${r[k].required}${r.paths[k] ? `  ← ${r.paths[k]}` : ""}`);
   console.log(`  kit checkout: ${r.paths.kitCheckout ?? "none (using installed packages)"}`);
+  // Capability probe: connect once to the MCP (as groundwork-console, read-only) and check send_message.inReplyTo — the bus feature the console's answered-decisions logic relies on.
+  try { const { BusClient } = await import("../dist/mcp.js"); const cl = new BusClient(cfg.kitPath, cfg.coordDir, "groundwork-console"); await cl.connect(); const ok = cl.supports("send_message", "inReplyTo"); await cl.close(); console.log(`  ${ok ? "✓" : "⚠"} mcp capability inReplyTo ${ok ? "present" : "missing — decision replies will not be linked/cleared; upgrade agent-coord-mcp"}`); } catch (e) { console.log(`  ? mcp capability probe failed: ${e.message}`); }
   if (!r.ok) { console.log("\nfix: npm i -g agent-coord-mcp @davidbalzan/groundwork agent-coordination"); process.exit(1); }
   process.exit(0);
 }

package/dist/answered.js

@@ -1,40 +1,11 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
-/* Console-owned "answered" set for DAVID_DECISION packets (room posts + DMs), keyed by message id.
-   Until the bus has inReplyTo (queued P3), this is how the UI stops showing a packet as open once David replied from the console.
-   Persisted in ~/.groundwork-console/answered.json — never touches ~/agent-coord. */
-const FILE = path.join(homedir(), ".groundwork-console", "answered.json");
-let cache = null;
-export function answered() {
-    if (cache)
-        return cache;
-    try {
-        cache = existsSync(FILE) ? JSON.parse(readFileSync(FILE, "utf8")) : {};
-    }
-    catch {
-        cache = {};
-    }
-    return cache;
-}
-export function markAnswered(ids, meta) {
-    const a = answered();
-    let n = 0;
-    for (const id of ids)
-        if (id && !a[id]) {
-            a[id] = { ts: Date.now(), ...meta };
-            n++;
-        }
-    if (n) {
-        mkdirSync(path.dirname(FILE), { recursive: true });
-        writeFileSync(FILE, JSON.stringify(a, null, 2));
-    }
-    return n;
-}
-/* Bus-native answered set (kit ≥ 18ffbf4): any message FROM david carrying inReplyTo:<id> answers <id>. Scanned from ~/agent-coord inbox/*.jsonl + rooms/*.jsonl, cached 10 s. Unioned with the console-owned set above. */
+/* Answered DAVID_DECISION packets — bus-native only (kit ≥ 18ffbf4): a message FROM david carrying inReplyTo:<id> answers <id>.
+   Derived by scanning ~/agent-coord inbox/*.jsonl + rooms/*.jsonl (cached 10 s). The console-owned answered.json store was retired 2026-08-19. */
 let busCache = null;
 let coordRoot = null;
-export function setCoordDir(dir) { coordRoot = dir; }
+export function setCoordDir(dir) { coordRoot = dir; busCache = null; }
 function busAnswered() {
     if (!coordRoot)
         return new Set();
@@ -64,4 +35,15 @@ function busAnswered() {
     busCache = { at: Date.now(), ids };
     return ids;
 }
-export const isAnswered = (id) => typeof id === "string" && (!!answered()[id] || busAnswered().has(id));
+export const isAnswered = (id) => typeof id === "string" && busAnswered().has(id);
+/** Forget the cache (after the console itself sends a reply) so the next read reflects it immediately. */
+export const invalidateAnswered = () => { busCache = null; };
+/** One-time cleanup of the retired console-owned store. Returns true if a file was removed. */
+const LEGACY_FILE = path.join(homedir(), ".groundwork-console", "answered.json");
+export function removeLegacyAnsweredFile() { try {
+    if (existsSync(LEGACY_FILE)) {
+        unlinkSync(LEGACY_FILE);
+        return true;
+    }
+}
+catch { /* leave it */ } return false; }

package/dist/kitresolve.js

@@ -2,6 +2,7 @@ import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+// TODO(kit publish): bump mcp to the version that ships send_message.inReplyTo (kit main 18ffbf4 is still tagged 0.23.0) — until then the capability is detected at runtime (BusClient.supports) and surfaced in /health.requires.mcp.capabilities.
 export const REQUIRES = { seam: "^0.1.0", mcp: "^0.23.0", groundwork: "^0.3.0", playbook: "^0.5.0" };
 const which = (bin) => { try {
     return execFileSync("which", [bin], { encoding: "utf8" }).trim() || null;
@@ -71,10 +72,10 @@ export function satisfies(v, range) {
         return false;
     return a > x || b > y || (b === y && c >= z);
 }
-export function requiresReport(kitPath) {
+export function requiresReport(kitPath, caps) {
     const inst = installedVersions(kitPath);
     const check = (k) => ({ required: REQUIRES[k], installed: inst[k], ok: satisfies(inst[k], REQUIRES[k]) });
-    const r = { seam: check("seam"), mcp: check("mcp"), groundwork: check("groundwork"), playbook: check("playbook") };
+    const r = { seam: check("seam"), mcp: { ...check("mcp"), capabilities: caps ?? { inReplyTo: null }, warnings: caps?.inReplyTo === false ? ["inReplyTo missing — decision replies will not be linked/cleared; upgrade agent-coord-mcp"] : [] }, groundwork: check("groundwork"), playbook: check("playbook") };
     return { ...r, paths: inst.paths, ok: Object.values(r).every((x) => x.ok !== false) };
 }
 /** Package root dir for a kit package: the checkout's packages/<dir> if present, else the installed npm package (found from its bin). Null when neither exists. */

package/dist/mcp.js

@@ -14,7 +14,7 @@ const IDENTITIES = {
 };
 export const AGENT_ID = "groundwork-console";
 export const READ_ONLY_TOOLS = new Set(["doctor", "list_agents", "list_rooms", "list_scopes", "status", "ping", "read_messages", "retrieve_room_history", "retrieve_message", "list_work"]);
-export const WRITE_TOOLS_GATED = new Set(["send_message", "post_status", "prune", "force_unregister", "unregister", "join_room", "leave_room", "delete_room", "set_room_topic", "set_room_motd", "import_work", "export_work"]);
+export const WRITE_TOOLS_GATED = new Set(["send_message", "send_command", "post_status", "prune", "force_unregister", "unregister", "join_room", "leave_room", "delete_room", "set_room_topic", "set_room_motd", "import_work", "export_work"]);
 const SWITCH_FILE = path.join(homedir(), ".groundwork-console", "switches.json");
 function loadSwitches() {
     let saved = {};
@@ -93,6 +93,7 @@ export class BusClient {
     toolArgs = new Map();
     /** True when the connected server's tool schema lists this argument (false when unknown or not connected yet). */
     supports(tool, arg) { return this.toolArgs.get(tool)?.has(arg) ?? false; }
+    get connected() { return !!this.client; }
     async call(name, args, log) {
         const isWrite = WRITE_TOOLS_GATED.has(name);
         if (!READ_ONLY_TOOLS.has(name) && !isWrite)

package/dist/provision.js

@@ -25,6 +25,30 @@ async function fleetWindow(project, startDir, log) {
     log(`created window ${win} in session ${session} (first pane ${pane} reused for the first agent — no spare shell)`);
     return { target: `${session}:${win}`, freshPane: pane };
 }
+const PROMPT_GLYPH = { claude: /^\s*[❯>]\s?/, grok: /^\s*[❯>›]\s?/, codex: /^\s*[❯>›]\s?/, opencode: /^\s*[❯>›]\s?/ };
+/** Was `line` submitted? Decided from the INPUT BOX only — the last prompt-glyph line framed by a rule above it (Claude Code always frames the box; other harnesses: within the last 4 lines) —
+    never from transcript echoes ("❯ <submitted text>" followed by output). Stuck ⇔ the input still holds the typed text, or a slash popup is open under it. Pure; unit-tested in scripts/test-inject.mjs. */
+export function inputSubmitted(captureText, harness, line) {
+    const lines = captureText.split("\n").map((l) => l.replace(/\u00a0/g, " ").replace(/\s+$/, ""));
+    const isRule = (l) => !!l && /^\s*[─━-]{10,}\s*$/.test(l);
+    const needle = line.slice(0, Math.min(line.length, 40));
+    let idx = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (!PROMPT_GLYPH[harness].test(lines[i]))
+            continue;
+        if (isRule(lines[i - 1]) || (harness !== "claude" && i >= lines.length - 4)) {
+            idx = i;
+            break;
+        }
+        else
+            break;
+    } // Claude Code always frames its box with a rule; an unframed ❯ line is a transcript echo
+    if (idx < 0)
+        return true; // no input box visible → nothing is sitting in the input
+    const inputBlock = lines.slice(idx, Math.min(lines.length, idx + 3)).filter((l) => !isRule(l)).join(" "); // the box can wrap
+    const popup = /\/[a-z][\w-]*\s{2,}\S/.test(lines.slice(idx + 1, idx + 7).join(" ")); // slash popup rows: "/coord-worker   Act as…"
+    return !inputBlock.includes(needle) && !popup;
+}
 export async function spawnAgent(req, isRegistered, log, isAttached = () => true, roleOf = () => null) {
     if (!/^[a-z0-9][a-z0-9-_]*$/i.test(req.agentId))
         throw new Error("agentId: letters, digits, - _");
@@ -44,14 +68,78 @@ export async function spawnAgent(req, isRegistered, log, isAttached = () => true
     await tmux("send-keys", "-t", paneId, "C-m");
     log(`launched: ${cmd}`);
     const wait = Math.min(Math.max(req.waitSeconds ?? 8, 3), 60);
-    log(`waiting ${wait}s for the harness to start…`);
-    await sleep(wait * 1000);
-    const inject = async (line) => { await tmux("send-keys", "-t", paneId, "-l", line); await sleep(400); await tmux("send-keys", "-t", paneId, "C-m"); log(`injected: ${line}`); await sleep(600); };
+    const capture = async () => { try {
+        return await tmux("capture-pane", "-p", "-t", paneId, "-S", "-40");
+    }
+    catch {
+        return "";
+    } };
+    const paneAlive = async () => { try {
+        const out = await tmux("list-panes", "-t", target, "-F", "#{pane_id}\t#{pane_dead}");
+        return out.split("\n").some((l) => l.startsWith(paneId + "\t0"));
+    }
+    catch {
+        return false;
+    } };
+    // (1) Ready-prompt wait: poll the pane until the harness input prompt is visible (bounded by waitSeconds). Claude Code: "? for shortcuts" / the "›" input box; others: a prompt glyph on the last lines.
+    const READY = { claude: /\? for shortcuts|bypass permissions|esc to interrupt|Welcome to Claude Code|Claude Code v\d/i, grok: /grok|›/i, codex: /codex|›/i, opencode: /opencode|›/i }; // never the bare shell prompt: an early inject would type into zsh
+    const t0 = Date.now();
+    let ready = false;
+    while (Date.now() - t0 < wait * 1000) {
+        if (!(await paneAlive()))
+            break;
+        if (READY[req.harness].test(await capture())) {
+            ready = true;
+            break;
+        }
+        await sleep(700);
+    }
+    log(ready ? `harness prompt visible after ${((Date.now() - t0) / 1000).toFixed(1)}s` : `⚠ no harness prompt seen within ${wait}s — injecting anyway`);
+    if (!(await paneAlive()))
+        throw new Error(`pane ${paneId} died before the seed (harness failed to start?) — check the window ${target}`);
+    // (2) Verified injection: type the line, settle, C-m, then confirm the typed text left the input; on a stuck slash popup (Claude Code eats the first C-m while the command menu is open) → Escape + C-m, up to 3 tries.
+    // "Submitted" is decided from the INPUT LINE only (the line starting with the harness prompt glyph), never from transcript echoes: Claude Code echoes the
+    // submitted command in the transcript, and an Escape sent on a false "stuck" would interrupt the running turn (skill boot / registration).
+    const submitted = async (line) => inputSubmitted(await capture(), req.harness, line);
+    const inject = async (line) => {
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            if (!(await paneAlive()))
+                throw new Error(`✗ inject failed: pane died — "${line}"`);
+            if (attempt === 1) {
+                await tmux("send-keys", "-t", paneId, "-l", line);
+                await sleep(450);
+            }
+            else {
+                await tmux("send-keys", "-t", paneId, "Escape");
+                await sleep(250);
+            }
+            await tmux("send-keys", "-t", paneId, "C-m");
+            const d = Date.now() + 5_000;
+            let ok = false;
+            while (Date.now() < d) {
+                await sleep(400);
+                if (await submitted(line)) {
+                    ok = true;
+                    break;
+                }
+            }
+            if (ok) {
+                log(`injected${attempt > 1 ? ` (attempt ${attempt})` : ""}: ${line}`);
+                await sleep(500);
+                return;
+            }
+            log(`… "${line.slice(0, 50)}" still in the input after C-m (attempt ${attempt}) — ${attempt < 3 ? "Escape + retry" : "giving up"}`);
+        }
+        throw new Error(`✗ inject failed after 3 tries: "${line}" — the harness did not accept the line; seed aborted (registration wait skipped)`);
+    };
     if (req.model && CLAUDE_HARNESS_ONLY.has(req.harness))
         await inject(`/model ${req.model}`);
     if (CLAUDE_HARNESS_ONLY.has(req.harness))
         await inject(`/color ${ROLE_COLOR[req.role]}`);
-    const skill = `${ROLE_SKILL[req.role]} --id=${req.agentId}${req.lane ? ` --lane=${req.lane}` : ""}${req.room ? ` --room=${req.room}` : ""}`;
+    // Skill line: the common coord-* signature (kit b84e14c): --id --role --project --room [--rooms] --repo [--lane]. Cards accept it once the machine's playbook is updated from the kit; older cards ignore unknown flags.
+    const roleId = `coord-${req.role === "coordinator" ? "coordinator" : req.role}`;
+    const skill = `${ROLE_SKILL[req.role]} --id=${req.agentId} --role=${roleId} --project=${req.project} --room=${req.room ?? req.project} --repo=${req.repoPath}${req.lane ? ` --lane=${req.lane}` : ""}`;
+    log(`seed (common coord-* signature, kit b84e14c): ${skill}`);
     await inject(CLAUDE_HARNESS_ONLY.has(req.harness) ? skill : `Act per the ${ROLE_SKILL[req.role].slice(1)} playbook card: ${skill}${req.note ? ". " + req.note : ""}`);
     if (req.note && CLAUDE_HARNESS_ONLY.has(req.harness))
         await inject(req.note);
@@ -63,6 +151,8 @@ export async function spawnAgent(req, isRegistered, log, isAttached = () => true
             registered = true;
             break;
         }
+        if (!(await paneAlive()))
+            throw new Error(`✗ pane ${paneId} died while waiting for ${req.agentId} to register — seed aborted`);
         await sleep(2_000);
     }
     log(registered ? `✓ ${req.agentId} registered on the bus` : `⚠ ${req.agentId} not registered after 90s — check the pane`);

package/dist/server.js

@@ -16,7 +16,7 @@ import { agents, agentsAsync, rooms, roomMessages, roomMessageCount, statusStrea
 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 { detectedHarnesses, groundworkSkills, playbookCards } from "./skills.js";
 import { extensionsOf } from "./extensions.js";
 import { parseWorkDoc, workstreamsExtensionsOf } from "@davidbalzan/groundwork-seam";
 import { EventEngine } from "./events.js";
@@ -27,10 +27,10 @@ import { BusClient, AGENT_ID, busWrites, seamWrites, saveSwitches, SWITCHES_FILE
 import { addQueueItem, reverifyFact, scopeAllows } from "./seamwrite.js";
 import { fileURLToPath } from "node:url";
 import { saveUpload, uploadPath, purgeUploads, UPLOAD_DIR, UPLOAD_TTL_HOURS } from "./uploads.js";
-import { answered, markAnswered, isAnswered, setCoordDir } from "./answered.js";
+import { isAnswered, setCoordDir, invalidateAnswered, removeLegacyAnsweredFile } from "./answered.js";
 import { requireAuth, login, logout, isAuthed, authEnabled, tokenFile } from "./auth.js";
 import { knowledgeIndex, knowledgeDoc, knowledgePath } from "./knowledge.js";
-import { requiresReport, groundworkCli, playbookCli, packageRoot, REQUIRES } from "./kitresolve.js";
+import { requiresReport, groundworkCli, playbookCli, packageRoot, hasKitCheckout, REQUIRES } from "./kitresolve.js";
 let cfg = loadConfig();
 const port = Number(process.env.PORT ?? 8790);
 const HERE = path.dirname(fileURLToPath(import.meta.url));
@@ -38,11 +38,15 @@ const RULES = process.env.GROUNDWORK_CONSOLE_RULES ?? [path.join(process.env.HOM
 const PKG = JSON.parse(readFileSync(path.resolve(HERE, "../package.json"), "utf8"));
 const runs = new Runs();
 setCoordDir(cfg.coordDir);
+if (removeLegacyAnsweredFile())
+    void runs.exec({ kind: "cli", label: "retired ~/.groundwork-console/answered.json (answered = bus inReplyTo now)", sideEffects: true }, async (log) => { log("removed the console-owned answered store; decision packets are answered by replies carrying inReplyTo"); return { removed: true }; });
 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);
+/** Capabilities of the connected MCP (null until a client has connected and listed tools). */
+const mcpCaps = () => ({ inReplyTo: bus.connected ? bus.supports("send_message", "inReplyTo") : busDavid.connected ? busDavid.supports("send_message", "inReplyTo") : null });
 const PUBLIC_DIR = path.resolve(HERE, "../public");
 const root = new Hono();
 const app = new Hono().basePath("/api");
@@ -57,7 +61,7 @@ app.post("/auth/logout", (c) => { logout(c); return c.json({ ok: true }); });
 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, hostname: osHostname().replace(/\.local$/, "") }));
+app.get("/health", (c) => c.json({ ok: true, readOnly: !busWrites.enabled, busWrites: busWrites.enabled, version: PKG.version, requires: requiresReport(cfg.kitPath, mcpCaps()), config: CONFIG_FILE, hostname: osHostname().replace(/\.local$/, "") }));
 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) => {
@@ -109,6 +113,23 @@ app.post("/actions/send", async (c) => {
         return c.json({ error: "text required" }, 400);
     if (!b.room && !b.to)
         return c.json({ error: "room or to required" }, 400);
+    // Raw control commands: exactly `/clear` or `/compact` (no args) to ONE agent go through MCP send_command — the only path that types a slash command
+    // into a live CLI (allowlist locked to these two in the MCP; widening it — /reload-skills etc. — is a kit decision, not done here). Everything else is a text DM.
+    const RAW_COMMANDS = new Set(["/clear", "/compact"]);
+    const cmd = b.text.trim();
+    if (RAW_COMMANDS.has(cmd)) {
+        if (!b.to)
+            return c.json({ error: `${cmd} is unicast — pick an agent (rooms get text only)` }, 400);
+        const r = await runs.exec({ kind: "bus", label: `command ${cmd} → ${b.to}`, sideEffects: true, args: { as: who, to: b.to, command: cmd } }, async (log) => {
+            const out = (await clientFor(who).call("send_command", { to: b.to, command: cmd, waitForDelivery: true, deliveryTimeoutMs: 15_000 }, log));
+            log(`delivery: ${out.delivery ?? "?"}${out.reason ? ` · ${out.reason}` : ""}${out.note ? ` · ${out.note}` : ""}`);
+            if (out.error)
+                throw new Error(out.error);
+            return out;
+        });
+        const out = (r.result ?? {});
+        return c.json({ ...r, raw: true, delivery: out.delivery ?? null, warning: out.delivery === "pending" ? `pusher has not confirmed typing ${cmd} yet${out.reason ? ` — ${out.reason}` : ""}` : undefined }, r.status === "ok" ? 200 : 403);
+    }
     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);
@@ -116,29 +137,30 @@ app.post("/actions/send", async (c) => {
     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 cl = clientFor(who);
         await cl.connect(log);
-        const parent = b.inReplyTo ?? b.answers?.[0];
-        const withReply = parent && cl.supports("send_message", "inReplyTo") ? { inReplyTo: parent } : {};
-        if (parent && !("inReplyTo" in withReply))
-            log("bus predates inReplyTo — using the console-side answered set only");
-        const out = await cl.call("send_message", { ...(b.to ? { to: b.to } : { room: b.room.replace(/^#/, "") }), text: b.text, ...(b.kind ? { kind: b.kind } : {}), ...withReply }, 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 */ }
+        // Reply linkage = bus inReplyTo only (console-owned answered.json retired 2026-08-19). Parent: explicit from the UI (answers[0] / inReplyTo);
+        // for a DM as David with no explicit parent, the latest still-open DAVID_DECISION DM from that agent — so "reply to the agent" clears its packet.
+        let parent = b.inReplyTo ?? b.answers?.[0];
+        if (!parent && who === "david" && 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 && !isAnswered(m.id))
+                            parent = m.id;
                     }
-            }
-            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)`);
+                    catch { /* skip */ }
+                }
+            if (parent)
+                log(`inReplyTo ← latest open DAVID_DECISION from ${b.to} (${parent})`);
+        }
+        const supportsReply = cl.supports("send_message", "inReplyTo");
+        if (parent && !supportsReply)
+            log("⚠ connected agent-coord-mcp has no inReplyTo — reply will NOT be linked to the packet; upgrade agent-coord-mcp (gwc doctor)");
+        const out = await cl.call("send_message", { ...(b.to ? { to: b.to } : { room: b.room.replace(/^#/, "") }), text: b.text, ...(b.kind ? { kind: b.kind } : {}), ...(parent && supportsReply ? { inReplyTo: parent } : {}) }, log);
+        if (parent && supportsReply) {
+            invalidateAnswered();
+            log(`linked: inReplyTo ${parent}`);
         }
         return out;
     });
@@ -291,11 +313,11 @@ app.get("/projects/:name/skills", async (c) => {
         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);
+    const cards = await 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,
+        groundwork: { versionMarker: gl.version || sync.versionMarker, kitVersion: sync.kitVersion, source: sync.source ?? null, 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,
+        playbook: { kitVersion: pl.version || cards.kitVersion, source: cards.source ?? null, rewrite: cards.rewrite ?? null, 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 } }; }) },
     });
 });
@@ -485,8 +507,6 @@ app.get("/bus/inbox", async (c) => {
 });
 /* 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);
@@ -572,14 +592,18 @@ app.post("/actions/playbook-update", async (c) => {
     const cli = playbookCli(cfg.kitPath);
     if (!cli)
         return c.json({ error: "agent-coordination CLI not found — npm i -g agent-coordination (or set kitPath to a kit checkout)" }, 500);
-    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) => {
+    // --harness= every home detected on this machine (~/.claude, ~/.grok, …) so grok & co. mirrors are refreshed too — not only the Claude home (the no-flag default is all five, but be explicit in the Run).
+    const harnesses = detectedHarnesses();
+    if (!harnesses.length)
+        return c.json({ error: "no harness home found (~/.claude, ~/.grok, ~/.cursor, ~/.vscode, ~/.config/opencode)" }, 400);
+    const argv = [cli, "update", `--harness=${harnesses.join(",")}`, ...(dry ? ["--dry-run"] : [])];
+    const r = await runs.exec({ kind: "shell", label: `agent-coordination update${dry ? " (dry-run · preview)" : ""} · ${harnesses.join(",")}`, sideEffects: !dry, args: { argv: argv.slice(1), harnesses } }, 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 { lines: lines.length, dryRun: dry, harnesses };
     });
     return c.json(r, r.status === "ok" ? 200 : 500);
 });
@@ -836,12 +860,49 @@ app.get("/runs/stream", (c) => {
     });
     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. */
+const doctorCounts = (d) => ({ warn: d?.summary?.warn ?? (d?.findings ?? []).filter((f) => f.level === "warn").length, error: d?.summary?.error ?? (d?.findings ?? []).filter((f) => f.level === "error").length, fixable: (d?.findings ?? []).filter((f) => f.fixable && f.level !== "ok").length });
 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));
+    if (!body.fix) {
+        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);
+    }
+    // fix=true: the MCP doctor's OWN fix path (orphan markers etc. — only the findings it tags fixable). Gated like every bus write. Before → fix → after, with the delta.
+    if (!busWrites.enabled)
+        return c.json({ error: "bus writes are off — switch them on in the header (WRITES), then Fix fixable" }, 403);
+    const r = await runs.exec({ kind: "mcp", label: "bus doctor · fix", sideEffects: true, args: { tool: "doctor", fix: true, agentId: AGENT_ID } }, async (log) => {
+        const before = (await bus.call("doctor", {}, log));
+        const b = doctorCounts(before);
+        log(`before: ${b.warn} warn · ${b.error} error · ${b.fixable} fixable`);
+        const fixed = (await bus.call("doctor", { fix: true }, log));
+        log(`fix: ${fixed.fixApplied ? "applied" : "nothing applied"}`);
+        const after = (await bus.call("doctor", {}, log));
+        const a = doctorCounts(after);
+        log(`after: ${a.warn} warn · ${a.error} error · ${a.fixable} fixable (Δ warn ${a.warn - b.warn}, error ${a.error - b.error}, fixable ${a.fixable - b.fixable})`);
+        return { ...after, fixed: { applied: !!fixed.fixApplied, fixedFindings: (before.findings ?? []).filter((f) => f.fixable && f.level !== "ok" && !(after.findings ?? []).some((g) => g.check === f.check && g.level !== "ok")).map((f) => f.check) }, before: b, after: a, delta: { warn: a.warn - b.warn, error: a.error - b.error, fixable: a.fixable - b.fixable } };
+    });
+    return c.json(r, r.status === "ok" ? 200 : 500);
+});
+/* dist-behind-source is not doctor-fixable: rebuild the kit's MCP (the doctor's own advice: `npm run build` in packages/coord-mcp — here via the kit workspace: `pnpm --filter agent-coord-mcp build`, cwd = kit checkout). Only when a kit checkout is configured; never touches ~/agent-coord. */
+app.post("/actions/rebuild-kit-mcp", async (c) => {
+    if (!busWrites.enabled)
+        return c.json({ error: "bus writes are off — switch them on in the header (WRITES) first" }, 403);
+    const b = (await c.req.json().catch(() => ({})));
+    if (b.confirm !== "BUILD")
+        return c.json({ error: "confirm must be BUILD" }, 400);
+    if (!hasKitCheckout(cfg.kitPath))
+        return c.json({ error: `no kit checkout at kitPath (${cfg.kitPath || "unset"}) — on this machine the MCP is the installed npm package; upgrade it with npm i -g agent-coord-mcp@latest, or ask the kit coordinator to publish` }, 409);
+    const argv = ["pnpm", "--filter", "agent-coord-mcp", "build"];
+    const r = await runs.exec({ kind: "shell", label: "rebuild kit MCP (pnpm --filter agent-coord-mcp build)", sideEffects: true, args: { cwd: cfg.kitPath, argv } }, async (log) => {
+        log(`$ ${argv.join(" ")}  (cwd ${cfg.kitPath})`);
+        const out = await execP(argv[0], argv.slice(1), { cwd: cfg.kitPath, timeout: 180_000, maxBuffer: 8 << 20 }).catch((e) => { log(`exit: ${e.message}`); return { stdout: e.stdout ?? "", stderr: e.stderr ?? "", failed: true }; });
+        for (const l of (out.stdout + out.stderr).replace(/\x1b\[[0-9;]*m/g, "").split("\n").filter(Boolean).slice(-40))
+            log(l);
+        if (out.failed)
+            throw new Error("build failed — see log");
+        log("built. Live MCP sessions still run the old inode: restart agents (detach_agent + attach_agent) or wait for their next session; the console's own client reconnects on next use.");
+        return { ok: true, cwd: cfg.kitPath };
+    });
     return c.json(r, r.status === "ok" ? 200 : 500);
 });
 app.post("/actions/project-doctor/:name", async (c) => {
@@ -912,8 +973,13 @@ setInterval(runPurge, 30 * 60_000).unref();
 /* 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
+    // Cache policy: the shell (index.html) is never cached (so an upgraded API serves the new UI on next load — David saw a 0.1.5 UI on 0.1.6 until a hard refresh);
+    // hashed Vite assets under /assets/* are immutable for a year; everything else (fonts, icons) a day.
+    const shell = (c) => { c.header("Cache-Control", "no-cache"); c.header("X-Console-Version", PKG.version); return c.html(readFileSync(path.join(PUBLIC_DIR, "index.html"), "utf8")); };
+    root.get("/", shell);
+    root.get("/index.html", shell);
+    root.use("/*", serveStatic({ root: PUBLIC_DIR, onFound: (p, c) => { c.header("Cache-Control", /\/assets\/[^/]+-[\w-]{6,}\.\w+$/.test(p) ? "public, max-age=31536000, immutable" : "public, max-age=86400"); } }));
+    root.get("*", shell); // 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";

package/dist/skills.js

@@ -1,10 +1,41 @@
-/* Supplement to the CLIs' `list --json`: byte-compare installed SKILL.md with the kit source (in-sync signal the CLIs do not report). */
+/* Supplement to the CLIs' `list --json`: compare installed SKILL.md with what the installer would write (in-sync signal the CLIs do not report).
+   groundwork: byte-copy → raw hash. playbook: per-harness placeholder rewrite → hash the rewritten source (see loadRewrite). */
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import path from "node:path";
 import { packageRoot } from "./kitresolve.js";
+import { pathToFileURL } from "node:url";
+const FALLBACK_REWRITE = {
+    claude: { tool: (n) => `mcp__agent-coord__${n}`, tools: "mcp__agent-coord__*" },
+    grok: { tool: (n) => `agent-coord__${n}`, tools: "agent-coord__*", playbookHome: "~/.grok/groundwork-playbook" },
+    cursor: { tool: (n) => n, tools: "the agent-coord MCP tools" },
+    vscode: { tool: (n) => `#tool:${n}`, tools: "#tool:agent-coord/*" },
+    opencode: { tool: (n) => `agent-coord_${n}`, tools: "agent-coord_*" },
+    generic: { tool: (n) => `the \`${n}\` tool on the \`agent-coord\` MCP server`, tools: "the tools on the `agent-coord` MCP server" },
+};
+const fallbackRewrite = (text, harness) => { const spec = FALLBACK_REWRITE[harness] ?? FALLBACK_REWRITE.generic; let out = text.replaceAll("{{tools:agent-coord}}", spec.tools).replace(/\{\{tool:([a-z0-9_]+)\}\}/g, (_m, n) => spec.tool(n)); if (spec.playbookHome)
+    out = out.replaceAll("~/.claude/groundwork-playbook", spec.playbookHome); return out; };
+const rewriteCache = new Map();
+async function loadRewrite(root) {
+    const hit = rewriteCache.get(root);
+    if (hit)
+        return hit;
+    let out = { fn: fallbackRewrite, source: "console fallback table" };
+    const mod = path.join(root, "lib", "packaging.mjs");
+    if (existsSync(mod)) {
+        try {
+            const m = (await import(pathToFileURL(mod).href));
+            if (typeof m.rewritePlaceholders === "function")
+                out = { fn: m.rewritePlaceholders, source: "kit lib/packaging.mjs" };
+        }
+        catch { /* fallback */ }
+    }
+    rewriteCache.set(root, out);
+    return out;
+}
 const sha = (p) => (existsSync(p) ? createHash("sha1").update(readFileSync(p)).digest("hex").slice(0, 10) : null);
+const shaText = (t) => createHash("sha1").update(t).digest("hex").slice(0, 10);
 const dirs = (p) => (existsSync(p) ? readdirSync(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name) : []);
 const front = (p) => { if (!existsSync(p))
     return {}; const m = readFileSync(p, "utf8").match(/^---\n([\s\S]*?)\n---/); const o = {}; m?.[1].split("\n").forEach((l) => { const i = l.indexOf(":"); if (i > 0)
@@ -14,13 +45,13 @@ export function groundworkSkills(kitPath, projectPath) {
     const versionMarker0 = existsSync(path.join(projectPath, "docs/.groundwork/VERSION")) ? readFileSync(path.join(projectPath, "docs/.groundwork/VERSION"), "utf8").trim() : null;
     if (!root)
         return { versionMarker: versionMarker0, kitVersion: null, driftedVersion: false, skills: [], error: "groundwork not found — npm i -g @davidbalzan/groundwork (or set kitPath to a kit checkout)" };
-    const payload = path.join(root, "payload/skills");
+    const payload = path.join(root, "payload/skills"); // groundwork init/update byte-copies SKILL.md (copyFileSafe) → raw hash comparison is correct here
     const pathsMjs = path.join(root, "src/lib/paths.mjs");
     const minimal = existsSync(pathsMjs) ? [...(readFileSync(pathsMjs, "utf8").match(/MINIMAL_SKILLS = \[([\s\S]*?)\]/)?.[1] ?? "").matchAll(/"([^"]+)"/g)].map((m) => m[1]) : [];
     const versionMarker = existsSync(path.join(projectPath, "docs/.groundwork/VERSION")) ? readFileSync(path.join(projectPath, "docs/.groundwork/VERSION"), "utf8").trim() : null;
     const kitVersion = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8")).version;
     return {
-        versionMarker, kitVersion, driftedVersion: !!versionMarker && versionMarker !== kitVersion,
+        versionMarker, kitVersion, source: root, driftedVersion: !!versionMarker && versionMarker !== kitVersion,
         skills: dirs(payload).map((name) => {
             const src = path.join(payload, name, "SKILL.md");
             const inst = path.join(projectPath, ".claude/skills", name, "SKILL.md");
@@ -35,19 +66,32 @@ export function groundworkSkills(kitPath, projectPath) {
     };
 }
 /* Global playbook cards live in more than one harness home: Claude → ~/.claude/skills, Grok → ~/.grok/skills (+ ~/.grok/groundwork-playbook). Measure each. */
-const HARNESS_HOMES = [["claude", path.join(homedir(), ".claude/skills")], ["grok", path.join(homedir(), ".grok/skills")]];
-export function playbookCards(kitPath) {
+// Same home overrides the installer honours (CLAUDE_HOME / GROK_HOME), so measurement and install target the same dirs (and tests can point both at a temp home).
+const HARNESS_HOMES = [["claude", path.join(process.env.CLAUDE_HOME || path.join(homedir(), ".claude"), "skills")], ["grok", path.join(process.env.GROK_HOME || path.join(homedir(), ".grok"), "skills")]];
+/* Harness homes the playbook installer can target (same env overrides as install.mjs). `detectedHarnesses` = those whose home dir exists on this machine —
+   passed as --harness= to `update` so grok/cursor/... mirrors are refreshed only where the harness is present (the installer's no-flag default is all five). */
+export const INSTALLER_HOMES = {
+    claude: process.env.CLAUDE_HOME || path.join(homedir(), ".claude"), grok: process.env.GROK_HOME || path.join(homedir(), ".grok"), cursor: process.env.CURSOR_HOME || path.join(homedir(), ".cursor"),
+    vscode: process.env.VSCODE_HOME || path.join(homedir(), ".vscode"), opencode: process.env.OPENCODE_HOME || path.join(homedir(), ".config/opencode"),
+};
+export const detectedHarnesses = () => Object.entries(INSTALLER_HOMES).filter(([, d]) => existsSync(d)).map(([h]) => h);
+/* Exposed for the fixture test: the fallback table must produce the same bytes as the kit's rewritePlaceholders. */
+export const __rewrite = { fallbackRewrite, loadRewrite };
+export async function playbookCards(kitPath) {
     const root = packageRoot(kitPath, "playbook");
     if (!root)
         return { kitVersion: null, globalDir: HARNESS_HOMES[0][1], homes: [], cards: [], error: "agent-coordination not found — npm i -g agent-coordination (or set kitPath to a kit checkout)" };
     const srcRoot = path.join(root, "skills");
     const kitVersion = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8")).version;
     const homes = HARNESS_HOMES.filter(([, d]) => existsSync(d));
+    const rw = await loadRewrite(root);
+    // expected installed bytes per harness = installer rewrite of the card (same transform install.mjs applies before writing SKILL.md)
+    const expected = (src, harness) => shaText(rw.fn(readFileSync(src, "utf8"), harness));
     return {
-        kitVersion, globalDir: HARNESS_HOMES[0][1], homes: homes.map(([h, d]) => ({ harness: h, dir: d })),
+        kitVersion, source: root, rewrite: rw.source, globalDir: HARNESS_HOMES[0][1], homes: homes.map(([h, d]) => ({ harness: h, dir: d })),
         cards: dirs(srcRoot).filter((n) => n !== "references").map((name) => {
             const src = path.join(srcRoot, name, "SKILL.md");
-            const per = Object.fromEntries(homes.map(([h, d]) => { const inst = path.join(d, name, "SKILL.md"); const installed = existsSync(inst); const slices = existsSync(path.join(d, name, "references")) ? readdirSync(path.join(d, name, "references")).filter((f) => f.endsWith(".md")) : []; return [h, { installed, inSync: installed ? sha(src) === sha(inst) : null, slices: slices.length, legacyEssay: slices.includes("playbook.md") }]; }));
+            const per = Object.fromEntries(homes.map(([h, d]) => { const inst = path.join(d, name, "SKILL.md"); const installed = existsSync(inst); const slices = existsSync(path.join(d, name, "references")) ? readdirSync(path.join(d, name, "references")).filter((f) => f.endsWith(".md")) : []; return [h, { installed, inSync: installed ? expected(src, h) === sha(inst) : null, slices: slices.length, legacyEssay: slices.includes("playbook.md") }]; }));
             const claude = per.claude ?? { installed: false, inSync: null, slices: 0, legacyEssay: false };
             return { name, installed: claude.installed, inSync: claude.inSync, slices: claude.slices, legacyEssay: claude.legacyEssay, homes: per, description: front(src).description ?? "", mirrors: { opencode: existsSync(path.join(homedir(), ".config/opencode/skills", name)), cursor: existsSync(path.join(homedir(), ".cursor/commands", `${name}.md`)), vscode: existsSync(path.join(homedir(), ".vscode/prompts", `${name}.prompt.md`)) } };
         }),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@davidbalzan/groundwork-console",
   "private": false,
-  "version": "0.1.6",
+  "version": "0.1.7",
   "type": "module",
   "dependencies": {
     "@davidbalzan/groundwork-seam": "^0.1.0",
@@ -44,6 +44,9 @@
     "build:web": "pnpm --filter @groundwork-console/web build && rm -rf public && cp -R ../web/dist public",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "start": "node bin/groundwork-console.mjs",
-    "publish-check": "node scripts/publish-check.mjs"
+    "publish-check": "node scripts/publish-check.mjs",
+    "test:inject": "tsx test/inject.test.mts",
+    "test:skills": "tsx test/skills.test.mts",
+    "test": "pnpm run test:inject && pnpm run test:skills"
   }
 }