@davidbalzan/groundwork-console 0.1.5 → 0.1.7

package/README.md

@@ -12,7 +12,7 @@ npx @davidbalzan/groundwork-console                                    # or: npm
 First run creates `~/.groundwork-console/config.json` (add projects from Home → **Add project**) and `~/.groundwork-console/token`, prints the URL and a sign-in link, and opens the browser already signed in. Everything runs on one port (`:8790`).
 
 ```
-groundwork-console [start] [--port 8790] [--host 127.0.0.1 | --tailscale] [--no-open] [--no-auth] [--config <file>]
+groundwork-console [start] [--port 8790] [--host 127.0.0.1 | --tailscale | --lan[=<ip>]] [--no-open] [--no-auth] [--config <file>]
 groundwork-console doctor    # kit requires + which bins/paths were resolved
 groundwork-console token     # print the token
 groundwork-console config    # print the config path
@@ -22,7 +22,7 @@ Requires on the host: Node ≥ 22, tmux (pane monitor / spawn), and either the t
 
 ## From another machine
 
-`groundwork-console --tailscale` binds this machine's Tailscale IP (found via `tailscale ip -4`) instead of loopback and prints a sign-in link you can open from any device on your tailnet; the token cookie does the rest (plain http — keep it on the tailnet, or put TLS in front). Without Tailscale: `ssh -N -L 8790:127.0.0.1:8790 <host>` and open `http://localhost:8790`.
+`groundwork-console --tailscale` binds this machine's Tailscale IP (found via `tailscale ip -4`) instead of loopback and prints a sign-in link you can open from any device on your tailnet; the token cookie does the rest (plain http — keep it on the tailnet, or put TLS in front). On the same home network without Tailscale: `groundwork-console --lan` binds the primary private LAN IPv4 (or `--lan=<ip>` to pin one) — same sign-in link flow, plain http, trusted networks only. Otherwise: `ssh -N -L 8790:127.0.0.1:8790 <host>` and open `http://localhost:8790`. `--no-auth` is refused together with `--lan`/`--tailscale` (token auth must front any non-loopback bind).
 
 ## What it does
 
@@ -39,6 +39,6 @@ Writes are behind two one-click header switches (bus writes · seam & docs write
 ## Config & env
 
 `~/.groundwork-console/config.json`: `{ "kitPath": "~/workspace/groundwork-kit", "coordDir": "~/agent-coord", "projects": [{ "name", "path", "room" }] }`.
-Env: `GROUNDWORK_CONSOLE_HOST` (bind; default `127.0.0.1` — put the token auth in front before exposing), `GROUNDWORK_CONSOLE_TOKEN`, `GROUNDWORK_CONSOLE_AUTH=off`, `GROUNDWORK_CONSOLE_CONFIG`, `GROUNDWORK_CONSOLE_RULES`, `AGENT_COORD_DIR`, `PORT`. (`KIT_CONSOLE_*` from the pre-rename days is still honoured.)
+Env: `GROUNDWORK_CONSOLE_HOST` (bind; default `127.0.0.1` — put the token auth in front before exposing), `GROUNDWORK_CONSOLE_TOKEN`, `GROUNDWORK_CONSOLE_UPLOAD_TTL_HOURS` (pasted images are purged after this many hours; default 6), `GROUNDWORK_CONSOLE_AUTH=off`, `GROUNDWORK_CONSOLE_CONFIG`, `GROUNDWORK_CONSOLE_RULES`, `AGENT_COORD_DIR`, `PORT`. (`KIT_CONSOLE_*` from the pre-rename days is still honoured.)
 
 Source, issues, design notes: <https://github.com/davidbalzan/groundwork-console>. MIT.

package/bin/groundwork-console.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 /* groundwork-console — one command: starts the API + serves the built UI on one port, prints the sign-in link, opens the browser.
-   Flags: --port 8790 · --host 127.0.0.1 · --tailscale (bind the tailnet IP, print the remote sign-in link) · --no-open · --no-auth · --config <file>
+   Flags: --port 8790 · --host 127.0.0.1 · --tailscale (bind the tailnet IP) · --lan[=<ip>] (bind the primary private LAN IPv4) · --no-open · --no-auth · --config <file>
+   Both remote flags print the remote sign-in link; token auth must front any non-loopback bind (--no-auth + --lan/--tailscale refuses unless GROUNDWORK_CONSOLE_UNSAFE_LAN=1).
    Subcommands: token (print the token) · doctor (kit requires + paths) · config (print config path) */
 import { readFileSync, existsSync } from "node:fs";
 import { execFileSync } from "node:child_process";
@@ -23,7 +24,23 @@ function tailscaleIp() {
   for (const addrs of Object.values(os.networkInterfaces())) for (const a of addrs ?? []) if (a.family === "IPv4" && /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./.test(a.address)) return a.address;
   return null;
 }
+/** Primary private LAN IPv4: prefer en0/eth0, else the first non-internal 10/8, 172.16/12, 192.168/16 address. */
+function lanIp() {
+  const ifs = os.networkInterfaces();
+  const priv = (a) => /^(10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.)/.test(a);
+  const pick = (names) => { for (const n of names) for (const a of ifs[n] ?? []) if (a.family === "IPv4" && !a.internal && priv(a.address)) return a.address; return null; };
+  return pick(["en0", "eth0", "en1", "wlan0"]) ?? pick(Object.keys(ifs).sort());
+}
 let host = String(flag("--host", process.env.GROUNDWORK_CONSOLE_HOST ?? "127.0.0.1"));
+const lanArg = args.find((a) => a === "--lan" || a.startsWith("--lan="));
+if (lanArg && has("--tailscale")) { console.error("--lan and --tailscale are exclusive — pick one bind"); process.exit(1); }
+if ((lanArg || has("--tailscale")) && has("--no-auth") && process.env.GROUNDWORK_CONSOLE_UNSAFE_LAN !== "1") { console.error("refusing a non-loopback bind with auth off — drop --no-auth (token auth fronts the LAN/tailnet), or set GROUNDWORK_CONSOLE_UNSAFE_LAN=1 if you really mean it"); process.exit(1); }
+if (lanArg) {
+  const pinned = lanArg.includes("=") ? lanArg.split("=")[1] : null;
+  const ip = pinned ?? lanIp();
+  if (!ip) { console.error("--lan: no private LAN IPv4 found (interfaces: " + Object.keys(os.networkInterfaces()).join(", ") + ") — pass --lan=<ip>"); process.exit(1); }
+  host = ip; if (!process.env.GROUNDWORK_CONSOLE_PUBLIC_API) process.env.GROUNDWORK_CONSOLE_PUBLIC_API = `http://${ip}:${port}/api`;
+}
 if (has("--tailscale")) { const ip = tailscaleIp(); if (!ip) { console.error("--tailscale: no tailnet address found (is Tailscale running? try `tailscale ip -4`)"); process.exit(1); } host = ip; if (!process.env.GROUNDWORK_CONSOLE_PUBLIC_API) process.env.GROUNDWORK_CONSOLE_PUBLIC_API = `http://${ip}:${port}/api`; }
 if (flag("--config")) process.env.GROUNDWORK_CONSOLE_CONFIG = String(flag("--config"));
 process.env.PORT = port; process.env.GROUNDWORK_CONSOLE_HOST = host;
@@ -41,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);
 }
@@ -52,5 +71,5 @@ const { CONFIG_FILE } = await import("../dist/config.js");
 const base = `http://${host === "0.0.0.0" ? "localhost" : host}:${port}`;
 const token = authEnabled ? loadToken() : null;
 const url = token ? `${base}/api/auth/login?token=${encodeURIComponent(token)}&next=/` : `${base}/`;
-console.log(`\n  groundwork-console ${pkg.version}\n  UI      ${base}/\n  config  ${CONFIG_FILE}\n  token   ${authEnabled ? tokenFile : "auth off"}\n  sign in ${url}${has("--tailscale") ? `\n  remote  open the sign-in link above from any device on your tailnet (token cookie, 30 d). Plain http — keep it on the tailnet.` : ""}\n`);
+console.log(`\n  groundwork-console ${pkg.version}\n  UI      ${base}/\n  config  ${CONFIG_FILE}\n  token   ${authEnabled ? tokenFile : "auth off"}\n  sign in ${url}${has("--tailscale") ? `\n  remote  open the sign-in link above from any device on your tailnet (token cookie, 30 d). Plain http — keep it on the tailnet.` : lanArg ? `\n  remote  open the sign-in link above from any device on this LAN (token cookie, 30 d). Plain http on your local network — home/trusted networks only, never a shared or public one.` : ""}\n`);
 if (!has("--no-open") && host !== "0.0.0.0") { try { const { default: open } = await import("open"); await open(url); } catch { /* headless: link is printed */ } }

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/bus.js

@@ -1,7 +1,7 @@
 /* Read-only views over the agent-coord store (~/agent-coord). Mirrors what the MCP tools return, without going through the MCP. */
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
-import { listPanes } from "./tmux.js";
+import { listPanes, contentActivity } from "./tmux.js";
 const readJson = (p, fallback) => { try {
     return JSON.parse(readFileSync(p, "utf8"));
 }
@@ -21,12 +21,19 @@ const tailJsonl = (p, limit) => {
 };
 export async function agentsAsync(root) {
     const panes = await listPanes();
-    return agentsSync(root).map((a) => {
+    const base = agentsSync(root);
+    // Content-based activity for live panes only (one capture per pane per poll); window_activity is the fallback.
+    const content = new Map();
+    await Promise.all(base.map(async (a) => { const pane = a.pane ? panes.find((p) => p.paneId === a.pane || p.target === a.pane) : undefined; if (pane && !pane.dead)
+        content.set(a.agentId, await contentActivity(pane.paneId)); }));
+    return base.map((a) => {
         const pane = a.pane ? panes.find((p) => p.paneId === a.pane || p.target === a.pane) : undefined;
-        const paneActivity = pane?.activityTs ?? null;
+        const windowActivity = pane?.activityTs ?? null;
+        const ct = content.get(a.agentId);
+        const paneActivity = ct === undefined || ct === null ? windowActivity : ct || null; // 0 = seeded, no change observed yet → treated as unknown, not as "now"
         const lastSeen = Math.max(a.lastSeen ?? 0, paneActivity ?? 0);
         const age = lastSeen ? Date.now() - lastSeen : Infinity;
-        return { ...a, paneActivity, paneCommand: pane?.command ?? null, paneAlive: pane ? !pane.dead : null, lastSeen: lastSeen || null, heartbeatAgeMs: Number.isFinite(age) ? age : null, liveness: age < 15 * 60_000 ? "live" : age < 24 * 3_600_000 ? "idle" : "dead", active: paneActivity ? Date.now() - paneActivity < 60_000 : false };
+        return { ...a, paneActivity, windowActivity, paneCommand: pane?.command ?? null, paneAlive: pane ? !pane.dead : null, lastSeen: lastSeen || null, heartbeatAgeMs: Number.isFinite(age) ? age : null, liveness: age < 15 * 60_000 ? "live" : age < 24 * 3_600_000 ? "idle" : "dead", active: paneActivity ? Date.now() - paneActivity < 60_000 : false };
     }).sort((a, b) => (b.lastSeen ?? 0) - (a.lastSeen ?? 0));
 }
 export const agents = agentsSync;

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/runs.js

@@ -1,6 +1,38 @@
-const RING = 200, LOG_MAX = 400;
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+const RING = 200, LOG_MAX = 400, PERSIST_LOG = 60;
+/* Persistence: ~/.groundwork-console/runs.json (state dir only — never ~/agent-coord). Write-behind (debounced 300 ms) on every change; loaded on construct.
+   Runs still "running" at load are marked failed ("api restarted") so nothing looks alive that isn't. Per-run logs are truncated to PERSIST_LOG lines on disk. */
+const RUNS_FILE = path.join(homedir(), ".groundwork-console", "runs.json");
 export class Runs {
     runs = [];
+    saveTimer = null;
+    constructor() {
+        try {
+            if (existsSync(RUNS_FILE)) {
+                const j = JSON.parse(readFileSync(RUNS_FILE, "utf8"));
+                this.runs = (j.runs ?? []).slice(-RING).map((r) => (r.status === "running" || r.status === "queued" ? { ...r, status: "failed", endedAt: r.endedAt ?? Date.now(), error: r.error ?? "api restarted while running" } : r));
+                this.seq = j.seq ?? 0;
+            }
+        }
+        catch {
+            this.runs = [];
+        } // corrupt file: start empty, next save overwrites
+    }
+    save() {
+        if (this.saveTimer)
+            return;
+        this.saveTimer = setTimeout(() => {
+            this.saveTimer = null;
+            try {
+                mkdirSync(path.dirname(RUNS_FILE), { recursive: true });
+                const slim = this.runs.map((r) => ({ ...r, log: r.log.length > PERSIST_LOG ? [`… ${r.log.length - PERSIST_LOG} earlier lines`, ...r.log.slice(-PERSIST_LOG)] : r.log }));
+                writeFileSync(RUNS_FILE, JSON.stringify({ seq: this.seq, savedAt: Date.now(), runs: slim }));
+            }
+            catch { /* disk unavailable: in-memory ring still works */ }
+        }, 300);
+    }
     listeners = new Set();
     seq = 0;
     list(limit = 50) { return this.runs.slice(-limit).reverse(); }
@@ -8,7 +40,7 @@ export class Runs {
     running() { return this.runs.filter((r) => r.status === "running" || r.status === "queued"); }
     subscribe(fn) { this.listeners.add(fn); return () => this.listeners.delete(fn); }
     emit(r) { for (const l of this.listeners)
-        l(r); }
+        l(r); this.save(); }
     create(init) {
         const r = { id: `run-${Date.now()}-${++this.seq}`, status: "queued", startedAt: Date.now(), log: [], ...init };
         this.runs.push(r);