agent-coord-mcp 0.25.4 → 0.25.5

package/dist/server.js

@@ -160,7 +160,7 @@ function buildServer(initialBound, opts = {}) {
     }
     const server = new McpServer({
         name: "agent-coord",
-        version: "0.25.4",
+        version: "0.25.5",
     });
     const addTool = (name, description, inputSchema, cb) => {
         server.registerTool(name, { description, inputSchema: z.object(inputSchema) }, async (args) => cb((args ?? {})));

package/hooks/submit.mjs

@@ -182,6 +182,20 @@ export function partitionStyledLine(styledLine) {
 // lesson is narrower than "test on a real TUI": a check that reads scrollback
 // has to be tested against a pane that HAS scrollback.
 //
+// Claude Code collapses a long bracketed paste into a chip in the input:
+//   ❯ [Pasted text #14 +9 lines]
+// That chip IS the landed paste — the full payload never appears as plain
+// text. Treating it as "not landed" was the intermittent Enter miss David hit:
+// landedInInput returned false → Enter was refused → chip sat forever. The
+// opposite failure (chip still sitting after Enter, verifier saying "gone"
+// because the payload string isn't in the chip label) is handled in
+// stillInInput below.
+export const PASTE_CHIP_RE = /\[Pasted text #\d+/i;
+
+export function isPasteChip(draft) {
+  return PASTE_CHIP_RE.test(String(draft ?? ""));
+}
+
 // Returns true = still waiting in the input, false = gone (submitted),
 // null = UNKNOWN. Unknown is never upgraded to a confirmation: no pane text,
 // or no line matching AGENT_COORD_PROMPT_PATTERN, means we cannot tell.
@@ -191,7 +205,12 @@ export function stillInInput(paneText, payload) {
   if (!needle) return false;
   const { draft } = readPaneState(paneText);
   if (draft === null) return null; // no recognizable input line — cannot tell
-  return squash(draft).includes(needle);
+  const d = squash(draft);
+  if (!d) return false;
+  // A paste chip still in the input means Enter did not submit — regardless
+  // of whether the full payload string is visible inside the chip label.
+  if (isPasteChip(d)) return true;
+  return d.includes(needle);
 }
 
 // Has the PASTED payload appeared in the input line yet? Distinct from
@@ -209,6 +228,8 @@ export function landedInInput(paneText, payload) {
   if (draft === null) return null;
   const d = squash(draft);
   if (!d) return false;
+  // Claude Code paste chip = landed (collapsed). See PASTE_CHIP_RE.
+  if (isPasteChip(d)) return true;
   if (d.includes(needle.slice(0, 32))) return true; // draft carries the payload head
   return needle.includes(d) && d.length >= 8; // visible draft is a genuine fragment of the payload
 }
@@ -336,12 +357,17 @@ export async function submitControl(deps, payload) {
 //   run(args) -> {status, stdout, stderr}      // spawnSync-shaped
 //   target, buffer                             // tmux -t target, buffer name
 //
-// Returns {submitted, verified, reason?, attempts}. For bracketed peer content
-// verification is skipped entirely (`verified:false`, `submitted:true`) — that
-// path pastes inert data on the hot path and has never been the problem; only
-// control commands are verified.
-export async function pasteAndSubmit(deps, payload, { bracketed = false, verify = false } = {}) {
+// Returns {submitted, verified, reason?, attempts}.
+//
+// Bracketed peer content verifies by DEFAULT. The old hot-path shortcut
+// (`verify:false` → fire-and-forget Enter) left Claude Code paste chips
+// (`[Pasted text #N +X lines]`) sitting unsubmitted whenever Enter was
+// dropped or refused — no retry, no receipt of failure. Control commands
+// already verified; peer traffic gets the same loop now. Pass
+// `verify:false` explicitly to opt out (unknown-TUI / test escape hatch).
+export async function pasteAndSubmit(deps, payload, { bracketed = false, verify } = {}) {
   const { run, runStdin, target, buffer } = deps;
+  const doVerify = verify === undefined ? bracketed : verify;
 
   await runStdin(["load-buffer", "-b", buffer, "-"], payload);
   const paste = run(["paste-buffer", ...(bracketed ? ["-p"] : []), "-b", buffer, "-t", target, "-d"]);
@@ -378,7 +404,7 @@ export async function pasteAndSubmit(deps, payload, { bracketed = false, verify
   await sleep(ENTER_GAP_MS());
   run(["send-keys", "-t", target, "Enter"]);
 
-  if (!verify) return { submitted: true, verified: false, attempts: 1 };
+  if (!doVerify) return { submitted: true, verified: false, attempts: 1 };
 
   const retries = ENTER_RETRIES();
   for (let attempt = 1; ; attempt++) {

package/hooks/tmux-pusher.mjs

@@ -428,8 +428,12 @@ async function injectViaTmux(batch) {
   let run = [];
   const flushRun = async () => {
     if (run.length === 0) return;
-    await pasteAndSubmit(formatBatch(run), true); // peer content: inert bracketed paste
-    writeReceipts(run); // stamp only AFTER the paste+submit resolves
+    // bracketed=true → submit.mjs verifies by default (paste-chip land + Enter retry).
+    const outcome = await pasteAndSubmit(formatBatch(run), true);
+    if (outcome && outcome.submitted === false) {
+      process.stderr.write(`[tmux-pusher] peer paste NOT submitted: ${outcome.reason}\n`);
+    }
+    writeReceipts(run, outcome); // stamp only AFTER the paste+submit resolves
     run = [];
   };
   for (const m of batch) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-coord-mcp",
-  "version": "0.25.4",
+  "version": "0.25.5",
   "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": {

package/scripts/check-test-count.mjs

@@ -22,7 +22,7 @@
 
 import { spawn } from "node:child_process";
 
-const EXPECTED_TESTS = 286;
+const EXPECTED_TESTS = 291;
 
 const expected = Number(process.env.AGENT_COORD_EXPECTED_TESTS ?? EXPECTED_TESTS);
 // Same glob the suite always used — `--test test/` would recurse differently

package/scripts/coord-pusher.mjs

@@ -300,8 +300,9 @@ async function injectViaTmux(batch) {
   let run = [];
   const flushRun = async () => {
     if (run.length === 0) return;
-    await pasteAndSubmit(formatBatch(run), true); // peer content: inert bracketed paste
-    await reportReceipts(run); // stamp only AFTER the paste+submit resolves
+    // bracketed=true → submit.mjs verifies by default (paste-chip land + Enter retry).
+    const outcome = await pasteAndSubmit(formatBatch(run), true);
+    await reportReceipts(run, outcome); // stamp only AFTER the paste+submit resolves
     run = [];
   };
   for (const m of batch) {
@@ -328,11 +329,9 @@ async function injectViaTmux(batch) {
 // Wire counterpart to tmux-pusher's writeReceipts: this pusher cannot append
 // to receipts/<id>.jsonl on the server's filesystem, so it reports each
 // delivery over MCP and the server writes the same receipt line the local
-// path does. `outcome` (control commands only) carries what submit
-// verification actually observed — submitted/verified/reason are forwarded
-// verbatim and OMITTED entirely for ordinary peer batches, because an absent
-// `submitted` means "typed but unverified" and must never be upgraded to a
-// claim of execution this pusher did not make.
+// path does. `outcome` carries what submit verification observed —
+// submitted/verified/reason are forwarded for both control commands and
+// (as of 0.25.5) bracketed peer pastes.
 //
 // Best-effort by design: a failed report must not break delivery or crash the
 // inject loop (the message IS in the pane by the time we get here). The

package/src/server.ts

@@ -241,7 +241,7 @@ function buildServer(initialBound?: string, opts: { trackSession?: boolean } = {
 
   const server = new McpServer({
     name: "agent-coord",
-    version: "0.25.4",
+    version: "0.25.5",
   });
 
   const addTool = (