agent-coord-mcp 0.19.0 → 0.23.0

package/hooks/tmux-pusher.mjs

@@ -75,6 +75,7 @@ import { fileURLToPath } from "node:url";
 import path from "node:path";
 import { spawn, spawnSync } from "node:child_process";
 import { effectiveTier, isGateRunnerRole, TierQueue, formatBatch } from "./tier.mjs";
+import { isCi } from "./roles.mjs";
 import { mergeTransportMarker } from "./marker.mjs";
 import { pasteAndSubmit as sharedPasteAndSubmit, submitControl as sharedSubmitControl } from "./submit.mjs";
 
@@ -113,9 +114,10 @@ const MAX_QUEUE_MS = parseInt(process.env.AGENT_COORD_MAX_QUEUE_MS || "15000", 1
 // SCOPE: changes are honored only from these trusted ids. Re-resolved from
 // the registry every 30s so a role change doesn't strand a stale pusher;
 // AGENT_COORD_GATE_RUNNER=1|0 overrides in both directions.
-let tierCtx = { enabled: TIERS_ENABLED, gateRunner: false, trustedSenders: new Set() };
+let tierCtx = { enabled: TIERS_ENABLED, gateRunner: false, ci: false, trustedSenders: new Set() };
 function refreshTierCtx() {
   let gateRunner = false;
+  let ci = false;
   const trusted = new Set();
   try {
     const reg = JSON.parse(readFileSync(path.join(ROOT, "agents.json"), "utf8"));
@@ -123,18 +125,21 @@ function refreshTierCtx() {
       // Pass the whole entry: the frozen roleId lives beside `role`, and
       // reading only the display string would throw the identity away.
       if (isGateRunnerRole(entry)) trusted.add(id);
+      if (id === AGENT_ID) ci = isCi(entry);
     }
     gateRunner = trusted.has(AGENT_ID);
   } catch {
-    // No registry yet — conservative default (not a gate runner).
+    // No registry yet — conservative default (not a gate runner, not ci).
   }
   const env = process.env.AGENT_COORD_GATE_RUNNER;
   if (env === "1" || env === "true") gateRunner = true;
   if (env === "0" || env === "false") gateRunner = false;
-  if (gateRunner !== tierCtx.gateRunner) {
-    process.stderr.write(`[tmux-pusher] gate-runner resolved: ${gateRunner}\n`);
+  // AGENT_COORD_GATE_RUNNER must not flip ci — that would look like a
+  // verdict grant. Express-lane wake is roleId === ci only.
+  if (gateRunner !== tierCtx.gateRunner || ci !== tierCtx.ci) {
+    process.stderr.write(`[tmux-pusher] gate-runner resolved: ${gateRunner} ci: ${ci}\n`);
   }
-  tierCtx = { enabled: TIERS_ENABLED, gateRunner, trustedSenders: trusted };
+  tierCtx = { enabled: TIERS_ENABLED, gateRunner, ci, trustedSenders: trusted };
 }
 refreshTierCtx();
 setInterval(refreshTierCtx, 30_000).unref();
@@ -461,6 +466,12 @@ function writeReceipts(msgs, outcome) {
         ts: Date.now(),
         from: m.from,
         control: m.control === true,
+        // Build identity of the pusher that did the typing/verifying — the
+        // same module-graph stamp the transport marker carries (SCRIPT_MTIME
+        // covers hooks/*.mjs, not just this file). Lets deliveryOutcome note
+        // a "confirmed" issued by pre-upgrade verification logic. Omitted
+        // when unknown: absence reads as UNKNOWN downstream, never as fresh.
+        ...(SCRIPT_MTIME !== undefined ? { scriptMtime: SCRIPT_MTIME } : {}),
         ...(outcome
           ? {
               submitted: outcome.submitted === true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-coord-mcp",
-  "version": "0.19.0",
+  "version": "0.23.0",
   "description": "File-backed MCP server for coordinating multiple AI coding agents (Claude Code, Cursor, Cline, etc.). Local stdio or networked over Streamable HTTP.",
   "type": "module",
   "bin": {
@@ -8,15 +8,6 @@
     "coord-chat": "scripts/coord-chat.mjs",
     "coord-pusher": "scripts/coord-pusher.mjs"
   },
-  "scripts": {
-    "build": "tsc",
-    "prepare": "node scripts/check-self-dependency.mjs && tsc",
-    "start": "node dist/server.js",
-    "dev": "tsx src/server.ts",
-    "pretest": "node scripts/check-self-dependency.mjs && tsc",
-    "test": "node scripts/check-test-count.mjs",
-    "test:raw": "node --test \"test/*.test.mjs\""
-  },
   "files": [
     "dist",
     "src",
@@ -52,14 +43,23 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.4",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "proper-lockfile": "^4.1.2",
-    "zod": "^4.4.3"
+    "zod": "^4.4.3",
+    "@davidbalzan/groundwork-seam": "0.1.0"
   },
   "devDependencies": {
-    "@types/node": "^25.9.2",
+    "@types/node": "^26.2.0",
     "@types/proper-lockfile": "^4.1.4",
-    "tsx": "^4.19.2",
-    "typescript": "^6.0.3"
+    "tsx": "^4.23.12",
+    "typescript": "^7.0.2"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/server.js",
+    "dev": "tsx src/server.ts",
+    "pretest": "node scripts/check-self-dependency.mjs && tsc",
+    "test": "node scripts/check-test-count.mjs",
+    "test:raw": "node --test \"test/*.test.mjs\""
   }
-}
+}

package/scripts/check-self-dependency.mjs

@@ -17,10 +17,13 @@
 // was untouched; a reviewer reads the claim, not the diff. This guard is
 // cheap insurance against that class, not evidence of a recurring bug.
 //
-// Runs on `prepare` (every install), `pretest`, and `prepublishOnly`.
-import { readFileSync } from "node:fs";
+// Runs on `prepare` (every install) and `pretest`.
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
 
-const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+const pkgDir = fileURLToPath(new URL("..", import.meta.url));
+const pkg = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf8"));
 const DEP_FIELDS = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"];
 
 function selfDepFields(manifest) {
@@ -29,26 +32,71 @@ function selfDepFields(manifest) {
   );
 }
 
-const offenders = selfDepFields(pkg);
+function walkFor(name, start) {
+  let dir = start;
+  for (let i = 0; i < 6; i++) {
+    const candidate = join(dir, name);
+    if (existsSync(candidate)) return { file: candidate, root: dir };
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+function npmLockSelfDep() {
+  const sibling = join(pkgDir, "package-lock.json");
+  if (!existsSync(sibling)) return false;
+  try {
+    const lock = JSON.parse(readFileSync(sibling, "utf8"));
+    const rootPkg = lock.packages?.[""];
+    return Boolean(rootPkg && selfDepFields(rootPkg).length);
+  } catch {
+    return false;
+  }
+}
 
-let lockOffender = false;
-try {
-  const lock = JSON.parse(readFileSync(new URL("../package-lock.json", import.meta.url), "utf8"));
-  const rootPkg = lock.packages?.[""];
-  if (rootPkg && selfDepFields(rootPkg).length) lockOffender = true;
-} catch {
-  /* no lockfile yet (fresh checkout pre-install) — nothing to check */
+// pnpm-lock.yaml has no JSON root package. Check this package's importer
+// block for a key named after the package (a self-dep).
+function pnpmLockSelfDep() {
+  const found = walkFor("pnpm-lock.yaml", pkgDir);
+  if (!found) return false;
+  let text;
+  try {
+    text = readFileSync(found.file, "utf8");
+  } catch {
+    return false;
+  }
+  const rel = relative(found.root, pkgDir).split("\\").join("/") || ".";
+  const key = rel === "." ? "." : rel;
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const header = new RegExp(`(?<=^|\\n)  ${escaped}:\\n`);
+  const start = text.search(header);
+  if (start === -1) return false;
+  const from = text.indexOf("\n", start) + 1;
+  const next = text.slice(from).search(/\n  [^ \n]/);
+  const block = next === -1 ? text.slice(from) : text.slice(from, from + next);
+  const selfKey = new RegExp(`^[ \\t]+${pkg.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:\\s*$`, "m");
+  return selfKey.test(block);
 }
 
-if (offenders.length || lockOffender) {
+const offenders = selfDepFields(pkg);
+const npmLockOffender = npmLockSelfDep();
+const pnpmLockOffender = pnpmLockSelfDep();
+
+if (offenders.length || npmLockOffender || pnpmLockOffender) {
+  const lockBits = [
+    npmLockOffender && "package-lock.json's root package",
+    pnpmLockOffender && "pnpm-lock.yaml's importer for this package",
+  ].filter(Boolean);
   console.error(
     `[check-self-dependency] "${pkg.name}" depends on itself` +
       (offenders.length ? ` in package.json's ${offenders.join(", ")}` : "") +
-      (lockOffender ? `${offenders.length ? " and" : " in"} package-lock.json's root package` : "") +
+      (lockBits.length ? `${offenders.length ? " and" : " in"} ${lockBits.join(" and ")}` : "") +
       `.\nThis happened once before, added by an "npm audit fix" whose commit message said it was ` +
       `lockfile-only (de4e1ee, removed in 3bce3ce — see docs/DONE.md). If you just ran an audit or ` +
       `dependency update, check what else it changed in package.json. ` +
-      `Remove the self-reference from both files and re-run "npm install".`,
+      `Remove the self-reference from the manifest and lockfile.`,
   );
   process.exit(1);
 }

package/scripts/check-test-count.mjs

@@ -22,7 +22,7 @@
 
 import { spawn } from "node:child_process";
 
-const EXPECTED_TESTS = 226;
+const EXPECTED_TESTS = 272;
 
 const expected = Number(process.env.AGENT_COORD_EXPECTED_TESTS ?? EXPECTED_TESTS);
 // Same glob the suite always used — `--test test/` would recurse differently
@@ -41,9 +41,9 @@ child.stdout.on("data", (chunk) => {
 
 child.on("exit", (code, signal) => {
   if (signal) process.exit(1);
-  // The TAP summary lines the runner prints once, at the end.
+  // TAP (`# pass N`) on Node 20–22; spec reporter (`ℹ pass N`) on newer Node.
   const num = (label) => {
-    const m = out.match(new RegExp(`^# ${label} (\\d+)$`, "m"));
+    const m = out.match(new RegExp(`^(?:#|ℹ) ${label} (\\d+)\\s*$`, "m"));
     return m ? Number(m[1]) : null;
   };
   const tests = num("tests");

package/scripts/coord-pusher.mjs

@@ -114,15 +114,41 @@ try {
 } catch (e) {
   die(`register failed: ${e?.message ?? e}`);
 }
-// Stamp the mtime of THIS process's loaded script so doctor() can spot a
-// stale remote pusher after a remote-side upgrade (see v0.8.2 stale-pusher
-// check — same hazard as the local tmux-pusher).
-let scriptMtime;
-try {
-  const { statSync } = await import("node:fs");
-  const { fileURLToPath } = await import("node:url");
-  scriptMtime = statSync(fileURLToPath(import.meta.url)).mtimeMs;
-} catch { /* non-fatal */ }
+// Build identity of THIS pusher process: newest mtime across the entry file
+// AND its ../hooks/*.mjs imports, sampled once at startup. The entry file
+// alone is not enough — the paste/submit pipeline lives in hooks/submit.mjs,
+// so a fix landing there alone would leave a single-file stamp unchanged and
+// a still-running pusher on the old code would read as fresh (#28's lesson,
+// carried across the wire). Over-covering hooks siblings we don't import is
+// the safe direction: a spurious stale flag is loud and cheap, a false fresh
+// silently invalidates rollout verification. Stamped on the transport marker
+// AND on every receipt this process reports; undefined on failure — an
+// absent stamp reads as UNKNOWN downstream, never as fresh, and a partial
+// (entry-only) value could read fresh while submit.mjs is exactly the stale
+// part.
+const scriptMtime = await (async () => {
+  try {
+    const { statSync, readdirSync } = await import("node:fs");
+    const { fileURLToPath } = await import("node:url");
+    const path = await import("node:path");
+    const self = fileURLToPath(import.meta.url);
+    let newest = statSync(self).mtimeMs;
+    const hooksDir = path.join(path.dirname(self), "..", "hooks");
+    for (const f of readdirSync(hooksDir)) {
+      if (!f.endsWith(".mjs")) continue;
+      let m;
+      try {
+        m = statSync(path.join(hooksDir, f)).mtimeMs;
+      } catch {
+        continue; // deleted mid-scan
+      }
+      if (m > newest) newest = m;
+    }
+    return newest;
+  } catch {
+    return undefined; // non-fatal — absence stays honest
+  }
+})();
 try {
   await call(
     "report_transport",
@@ -323,6 +349,10 @@ async function reportReceipts(msgs, outcome) {
           id: m.id,
           ...(m.from !== undefined ? { from: m.from } : {}),
           control: m.control === true,
+          // Our build identity (module-graph mtime, see the startup stamp) —
+          // ties this receipt to the code that typed/verified the delivery.
+          // Omitted when unknown; the server must not default it.
+          ...(scriptMtime !== undefined ? { scriptMtime } : {}),
           ...(outcome
             ? {
                 submitted: outcome.submitted === true,

package/src/roles.ts

@@ -33,6 +33,10 @@ export function slugifyRole(role: unknown): string {
 
 export const GATE_RUNNER_ROLE_IDS = new Set(["qa", "quality", "coordinator", "gate"]);
 export const COORDINATOR_ROLE_IDS = new Set(["coordinator"]);
+// CI receives express-lane DONE: wake. Not a gate-runner — must not grant verdict.
+export const CI_ROLE_IDS = new Set(["ci"]);
+// Console / watchers. May send prefixed messages. Not a gate-runner.
+export const AUTOMATION_ROLE_IDS = new Set(["automation"]);
 
 export function resolveRole(role: RoleInput): ResolvedRole | undefined {
   if (role === null || role === undefined) return undefined;
@@ -70,6 +74,14 @@ export function isCoordinator(role: RoleInput): boolean {
   return roleMatches(role, COORDINATOR_ROLE_IDS);
 }
 
+export function isCi(role: RoleInput): boolean {
+  return roleMatches(role, CI_ROLE_IDS);
+}
+
+export function isAutomation(role: RoleInput): boolean {
+  return roleMatches(role, AUTOMATION_ROLE_IDS);
+}
+
 // Which roles may emit which record.type at the send path. Enforcement lives
 // in messaging.ts (checkRecordAuthority); the table lives here so register/join
 // can ECHO the consequence back at onboarding — a role that cannot emit `go`