@davidbalzan/groundwork-console 0.1.6 → 0.1.8

package/README.md

@@ -18,7 +18,7 @@ groundwork-console token     # print the token
 groundwork-console config    # print the config path
 ```
 
-Requires on the host: Node ≥ 22, tmux (pane monitor / spawn), and either the three kit bins above on PATH or a kit checkout at `kitPath` in the config. `doctor` tells you which it found. Console requires: seam `^0.1.0` · agent-coord-mcp `^0.23.0` · groundwork `^0.3.0` · agent-coordination `^0.5.0`.
+Requires on the host: Node ≥ 22, tmux (pane monitor / spawn), and either the three kit bins above on PATH or a kit checkout at `kitPath` in the config. `doctor` tells you which it found. Console requires: seam `^0.1.0` · agent-coord-mcp `^0.24.0` · groundwork `^0.3.0` · agent-coordination `^0.5.0`.
 
 ## From another machine
 

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

@@ -1,6 +1,8 @@
 /* Read-only git views for a project's docs: uncommitted hunks (working tree vs HEAD, staged included), last commit touching the file + its hunks, and a docs/ status map. */
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { existsSync } from "node:fs";
+import path from "node:path";
 const run = promisify(execFile);
 async function git(cwd, args) { try {
     const r = await run("git", args, { cwd, maxBuffer: 8 << 20 });
@@ -67,3 +69,115 @@ export async function lastDocsCommit(projectPath) {
     const files = ((await git(projectPath, ["show", "--format=", "--name-only", short, "--", "docs"])) ?? "").split("\n").filter(Boolean).map((f) => f.replace(/^docs\//, ""));
     return { short, subject, date, files };
 }
+const GIT_CACHE_MS = 3_000;
+const STALE_DAYS = 14;
+const GRAPH_MAX = 500;
+const cache = new Map();
+function cached(key, fn) {
+    const hit = cache.get(key);
+    if (hit && Date.now() - hit.at < GIT_CACHE_MS)
+        return hit.value;
+    const value = fn();
+    cache.set(key, { at: Date.now(), value });
+    value.catch(() => cache.delete(key));
+    return value;
+}
+const splitRecords = (out) => (out ?? "").split("\n").filter(Boolean).map((l) => l.split("\x1f"));
+export function gitGraph(projectPath, limit = 200) {
+    const n = Math.max(1, Math.min(GRAPH_MAX, Math.floor(limit) || 200));
+    return cached(`graph:${projectPath}:${n}`, async () => {
+        const head = (await git(projectPath, ["rev-parse", "HEAD"]))?.trim() ?? "";
+        const rows = splitRecords(await git(projectPath, ["log", "--all", "--date-order", `-n${n}`, "--format=%H%x1f%h%x1f%P%x1f%s%x1f%an%x1f%aI%x1f%D"]));
+        const commits = rows.map(([sha, short, parents, subject, author, date, refs]) => ({ sha, short, parents: (parents ?? "").split(" ").filter(Boolean), subject: subject ?? "", author: author ?? "", date: date ?? "", refs: (refs ?? "").split(",").map((r) => r.trim().replace(/^HEAD -> /, "HEAD -> ")).filter(Boolean) }));
+        return { head, commits };
+    });
+}
+/** `git worktree list --porcelain` → entries; dirty = `git status --porcelain` non-empty (skipped for prunable/missing paths); agent from the fleet sibling dir name `<repo>-<agentId>[-<slice>]`, else board owner whose Branch·Worktree column names the branch/path. */
+export function gitWorktrees(projectPath, hints = {}) {
+    return cached(`worktrees:${projectPath}:${(hints.agentIds ?? []).join(",")}`, async () => {
+        const out = (await git(projectPath, ["worktree", "list", "--porcelain"])) ?? "";
+        const blocks = out.split(/\n\s*\n/).map((b) => b.split("\n").filter(Boolean)).filter((b) => b.length);
+        const repoBase = path.basename(projectPath.replace(/\/+$/, ""));
+        const agentIds = [...(hints.agentIds ?? [])].sort((a, b) => b.length - a.length); // longest first: "<project>-worker-1" before "<project>"
+        const worktrees = await Promise.all(blocks.map(async (b, i) => {
+            const get = (k) => b.find((l) => l === k || l.startsWith(k + " "))?.slice(k.length).trim();
+            const wt = get("worktree") ?? "";
+            const sha = get("HEAD") ?? "";
+            const branchRef = get("branch");
+            const prunable = get("prunable") !== undefined;
+            const detached = b.includes("detached") || !branchRef;
+            const branch = branchRef ? branchRef.replace(/^refs\/heads\//, "") : null;
+            const dirty = !prunable && wt && existsSync(wt) ? ((await git(wt, ["status", "--porcelain"])) ?? "").trim().length > 0 : false;
+            const dir = path.basename(wt);
+            let agent;
+            if (i > 0 && dir.startsWith(repoBase + "-")) {
+                const suffix = dir.slice(repoBase.length + 1);
+                agent = agentIds.find((id) => suffix === id || suffix.startsWith(id + "-"));
+            }
+            if (!agent) {
+                const row = hints.boardRows?.find((r) => r.branchWorktree && ((branch && r.branchWorktree.includes(branch)) || r.branchWorktree.includes(dir)));
+                if (row?.owner)
+                    agent = row.owner;
+            }
+            return { path: wt, branch, sha, short: sha.slice(0, 7), detached, dirty, prunable, ...(agent ? { agent } : {}), isMain: i === 0 };
+        }));
+        return { worktrees };
+    });
+}
+/** gh (optional): open/merged/closed PRs by head branch. Missing/unauthenticated gh → null (envelope `ghAvailable:false`). */
+async function ghPrs(projectPath) {
+    try {
+        const r = await run("gh", ["pr", "list", "--state", "all", "--limit", "50", "--json", "number,url,state,title,headRefName"], { cwd: projectPath, maxBuffer: 8 << 20, timeout: 15_000 });
+        const list = JSON.parse(r.stdout);
+        const m = new Map();
+        for (const p of list)
+            if (!m.has(p.headRefName))
+                m.set(p.headRefName, { number: p.number, url: p.url, state: p.state, title: p.title });
+        return m;
+    }
+    catch {
+        return null;
+    }
+}
+export function gitBranches(projectPath, hints = {}) {
+    return cached(`branches:${projectPath}:${(hints.agentIds ?? []).join(",")}`, async () => {
+        const defaultBranch = "main";
+        const base = `origin/${defaultBranch}`;
+        const hasBase = (await git(projectPath, ["rev-parse", "--verify", "-q", `${base}^{commit}`]))?.trim() ? true : false;
+        const rows = splitRecords(await git(projectPath, ["for-each-ref", "--sort=-committerdate", "--format=%(refname)%1f%(objectname)%1f%(objectname:short)%1f%(subject)%1f%(committerdate:iso-strict)", "refs/heads", "refs/remotes"]))
+            .filter(([ref]) => !/^refs\/remotes\/[^/]+\/HEAD$/.test(ref));
+        const [{ worktrees }, prs] = await Promise.all([gitWorktrees(projectPath, hints), ghPrs(projectPath)]);
+        const qaOf = (n) => { const row = hints.openPrs?.find((r) => Object.values(r).some((v) => new RegExp(`(^|[^0-9])#${n}([^0-9]|$)`).test(v))); if (!row)
+            return undefined; const qa = row.mergeGate ?? row.status ?? row.state; return qa ? String(qa) : undefined; };
+        const now = Date.now();
+        const branches = await Promise.all(rows.map(async ([ref, sha, short, subject, date]) => {
+            const remote = ref.startsWith("refs/remotes/");
+            const name = ref.replace(/^refs\/(heads|remotes)\//, "");
+            let ahead = null, behind = null, merged = false;
+            if (hasBase) {
+                const lr = (await git(projectPath, ["rev-list", "--left-right", "--count", `${base}...${ref}`]))?.trim().split(/\s+/);
+                if (lr && lr.length === 2) {
+                    behind = +lr[0];
+                    ahead = +lr[1];
+                }
+                merged = (await gitOk(projectPath, ["merge-base", "--is-ancestor", ref, base]));
+            }
+            const stale = date ? now - Date.parse(date) > STALE_DAYS * 86_400_000 : false;
+            const localName = remote ? name.replace(/^[^/]+\//, "") : name;
+            const wt = remote ? undefined : worktrees.find((w) => w.branch === name);
+            const boardRow = hints.boardRows?.find((r) => r.branchWorktree && r.branchWorktree.includes(localName));
+            const owner = boardRow?.owner || wt?.agent;
+            const pr = prs?.get(localName);
+            const prOut = pr ? { ...pr, ...(qaOf(pr.number) ? { qa: qaOf(pr.number) } : {}) } : undefined;
+            return { name, remote, sha, short, subject: subject ?? "", date: date ?? "", ahead, behind, merged, stale, ...(wt ? { worktree: wt.path } : {}), ...(owner ? { owner } : {}), ...(prOut ? { pr: prOut } : {}) };
+        }));
+        return { defaultBranch, base, baseFound: hasBase, ghAvailable: prs !== null, branches };
+    });
+}
+async function gitOk(cwd, args) { try {
+    await run("git", args, { cwd });
+    return true;
+}
+catch {
+    return false;
+} }

package/dist/kitresolve.js

@@ -2,7 +2,9 @@ import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-export const REQUIRES = { seam: "^0.1.0", mcp: "^0.23.0", groundwork: "^0.3.0", playbook: "^0.5.0" };
+// mcp ^0.24.0 ships send_message.inReplyTo (npm 2026-08-19) — that is the floor. send_command's allowlist (/reload-skills since 0.25.0) is NOT a floor:
+// it is feature-detected per connection (BusClient.sendCommands → /health.requires.mcp.capabilities.sendCommand) and the console degrades gracefully without it.
+export const REQUIRES = { seam: "^0.1.0", mcp: "^0.24.0", groundwork: "^0.3.0", playbook: "^0.5.0" };
 const which = (bin) => { try {
     return execFileSync("which", [bin], { encoding: "utf8" }).trim() || null;
 }
@@ -56,25 +58,26 @@ export function installedVersions(kitPath) {
     const gw = groundworkCli(kitPath), pb = playbookCli(kitPath), mcp = mcpServer(kitPath);
     return { seam, groundwork: pkgVersionNear(gw), playbook: pkgVersionNear(pb), mcp: pkgVersionNear(mcp), paths: { groundwork: gw, playbook: pb, mcp, kitCheckout: hasKitCheckout(kitPath) ? kitPath : null } };
 }
-/** Minimal caret-range check (^a.b.c): same major (or same minor when major is 0), and >= min. */
+/** Floor check: the console's requirement is a MINIMUM within the same major (kit packages bump minors often; 0.25.1 must satisfy "^0.24.0").
+    Written as ^a.b.c for familiarity, evaluated as >= a.b.c and < (a+1).0.0 — NOT strict caret semantics for 0.x. */
 export function satisfies(v, range) {
     if (!v)
         return null;
     const m = range.match(/^\^(\d+)\.(\d+)\.(\d+)$/);
     if (!m)
         return null;
-    const [a, b, c] = v.split(".").map(Number);
+    const [a, b, c] = v.split(".").map((n) => parseInt(n, 10));
     const [x, y, z] = m.slice(1).map(Number);
+    if (![a, b, c].every(Number.isFinite))
+        return null;
     if (a !== x)
-        return false;
-    if (x === 0 && b !== y)
-        return false;
-    return a > x || b > y || (b === y && c >= z);
+        return false; // different major: not satisfied (breaking either way)
+    return 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, sendCommand: 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 = {};
@@ -74,12 +74,17 @@ export class BusClient {
             const reg = await client.callTool({ name: "register", arguments: { agentId: id.agentId, project: id.project, role: id.role, force: true } });
             log?.(`register → ${JSON.stringify(reg.structuredContent ?? textOf(reg)).slice(0, 160)}`);
             // Feature detection: which args each tool accepts (e.g. send_message.inReplyTo landed in kit 18ffbf4; the live bin may predate it).
+            let sendCommandDesc = "";
             try {
                 const tools = await client.listTools();
-                for (const t of tools.tools)
+                for (const t of tools.tools) {
                     this.toolArgs.set(t.name, new Set(Object.keys(t.inputSchema?.properties ?? {})));
+                    if (t.name === "send_command")
+                        sendCommandDesc = t.description ?? "";
+                }
             }
             catch { /* older server: no detection, pass nothing extra */ }
+            this.commands = await detectCommands(client, sendCommandDesc, log);
             this.client = client;
             return client;
         })();
@@ -91,8 +96,14 @@ export class BusClient {
         }
     }
     toolArgs = new Map();
+    commands = null;
+    /** send_command allowlist detected on the connected server (e.g. ["/clear","/compact"] on 0.24.0, +"/reload-skills" on 0.25.0); null = not connected / undetectable. */
+    get sendCommands() { return this.client ? this.commands : null; }
+    /** True when the connected server accepts this raw control command. */
+    acceptsCommand(cmd) { return this.sendCommands?.includes(cmd) ?? false; }
     /** 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)
@@ -108,6 +119,34 @@ export class BusClient {
     }
     async close() { await this.client?.close(); this.client = null; }
 }
+/* send_command allowlist detection. The MCP does not expose the allowlist in the tool schema (command is a plain string), so:
+   1. probe once per connection with a command that can never be valid — the server rejects it BEFORE looking at to/room or touching any pane
+      (transport.ts sendCommandTool: normalizeControlCommand → `unsupported command '…'. Allowed: /clear, /compact[, /reload-skills]`), so this is
+      side-effect-free and needs no bus-writes gate; 2. fall back to the tool description ("allowlist is locked to /clear, /compact and /reload-skills"). */
+const PROBE_COMMAND = "/__groundwork-console-probe__";
+async function detectCommands(client, description, log) {
+    const fromText = (t) => { const m = t.match(/Allowed:\s*([^\n]+)/i) ?? t.match(/locked to ([^.;\n]+)/i); return m ? [...m[1].matchAll(/\/[a-z][\w-]*/g)].map((x) => x[0]) : []; };
+    try {
+        const res = await client.callTool({ name: "send_command", arguments: { from: "groundwork-console", command: PROBE_COMMAND } });
+        const out = (res.structuredContent ?? parseText(textOf(res)));
+        const list = fromText(typeof out === "string" ? out : out?.error ?? textOf(res));
+        if (list.length) {
+            log?.(`send_command allowlist (probe): ${list.join(" ")}`);
+            return list;
+        }
+    }
+    catch (e) {
+        const list = fromText(e.message ?? "");
+        if (list.length)
+            return list;
+    }
+    const list = fromText(description);
+    if (list.length) {
+        log?.(`send_command allowlist (description): ${list.join(" ")}`);
+        return list;
+    }
+    return null;
+}
 function textOf(r) { return (r.content ?? []).map((c) => c.text ?? "").join("\n"); }
 function parseText(t) { try {
     return JSON.parse(t);

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