agent-coord-mcp 0.26.15 → 0.26.17

package/hooks/replay.mjs

@@ -0,0 +1,107 @@
+/*
+ * IS THIS INSTRUCTION ARRIVING FOR THE FIRST TIME, OR AGAIN?
+ *
+ * Phase 5.3 Task 21.2 asks for a property and deliberately names no mechanism:
+ * A REPLAYED INSTRUCTION MUST BE DISTINGUISHABLE FROM A LIVE ONE IN THE PANE,
+ * WITHOUT RELYING ON ANY AGENT'S RETAINED CONTEXT.
+ *
+ * WHY RETAINED CONTEXT CANNOT BE THE ANSWER — this is the whole reason the task
+ * forbids it. DM delivery is at-least-once by design (losing a message is worse
+ * than repeating one), so a crash, SIGTERM or dead pane between paste and cursor
+ * commit REDELIVERS. Today the redelivered bytes are IDENTICAL to the original,
+ * so the only thing that has ever caught a duplicate is an agent recognising the
+ * instruction — and that memory is destroyed two ways:
+ *
+ *   /clear       at a VISIBLE moment, at a task boundary, by an operator
+ *   compaction   SILENTLY and CONTINUOUSLY, with no command and no moment
+ *                anyone notices
+ *
+ * The aide's framing, which is stronger than the one I brought: the second is
+ * the case that matters, because there is no point at which anyone knows the
+ * memory is gone. A control whose only failure mode is invisible is not a
+ * control. Both were hit twice in one reconnect.
+ *
+ * THE SIGNAL IS THE RECEIPT LOG, WHICH IS ALREADY ON DISK. Receipts are stamped
+ * AFTER the payload is typed into the pane and the push cursor advances only
+ * after that, so the redelivery window is EXACTLY the window in which a receipt
+ * exists and the cursor has not moved. The evidence of a prior delivery is
+ * therefore already written down, by construction, before the redelivery can
+ * happen — nothing new has to be recorded and no agent has to remember anything.
+ *
+ * WHAT THE ABSENCE OF A MARKER DOES NOT MEAN. `prune` deletes receipts (default
+ * 7 days), and a receipt file that has been swept cannot report the delivery it
+ * once held. So an unmarked line means "no earlier delivery IS RECORDED", never
+ * "this is provably the first". That gap is bounded and not load-bearing —
+ * redelivery follows the original by seconds to minutes, while the sweep cutoff
+ * is days — but it is stated here rather than left for a reader to assume
+ * totality, which is the recurring defect this phase exists to remove.
+ *
+ * ONE GRAMMAR, TWO PRODUCERS. The local pusher reads its own receipts file; the
+ * remote pusher cannot see the server's filesystem, so the server annotates the
+ * message instead (readMessagesTool). Those two compute the same DATA by
+ * different routes and both render it through `replayMarker` here, so the pane
+ * cannot receive two different vocabularies for one fact.
+ */
+
+/**
+ * Prior deliveries per message id, from the text of a receipts JSONL file.
+ *
+ * Takes TEXT rather than a path so the parsing is exercisable without a
+ * filesystem — the reason cursor IO was moved into push-cursor.mjs.
+ * Unparseable lines are skipped: a corrupt tail must not blind the whole log.
+ */
+export function priorDeliveries(text) {
+  const out = new Map();
+  for (const line of String(text ?? "").split("\n")) {
+    if (!line.trim()) continue;
+    let r;
+    try {
+      r = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!r || typeof r.id !== "string") continue;
+    const seen = out.get(r.id);
+    const ts = Number.isFinite(r.ts) ? r.ts : undefined;
+    if (!seen) out.set(r.id, { deliveries: 1, ...(ts !== undefined ? { firstAt: ts } : {}) });
+    else {
+      seen.deliveries += 1;
+      // The FIRST delivery is the useful one to name: it tells a reader how
+      // long ago the instruction they are looking at was already handled.
+      if (ts !== undefined && (seen.firstAt === undefined || ts < seen.firstAt)) seen.firstAt = ts;
+    }
+  }
+  return out;
+}
+
+/**
+ * The `replay` annotation for a message about to be pasted, or undefined when
+ * no earlier delivery is recorded.
+ *
+ * `deliveries` counts receipts ALREADY on disk, so the attempt number of the
+ * delivery being rendered is that plus one.
+ */
+export function replayInfo(prior, id) {
+  const seen = id ? prior?.get(id) : undefined;
+  if (!seen || !(seen.deliveries > 0)) return undefined;
+  return { attempt: seen.deliveries + 1, ...(seen.firstAt !== undefined ? { firstAt: seen.firstAt } : {}) };
+}
+
+/**
+ * The pane-visible marker for a replay, or "" for a first delivery.
+ *
+ * It says three things, and the third is the one that makes it a control rather
+ * than a label: THIS IS NOT THE FIRST TIME, WHEN THE FIRST TIME WAS, and WHAT TO
+ * DO ABOUT IT. A reader with no retained context cannot infer the third, and
+ * "you may ignore a duplicate, an executor may not" is exactly the case where
+ * guessing is expensive — re-running a merge or a push because the instruction
+ * arrived twice is the failure at-least-once delivery pays for.
+ */
+export function replayMarker(replay) {
+  if (!replay || !(replay.attempt > 1)) return "";
+  const at = Number.isFinite(replay.firstAt) ? new Date(replay.firstAt) : null;
+  const when = at
+    ? ` · first delivered ${String(at.getUTCHours()).padStart(2, "0")}:${String(at.getUTCMinutes()).padStart(2, "0")}Z`
+    : "";
+  return `⟲ REPLAY (delivery ${replay.attempt}${when}) — ALREADY DELIVERED BEFORE; check server truth before acting, do not re-run it · `;
+}

package/hooks/tier.mjs

@@ -10,6 +10,7 @@
 // by convention, and a lowercase lookalike is chatter, not a work order.
 
 import { isGateRunner } from "./roles.mjs";
+import { replayMarker } from "./replay.mjs";
 
 // Typed protocol record → tier (Phase 8). The prefix table below is the same
 // vocabulary parsed out of text; reading the field instead removes the parse
@@ -211,6 +212,16 @@ export function injectLine(m) {
     const held = text.split("\n").length - 1;
     text = `${text.slice(0, nl)} [+${held} lines · record:${m.record.type} · retrieve_message id=${m.id}]`;
   }
+  // Phase 5.3 Task 21.2 — A REPLAY IS MARKED IN THE PANE, so telling it from a
+  // live instruction needs no retained context. Applied LAST so the marker is
+  // the first thing after the attribution header even when the record digest
+  // above has already rewritten `text` — a warning below the fold is an absent
+  // warning, and this line is often long.
+  //
+  // The header stays byte-identical, so the parse contract holds: attribution
+  // is still `[tag HH:MM from] ` and the marker is part of the TEXT, which is
+  // correct — it is something the reader must see, not metadata about routing.
+  text = `${replayMarker(m.replay)}${text}`;
   return `  [${tag} ${hhmm} ${m.from}] ${text}`;
 }
 

package/hooks/tmux-pusher.mjs

@@ -102,6 +102,7 @@ import { effectiveTier, isGateRunnerRole, TierQueue, formatBatch } from "./tier.
 import { isCi } from "./roles.mjs";
 import { mergeTransportMarker } from "./marker.mjs";
 import { readPushCursor, writePushCursor } from "./push-cursor.mjs";
+import { priorDeliveries, replayInfo } from "./replay.mjs";
 import { pasteAndSubmit as sharedPasteAndSubmit, submitControl as sharedSubmitControl } from "./submit.mjs";
 
 const AGENT_ID = process.env.AGENT_COORD_ID;
@@ -583,6 +584,32 @@ async function injectViaTmux(batch) {
     );
     return [...batch];
   }
+  // Phase 5.3 Task 21.2 — STAMP THE REPLAY FACT BEFORE PASTING.
+  //
+  // Read once per inject, not per message: the receipt log is append-only and a
+  // single read is a consistent snapshot for the whole batch.
+  //
+  // WHY THIS FILE IS THE RIGHT PLACE, and why it can work at all: receipts are
+  // stamped AFTER a payload is typed (writeReceipts, below) and the push cursor
+  // advances only after the whole batch lands (commitOffsets, in flush). So a
+  // death anywhere in that window redelivers a message whose receipt is ALREADY
+  // on disk — the evidence exists before the duplicate can, without anyone
+  // having recorded anything for this purpose or remembered anything at all.
+  //
+  // Best-effort: an unreadable receipt log yields an empty map and therefore no
+  // markers, which is the honest direction. A missing marker means "no earlier
+  // delivery is RECORDED", never "this is provably the first" — see replay.mjs.
+  let prior = new Map();
+  try {
+    prior = priorDeliveries(readFileSync(RECEIPTS_FILE, "utf8"));
+  } catch {
+    // no receipts yet, or unreadable — every message renders as a first delivery
+  }
+  batch = batch.map((m) => {
+    const replay = replayInfo(prior, m?.id);
+    return replay ? { ...m, replay } : m;
+  });
+
   const undelivered = [];
   let run = [];
   const flushRun = async () => {

package/package.json

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

@@ -1,108 +1,169 @@
 #!/usr/bin/env node
-// Run the suite and assert it ran the number of tests we expect.
+// Run the suite and assert it ran the tests we expect — PER FILE.
 //
-// WHY: `npm test` was twice observed reporting FOUR fewer tests with zero
-// failures (119→115, 145→141), never reproducible on a re-run. A suite whose
-// count silently varies cannot be used as a gate signal — "all green" and "a
-// file failed to load" look identical. This is the same silent-undercount
-// class as a QUEUE parser returning zero items while passing every test.
+// WHY THE CHECK EXISTS AT ALL: `npm test` was observed reporting fewer tests
+// with zero failures (119→115, 145→141, 556/557), never reproducible on a
+// re-run. A suite whose count silently varies cannot be used as a gate signal —
+// "all green" and "a file failed to load" look identical. So the count is an
+// assertion, not a statistic, and a short run fails loudly.
 //
-// So the count is an assertion, not a statistic. A short run fails loudly.
+// It compares PASS, not `# tests`. The first version compared `# tests`, and the
+// sighting that followed showed why that was wrong: the runner reported
+// `# tests 186 / # pass 182 / # fail 0` — its own totals not adding up, four
+// results landing in no bucket at all. `# tests` read the full 186, so the guard
+// would have passed a run in which four results were lost. The anomaly is a
+// reporter gap, not a short run, and only the pass count sees it.
 //
-// It compares PASS, not `# tests`. The first version compared `# tests`, and
-// the sighting that followed showed why that was the wrong number: the runner
-// reported `# tests 186 / # pass 182 / # fail 0` — its own totals not adding
-// up, four results landing in no bucket at all. `# tests` read the full 186, so
-// the guard would have passed a run in which four results were lost. The
-// anomaly is a reporter gap, not a short run, and only the pass count sees it.
+// WHY THE EXPECTATION IS PER FILE (Phase 5.2 Task 16b.3):
 //
-// When you add or remove tests, update EXPECTED_TESTS in the same commit —
-// that is the point, not an inconvenience. `AGENT_COORD_EXPECTED_TESTS=n`
-// overrides for a one-off (bisecting, a partial run); `=0` disables the check.
-
-import { spawn } from "node:child_process";
+// It was ONE hand-maintained integer, and that integer conflicted on six
+// separate rebases in two days — every resolution the same mechanical act: read
+// main's number, add mine, verify. Worse than the tedium is how it PRESENTED:
+// GitHub schedules no checks for a `DIRTY` head, so a conflict in this file
+// looked like a CI outage, and a jam was filed over it.
+//
+// A per-file record fixes the conflict STRUCTURALLY rather than by being easier
+// to remember: two branches adding tests to different files touch different
+// lines, so they no longer collide at all. Only a branch that changes the SAME
+// test file conflicts, which is a real conflict about real content.
+//
+// AND IT IS A STRICTLY STRONGER ASSERTION, which is the part that mattered more
+// than the conflict. A global total masks compensation: a file that silently
+// loads ZERO tests passes the check as long as another file grew by the same
+// amount. That is precisely the silent-undercount class this script was written
+// for, and the global integer could not see it. Per file, it cannot hide.
+//
+// WHY NOT DERIVE THE EXPECTATION FROM THE RUN: because then a short run derives
+// its own smaller number and agrees with itself. The expectation has to come
+// from OUTSIDE the run — a committed record — or the guard asserts nothing. That
+// is also why a static count of `test(` declarations is not used: measured, it
+// reads 602 against a real 606, because some tests are declared in loops. An
+// inexact source cannot back an equality assertion.
+//
+// `AGENT_COORD_EXPECTED_TESTS=n` still overrides with a single global total for
+// a one-off (bisecting, a partial run); `=0` disables the check.
 
-const EXPECTED_TESTS = 602;
+import { run } from "node:test";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { glob } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 
-const expected = Number(process.env.AGENT_COORD_EXPECTED_TESTS ?? EXPECTED_TESTS);
-// Same glob the suite always used — `--test test/` would recurse differently
-// on some node versions, and a runner that selects a different set of files
-// is exactly the failure this script exists to catch.
-// Reporter pinned to TAP: newer Node defaults to the spec reporter even when
-// piped (and env like FORCE_COLOR can style its summary lines), so grepping
-// the summary was machine-dependent — it broke David's publish run 2026-08-20.
-// TAP is stable, uncolored, and the format the totals-check below was written
-// against.
-const child = spawn(process.execPath, ["--test", "--test-reporter=tap", "test/*.test.mjs"], {
-  stdio: ["inherit", "pipe", "inherit"],
-  shell: false,
-});
+const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const RECORD = path.join(pkgRoot, "test/expected-counts.json");
 
-let out = "";
-child.stdout.on("data", (chunk) => {
-  out += chunk;
-  process.stdout.write(chunk);
-});
+// Same glob the suite always used — `--test test/` would recurse differently on
+// some node versions, and a runner that selects a different set of files is
+// exactly the failure this script exists to catch.
+// `AGENT_COORD_CTC_GLOB` narrows the population for the guard's own tests, so a
+// case costs two files rather than all 68. A TEST SEAM and nothing else: the
+// default is unchanged, because a script that selects a different file set than
+// the suite is precisely the failure this one exists to catch.
+const GLOB = process.env.AGENT_COORD_CTC_GLOB ?? "test/*.test.mjs";
+const files = [];
+for await (const f of glob(GLOB, { cwd: pkgRoot })) files.push(f);
+files.sort();
 
-child.on("exit", (code, signal) => {
-  if (signal) process.exit(1);
-  // TAP is forced above, so `# pass N` is the contract; the `ℹ` alternative
-  // stays as a belt against a runner that ignores the flag.
-  const num = (label) => {
-    const m = out.match(new RegExp(`^(?:#|ℹ) ${label} (\\d+)\\s*$`, "m"));
-    return m ? Number(m[1]) : null;
-  };
-  const tests = num("tests");
-  const pass = num("pass");
-  const fail = num("fail");
-  // SKIPS AND TODOS ARE BUCKETS, and this gate could not represent them. A
-  // conditionally-skipped test made the totals disagree and the message blamed
-  // "a reporter gap" — a cause it had not established and which was wrong. It
-  // caught something real and explained it incorrectly, which is worse than
-  // silence because it sends the reader somewhere specific.
-  const skipped = num("skipped");
-  const todo = num("todo");
+const expected = JSON.parse(readFileSync(RECORD, "utf8"));
+const override = process.env.AGENT_COORD_EXPECTED_TESTS;
+const globalOverride = override === undefined ? null : Number(override);
 
-  if (code !== 0 || (fail ?? 0) > 0) process.exit(code || 1);
+const actual = new Map(files.map((f) => [f, 0]));
+const failures = [];
+let total = 0;
 
-  if (expected === 0) {
-    console.log(`[check-test-count] count assertion disabled (ran ${tests ?? "?"} tests)`);
-    process.exit(0);
+for await (const ev of run({ files: files.map((f) => path.join(pkgRoot, f)), concurrency: true })) {
+  const d = ev.data ?? {};
+  if (ev.type === "test:stderr" || ev.type === "test:stdout") {
+    process.stdout.write(String(d.message ?? ""));
+    continue;
   }
-  if (pass === null) {
-    console.error("[check-test-count] FAIL — no '# pass' summary line in the runner output");
-    process.exit(1);
+  if (d.nesting !== 0) continue;
+  if (ev.type === "test:fail") {
+    failures.push(`${rel(d.file)}: ${d.name}`);
+    continue;
   }
-  // The runner's own totals disagreeing is its own finding — report it as such
-  // rather than as a count mismatch, so nobody chases a missing test file.
-  if (tests !== null && tests !== pass + (fail ?? 0) + (skipped ?? 0) + (todo ?? 0)) {
-    console.error(
-      `\n[check-test-count] FAIL — the runner's totals do not add up: ` +
-        `${tests} tests = ${pass} pass + ${fail ?? 0} fail + ${skipped ?? 0} skip + ${todo ?? 0} todo leaves ` +
-        `${tests - pass - (fail ?? 0) - (skipped ?? 0) - (todo ?? 0)} result(s) in NO bucket.\n` +
-        `  The cause is NOT named here on purpose: a reporter gap and an unmodelled bucket look identical from these ` +
-        `numbers, and this message used to assert the first while the answer was the second.\n`,
-    );
+  if (ev.type !== "test:pass") continue;
+  total++;
+  const key = rel(d.file);
+  actual.set(key, (actual.get(key) ?? 0) + 1);
+}
+
+function rel(file) {
+  return file ? `test/${path.basename(file)}` : "(unattributed)";
+}
+
+if (failures.length) {
+  console.error(`[check-test-count] ${failures.length} test(s) FAILED — the count is not the story here:`);
+  for (const f of failures) console.error(`    ${f}`);
+  process.exit(1);
+}
+
+// `=0` disables; any other override asserts the old single global total.
+if (globalOverride === 0) {
+  console.log(`[check-test-count] disabled by AGENT_COORD_EXPECTED_TESTS=0 — ${total} test(s) passed, unchecked`);
+  process.exit(0);
+}
+if (globalOverride !== null && Number.isFinite(globalOverride)) {
+  if (total !== globalOverride) {
+    console.error(`[check-test-count] FAIL — ${total} tests passed, override expected ${globalOverride}.`);
     process.exit(1);
   }
-  if ((skipped ?? 0) > 0) {
-    // NAMED, ALWAYS. A skip that reconciles arithmetically is still a test that
-    // did not run, and the one that skipped here was the empirical control the
-    // whole change rested on — the suite reported 347 green around it.
-    console.error(
-      `\n[check-test-count] ${skipped} test(s) SKIPPED. A skip is not a pass: if a skipped test is the one that ` +
-        `establishes the claim under review, this run did not check it. Name it in the PR or make it runnable.\n`,
-    );
+  console.log(`[check-test-count] ${total} test(s) passed, matching the AGENT_COORD_EXPECTED_TESTS override`);
+  process.exit(0);
+}
+
+// ── the real comparison, per file ──────────────────────────────────────────
+const drifted = [];
+for (const f of files) {
+  const want = expected[f];
+  const got = actual.get(f) ?? 0;
+  if (want === undefined) {
+    drifted.push(`${f}: ran ${got} test(s) and is NOT in the record — a new test file must be recorded in the same commit`);
+  } else if (got !== want) {
+    drifted.push(`${f}: ran ${got}, record says ${want}`);
   }
-  if (pass !== expected) {
-    console.error(
-      `\n[check-test-count] FAIL — ${pass} tests passed, expected ${expected}.\n` +
-        (pass < expected
-          ? `  ${expected - pass} result(s) missing. Zero failures does NOT mean green here: a file that fails to load reports nothing.\n` +
-            `  Re-run; if the count is stable, a test file is missing or erroring at import.\n`
-          : `  ${pass - expected} test(s) were added. Update EXPECTED_TESTS in scripts/check-test-count.mjs in the same commit.\n`),
-    );
-    process.exit(1);
+}
+// A file in the record that no longer exists. Reported rather than ignored: a
+// deleted test file is a legitimate change and a RENAMED one is a silent loss of
+// coverage, and only the author can say which.
+// KEYED ON EXISTENCE, NOT ON SELECTION. A record entry outside a narrowed glob
+// was simply not selected, which is not drift; an entry naming a file that is
+// not THERE is drift under any population. The first version skipped this whole
+// branch under the test seam, which meant the seam disabled the check the seam
+// exists to exercise — the guard's own test caught it.
+for (const f of Object.keys(expected)) {
+  if (!existsSync(path.join(pkgRoot, f))) {
+    drifted.push(`${f}: in the record but no such file exists — deleted, or renamed and its coverage lost`);
+  } else if (files.includes(f) === false && GLOB === "test/*.test.mjs") {
+    drifted.push(`${f}: exists but did not run — the glob no longer selects it`);
   }
-  console.log(`[check-test-count] ${pass} tests passed, as expected.`);
-});
+}
+// An unattributed pass would make every per-file number meaningless.
+const unattributed = actual.get("(unattributed)") ?? 0;
+if (unattributed) drifted.push(`${unattributed} test(s) passed with no file attribution — the per-file record cannot be verified against this run`);
+
+if (!drifted.length) {
+  console.log(
+    `[check-test-count] ${total} test(s) across ${files.length} file(s), each matching its recorded count — ` +
+      `per FILE, so a file that silently loads zero cannot be masked by another that grew`,
+  );
+  process.exit(0);
+}
+
+if (process.argv.includes("--write")) {
+  const next = {};
+  for (const f of files) next[f] = actual.get(f) ?? 0;
+  writeFileSync(RECORD, `${JSON.stringify(next, null, 2)}\n`);
+  console.log(`[check-test-count] rewrote the record for ${files.length} file(s):`);
+  for (const d of drifted) console.log(`    ${d}`);
+  process.exit(0);
+}
+
+console.error(`[check-test-count] FAIL — the suite does not match its recorded per-file counts:`);
+for (const d of drifted) console.error(`    ${d}`);
+console.error(
+  `  Run \`node scripts/check-test-count.mjs --write\` to record the new counts IN THE SAME COMMIT — that is the point, not an inconvenience.\n` +
+    `  A drop with no test removed in the diff is the silent-undercount this check exists to catch: re-run before recording it.`,
+);
+process.exit(1);

package/scripts/coord-pusher.mjs

@@ -38,6 +38,8 @@
 import { hostname } from "node:os";
 import { spawn, spawnSync } from "node:child_process";
 import { pasteAndSubmit as sharedPasteAndSubmit, submitControl as sharedSubmitControl } from "../hooks/submit.mjs";
+// The pane's parse-contract line, single-sourced — see the note above formatBatch.
+import { injectLine } from "../hooks/tier.mjs";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
@@ -248,38 +250,20 @@ async function flush() {
   }
 }
 
-// The per-message PARSE CONTRACT line — MUST stay byte-identical to
-// hooks/tier.mjs's injectLine (agent harnesses parse from/room/text out of
-// it). Compact form (v0.14.0): `  [<tag> <HH:MM> <from>] <text>`, tag drops
-// the leading "room ", timestamp is HH:MM UTC, no "from=" label. This pusher
-// is standalone (may deploy without hooks/), so the helper is duplicated
-// rather than imported; test/tier.test.mjs locks both to the same shape.
-function injectLine(m) {
-  const tag = String(m.tag ?? "").replace(/^room /, "");
-  const d = new Date(m.ts ?? 0);
-  const hhmm = `${String(d.getUTCHours()).padStart(2, "0")}:${String(d.getUTCMinutes()).padStart(2, "0")}`;
-  let text = m.text ?? "";
-  // Phase 8 Task 6: a TYPED record whose rendering spans lines is delivered as
-  // ONE attributed line — first line, a count of what was withheld, and the
-  // message id as the retrieval handle. Continuation lines used to arrive bare,
-  // with no `[tag HH:MM from]` header, so a parser could not attribute them.
-  //
-  // The handle is the message id, NOT a stashed copy: the full record is
-  // already persisted in rooms/<chan>.jsonl or inbox/<id>.jsonl, and
-  // retrieve_message reads it back by id (falling through to the append-only
-  // archive if compaction moved it). A cache would have had a TTL and lost the
-  // record permanently on expiry.
-  //
-  // Gated on `m.record`: a record-LESS multi-line message is untouched and
-  // still arrives unattributed past line 1, exactly as today. Task 6 does not
-  // fix hand-typed multi-line messages, and must not change their bytes.
-  const nl = text.indexOf("\n");
-  if (nl !== -1 && m.record && typeof m.record.type === "string" && m.id) {
-    const held = text.split("\n").length - 1;
-    text = `${text.slice(0, nl)} [+${held} lines · record:${m.record.type} · retrieve_message id=${m.id}]`;
-  }
-  return `  [${tag} ${hhmm} ${m.from}] ${text}`;
-}
+// THE PER-MESSAGE PARSE CONTRACT LINE IS IMPORTED, NOT COPIED.
+//
+// This was a duplicate of hooks/tier.mjs's `injectLine`, kept "byte-identical"
+// by a comment and locked by nothing, on the rationale that this pusher is
+// standalone and "may deploy without hooks/". THAT RATIONALE IS ALREADY FALSE:
+// the file imports ../hooks/submit.mjs at the top, so it cannot run without
+// hooks/ today and has not been able to for several releases. A copy kept in
+// step by a comment is two grammars the moment one is fixed — the same argument
+// the seam's phase-citation grammar records, where a second copy would have
+// kept a fixed bug alive in the other package with nothing to find it.
+//
+// Deleting the copy is what makes Task 21.2 land in BOTH panes: the replay
+// marker had to be added once rather than twice-and-hopefully-identically.
+// (the import itself sits with the other imports at the top of the file)
 
 function formatBatch(batch) {
   const lines = ["[agent-coord] msgs (pre-consumed, don't re-read):"];