trantor 0.18.57 → 0.18.58

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.57",
+  "version": "0.18.58",
   "description": "Trantor — the hub-world for AI agent crews: live message bus, presence, project Kanban/flow board + crew orchestration for independent AI coding agents (Claude, Codex, Gemini, Kimi, DeepSeek)",
   "mcpServers": {
     "relay": {

package/bin/cli.mjs

@@ -33,6 +33,8 @@ switch (cmd) {
   case "agent-settings": run("bin/agent-settings.mjs"); break;
   case "adopt":   spawn(process.execPath, [join(ROOT, "bin/adopt.mjs"), ...args], { stdio: "inherit", cwd: process.cwd() }).on("exit", c => process.exit(c ?? 0)); break;
   case "integrate": spawn(process.execPath, [join(ROOT, "bin/integrate.mjs"), ...args], { stdio: "inherit", cwd: process.cwd() }).on("exit", c => process.exit(c ?? 0)); break;
+  case "harvest": run("bin/harvest.mjs"); break;
+  case "sync": run("bin/sync.mjs"); break;
   case "down":    runCrew(); break;
   case "swap":    runCrew(); break;
   case "prune":   runCrew(); break;
@@ -207,6 +209,8 @@ switch (cmd) {
   trantor adopt       take over a session already running in a Terminal, then open it here
   trantor takeover    the whole move in one command: idle-gate the Terminal session, end it gracefully, adopt, open in the pane — [--force] [--session <id>] [--dry-run]
   trantor integrate   collect the crew's work, merge it, verify it, push it (--dry-run to rehearse)
+  trantor harvest     receipt for a seat commit you landed on main by hand: harvest <seat-sha> <main-sha> [--card N]
+  trantor sync        realign a seat branch with main from the receipts: sync [<seat>] [--dry-run] — refuses and names unharvested commits
   trantor down        tear the crew down (kills processes, closes windows, no dialogs)
   trantor prune       drop dead crew-window tracking rows (ghost workspaces/panes) without spawning anything
   trantor ui          open the live dashboard (board + flow views)

package/bin/crew-runner.mjs

@@ -12,7 +12,7 @@ import { ensureEnrolled } from "../lib/enroll.mjs";
 import { redactKeys } from "../lib/redact.mjs";
 import {
   AUTH_MARKER_RE, classifyFailure, looksLikeAuthDeath,
-  verdictFor,
+  verdictFor, substantiveOutput,
   readPromptText, stripPromptEcho,
 } from "../lib/classify-failure.mjs";
 import { capWake, capBcast, pickLessons, composePrompt } from "./crew-payload.mjs";
@@ -284,7 +284,7 @@ if (!CLI[AGENT]) log(`'${AGENT}' is not a built-in seat — running it as an ope
 
 // RUNNER_RULES / RUNNER_KICKOFF env overrides: the runner is also the substrate for non-crew
 // always-on seats (the fleet DUTY agent, bin/duty.mjs) whose doctrine is not "work your card".
-const RULES = process.env.RUNNER_RULES || `Rules: you are ${SESSION} on the trantor crew. Before starting a card, read YOUR card: relay_board with card:<id> (the card, its deps, its notes, and the last five done cards whose title shares a word); never the whole board. Work your assigned file(s), report on the bus (relay_send, <280 chars), move your Kanban card as you go with a NOTE saying what you did (doing -> testing -> done; in 'testing' run YOUR OWN test file — never the full npm test, suites collide across seats — plus \`node bin/slop-gate.mjs\` when the repo has one: it lints ONLY your changed files against the anti-slop rules, and a card must not reach done with slop-gate failing; use 'failed' + a report if anything breaks). If you need something from another session, message THAT SESSION (relay_peers to find its id, relay_send to reach it) — never ask the human to pass it along; carrying messages between agents is the job this bus exists to remove. When your work for THIS message is finished, END YOUR TURN — do NOT park, do NOT loop relay_wait; the runner waits for you and will wake you with the next message. Path discipline: build/test from your worktree root ${TURN_DIR} with absolute paths or --manifest-path/--prefix instead of cd-ing into subdirs, and put anything that must land outside the repo under ${TURN_DIR}/.agent-bus-out/ (gitignored) — never ~/.agent-bus. Cross-project action is a breach: never \`trantor up\` a crew, register a seat, or send a card/contract into a project other than ${PROJ} unless the operator ran \`trantor policy link ${PROJ} <other> --reason "<why>"\` first — the hub, the CLI and this runner all refuse it mechanically, so ask the operator to link the projects instead of routing around the refusal.`;
+const RULES = process.env.RUNNER_RULES || `Rules: you are ${SESSION} on the trantor crew. Before starting a card, read YOUR card: relay_board with card:<id> (the card, its deps, its notes, and the last five done cards whose title shares a word); never the whole board. Work your assigned file(s), report on the bus (relay_send, <280 chars), move your Kanban card as you go with a NOTE saying what you did (doing -> testing -> done; in 'testing' run YOUR OWN test file — never the full npm test, suites collide across seats — plus \`node bin/slop-gate.mjs\` when the repo has one: it lints ONLY your changed files against the anti-slop rules, and a card must not reach done with slop-gate failing; use 'failed' + a report if anything breaks). If you need something from another session, message THAT SESSION (relay_peers to find its id, relay_send to reach it) — never ask the human to pass it along; carrying messages between agents is the job this bus exists to remove. When your work for THIS message is finished, END YOUR TURN — do NOT park, do NOT loop relay_wait; the runner waits for you and will wake you with the next message. Path discipline: build/test from your worktree root ${TURN_DIR} with absolute paths or --manifest-path/--prefix instead of cd-ing into subdirs, and put anything that must land outside the repo under ${TURN_DIR}/.agent-bus-out/ (gitignored) — never ~/.agent-bus. Realigning your seat branch after the orchestrator harvested your commits is \`trantor sync\` run from your worktree: it reads the harvest receipts and refuses when an unharvested commit would be lost, so never reset or rebase onto main by hand. Cross-project action is a breach: never \`trantor up\` a crew, register a seat, or send a card/contract into a project other than ${PROJ} unless the operator ran \`trantor policy link ${PROJ} <other> --reason "<why>"\` first — the hub, the CLI and this runner all refuse it mechanically, so ask the operator to link the projects instead of routing around the refusal.`;
 
 // ---- the pulse --------------------------------------------------------------
 // RUNNER_PULSE_MS re-runs an orchestrator seat's mission note on a cadence when the bus is silent;
@@ -305,6 +305,10 @@ let lastErrText = "";
 // burned its whole max_tokens budget on internal reasoning and returned a null completion; the
 // runner used to read that silence as a clean turn while nothing was produced.
 let lastEmptyOutput = false;
+// #7759: exit 0 with bytes on the stream but neither a changed worktree nor substantive output —
+// the CLI printed its banner and quit. The both-streams-silent rule above stays; this is the
+// second, harder-to-see empty shape.
+let lastEmptyTurn = false;
 const ERRF = join(homedir(), ".agent-bus", `err-${AGENT}-${PROJ}.txt`);
 const DUTY_NUDGES = process.env.RUNNER_DUTY_NUDGES === "1";
 const DUTY_NUDGE_STATE = process.env.RUNNER_DUTY_NUDGE_STATE
@@ -357,7 +361,7 @@ function loadPending() {
 // Auth failures in TURN OUTPUT: opencode prints its auth error and still exits 0 (#5405). The rules
 // live in lib/classify-failure.mjs (#5868); runTurn judges only the CLI's own output, not the echo.
 function classify(exit) {
-  const { reason, matched } = classifyFailure(exit, lastErrText, lastEmptyOutput);
+  const { reason, matched } = classifyFailure(exit, lastErrText, lastEmptyOutput, lastEmptyTurn);
   log(`classified ${reason} because ${matched}`);
   return reason;
 }
@@ -507,6 +511,20 @@ async function notifyAssigners(pairs, text) {
   if (seen.size) log(`reported outcome to ${[...seen].join(", ")}`);
 }
 
+// #7759: bus activity is work. The hub's unified log already records sends and card moves/notes
+// with the actor (`by`), and GET /events filters by it — so the runner can see, with no new
+// endpoint, that the seat answered on the bus even when it printed nothing and touched no file.
+// Fail-open: an unreachable or older hub yields "no activity", the pre-fix behaviour.
+async function latestBusEventId() {
+  try { const r = await api("/events?limit=1"); return Number(r?.latest) || 0; } catch { return 0; }
+}
+async function busActivitySince(seq) {
+  try {
+    const r = await api(`/events?by=${encodeURIComponent(SESSION)}&since=${seq}&limit=500`);
+    return Array.isArray(r?.events) && r.events.some(e => Number(e?.id) > seq);
+  } catch { return false; }
+}
+
 async function reportHealthy() {
   if (consecFails === 0) return;        // already healthy — don't spam
   consecFails = 0;
@@ -632,6 +650,12 @@ async function runTurn(prompt, isFirst, trigger = "kickoff", opts = {}) {
   // exit-0 turn with real output must never be re-labelled "auth" by the #5405 escalation — the
   // qwen specimen committed aa3c340 while its captured stream still tripped the auth regex.
   const headBefore = gitOut(["rev-parse", "HEAD"], TURN_DIR);
+  // #7759: the worktree snapshot the turn is judged against at its end — porcelain covers edits
+  // AND new untracked files, which a HEAD-only comparison misses.
+  const statusBefore = gitOut(["status", "--porcelain"], TURN_DIR);
+  // #7759: the bus event cursor the turn is judged against — anything the seat posts after this
+  // (relay_send, a card move or note) is bus activity, which counts as work.
+  const busSeqBefore = await latestBusEventId();
   // #6154: a pinned seat with no sid yet resumes as FRESH — the guard below fails open, because
   // a resume without an id must fall back to a new session, never to `next`'s bare resume shape.
   let cmd = (isFirst || ((cli.sid || cli.pinned) && !sid)) ? cli.first : cli.next;
@@ -786,9 +810,18 @@ exit $turn_exit`;
     lastEmptyOutput = true;
     log("\x1b[31mexit 0 but the turn produced NO output — treating as FAILED (empty-output)\x1b[0m");
   }
+  // #7759: the turn is HOLLOW when it exited 0 having neither changed the worktree (HEAD or
+  // porcelain vs the turn-start snapshot, untracked included), said anything beyond CLI chrome,
+  // nor posted to the bus. Computed LAST and only when the escalations above did not claim the
+  // turn: an auth death or a null completion is never re-labelled empty (#7759, #5405, #5481).
+  const worktreeChanged = newCommit || gitOut(["status", "--porcelain"], TURN_DIR) !== statusBefore;
+  const busActive = await busActivitySince(busSeqBefore);
+  lastEmptyTurn = !cut && realExit === 0 && effExit === 0 && !authHit && !opts.state
+    && !worktreeChanged && !busActive && !substantiveOutput(ownOut);
+  if (lastEmptyTurn) log("\x1b[33mexit 0 but the turn was EMPTY — no worktree change, no substantive output, no bus activity\x1b[0m");
   // #5868: the verdict rides the telemetry row so a classification survives the pane scrolling
   // away — the same "classified X because Y" shape the runner logs, in the seat's jsonl forever.
-  const verdict = verdictFor(realExit, effExit, lastEmptyOutput, ownOut);
+  const verdict = verdictFor(realExit, effExit, lastEmptyOutput, ownOut, lastEmptyTurn);
   // #6134: what the turn COST, from the CLI's own usage line. Zero means this CLI printed none —
   // never that the turn was free. `trantor seat-why` totals these into today's spend per seat.
   let tokens = parseTurnTokens(ownOut);
@@ -801,8 +834,8 @@ exit $turn_exit`;
   // #6289: every ledger row names in ONE field what happened to the turn — cut (the box ended it),
   // api-error (the CLI failed), completed — and what it cost in tokens, even when this CLI printed
   // no usage line (0 means "not reported", never "free"). `cut` stays too: the drills read it.
-  const outcome = cut ? "cut" : (effExit !== 0 ? "api-error" : "completed");
-  const telemetryRow = { ts: Date.now(), agent: AGENT, project: PROJ, turn: TURN, trigger, model: MODEL || "cli-default", duration_ms: Date.now() - t0, exit: realExit, effExit, authFailed: effExit !== realExit, emptyOutput: lastEmptyOutput, verdict, outcome, tokens };
+  const outcome = cut ? "cut" : (effExit !== 0 ? "api-error" : lastEmptyTurn ? "empty" : "completed");
+  const telemetryRow = { ts: Date.now(), agent: AGENT, project: PROJ, turn: TURN, trigger, model: MODEL || "cli-default", duration_ms: Date.now() - t0, exit: realExit, effExit, authFailed: effExit !== realExit, emptyOutput: lastEmptyOutput, emptyTurn: lastEmptyTurn, verdict, outcome, tokens };
   if (cut) telemetryRow.cut = true;
   telemetry(telemetryRow);
   log(`turn ended (exit ${realExit}${effExit !== realExit ? ` → effective ${effExit} (${lastEmptyOutput ? "empty-output" : "auth"})` : ""}, ${((Date.now() - t0) / 1000).toFixed(0)}s)`);
@@ -944,16 +977,6 @@ function isContract(message) {
   return message?.kind === "contract" || /^\s*contract\s*:/i.test(text) || CARD_REF_RE.test(text);
 }
 
-function isRunnerSession(session) {
-  const suffix = `:${PROJ}`;
-  const name = String(session || "");
-  if (!name.endsWith(suffix)) return false;
-  const label = name.slice(0, -suffix.length);
-  // Crew labels are CLI/provider slugs. Host sessions keep their machine-style identity and remain
-  // valid direct assigners; runner-to-runner prose needs `contract:` or a card reference.
-  return /^[a-z0-9_.-]+$/.test(label) && !label.startsWith("hub:");
-}
-
 // A hub staleness alert describes a moment, so it EXPIRES; a peer's message never does, because a
 // seat missing a teammate's request is the failure this bus exists to prevent.
 const HUB_ALERT_TTL_MS = Number(process.env.TRANTOR_HUB_ALERT_TTL_MS || 30 * 60_000);
@@ -969,12 +992,12 @@ function shouldWake(message) {
   // into the next turn's prompt like a broadcast and never buys a CLI session of its own.
   if (message?.wake === false) return false;
   if (message?.to === SESSION) {
+    // #7766: with wake unset or true the sender's flag IS the decision. No keyword, card or
+    // sender-shape heuristic on the body second-guesses a direct message any more, so a plain
+    // question buys its turn. kind:status stays chatter; what is still demoted tells the sender
+    // (see the demotion notice at the wake split).
     if (message?.kind === "status") return false;
-    // Safety net for senders that never set the flag: a direct message carrying no card and no
-    // instruction is context. Typed alerts and overseer warnings still wake (#5760).
-    const typed = message?.kind === "alert" || /^🤝 OVERSEER /.test(String(message?.text || ""));
-    if (!typed && !isContract(message) && !carriesWork(message?.text)) return false;
-    return !isRunnerSession(message?.from) || isContract(message);
+    return true;
   }
   return message?.to === "all"
     && isContract(message)
@@ -1106,6 +1129,20 @@ function askedExcerpt(message) {
     const rest = msgs.filter(m => !fyi.includes(m));
     const direct = rest.filter(m => m.to === SESSION && shouldWake(m));
     const mentions = rest.filter(m => m.to === "all" && shouldWake(m));
+    // #7766: a direct message that is STILL demoted to context tells its SENDER in one line, so a
+    // dropped ask is visible instead of looking like a dead seat. Two demotions stay silent: the
+    // sender's own wake:false, and kind:status chatter — this notice is itself kind status, so
+    // answering one would loop. What remains today is the expired hub alert.
+    const demotedSenders = new Set();
+    for (const m of rest) {
+      if (m.to !== SESSION || direct.includes(m) || m.wake === false || m.kind === "status") continue;
+      const who = String(m.from || "");
+      if (!who || who === SESSION || demotedSenders.has(who)) continue;
+      demotedSenders.add(who);
+      log(`\x1b[33mdirect message demoted to context\x1b[0m — telling ${who}`);
+      api("/send", { from: SESSION, to: who, project: senderProjectOf(who) || PROJ, kind: "status",
+        text: `ℹ️ ${SESSION} did not turn on your direct message — demoted to context: "${askedExcerpt(m)}". Re-send citing a card if it still needs a turn` }).catch(() => {});
+    }
     // #6134: messages that do not earn a turn still become context, including direct acks.
     // #7430: stale hub alerts are shed HERE too, not only at boot — one that arrives already past
     // its TTL must not sit in every prompt until the next successful turn clears the batch.
@@ -1313,6 +1350,24 @@ function askedExcerpt(message) {
       await notifyAssigners(assigners,
         `⚠️ your contract FAILED on ${SESSION} (exit ${ec}, ${reason}) · retrying in ${Math.round(wait / 1000)}s · asked: "${asked}"`);
       log(`\x1b[31m${pendingWake.length} message(s) still UNDELIVERED — next attempt in ${Math.round(wait / 1000)}s\x1b[0m`);
+    } else if (lastEmptyTurn) {
+      // #7759: the turn exited 0 but was HOLLOW — a banner is not work. The wake is NOT
+      // consumed: the queue is kept and the ladder retries, and the assigner hears EMPTY,
+      // never "done". Second hollow attempt in a row parks the seat, like a failed turn.
+      deliveryFails++;
+      savePending(pendingWake, pendingBcast);
+      if (deliveryFails >= 2) {
+        retryAt = await parkSeat("empty-turn", pendingWake.length);
+        await notifyAssigners(assigners,
+          `⛔ your contract is PARKED on ${SESSION} (empty-turn: two exit-0 turns with no worktree change, substantive output or bus activity) · asked: "${asked}"`);
+        lastTurnAt = Date.now();
+        return;
+      }
+      const wait = RETRY_MS[Math.min(deliveryFails - 1, RETRY_MS.length - 1)];
+      retryAt = Date.now() + wait;
+      log(`\x1b[33mturn was EMPTY — wake not consumed, ${pendingWake.length} message(s) stay owed; retrying in ${Math.round(wait / 1000)}s\x1b[0m`);
+      await notifyAssigners(assigners,
+        `🫥 EMPTY turn on ${SESSION} (exit 0, ${secs}s — no worktree change, no substantive output, no bus activity) · wake stays owed · retrying in ${Math.round(wait / 1000)}s · asked: "${asked}"`);
     } else {
       pendingWake = []; pendingBcast = []; deliveryFails = 0; retryAt = 0;
       savePending([], []);

package/bin/harvest.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// `trantor harvest <seat-sha> <main-sha> [--card N]` (#7748): the receipt for a hand-made cherry-pick
+// or squash. The receipt is what lets `trantor sync` realign the seat branch later.
+import { resolveProject, hostId } from "../lib/project.mjs";
+import { recordHarvest, receiptsPath, run } from "../lib/harvest.mjs";
+import { signedPost } from "../hooks/lib/api.mjs";
+
+const args = process.argv.slice(2);
+const flag = (name) => { const i = args.indexOf(`--${name}`); return i >= 0 ? args[i + 1] : ""; };
+const positional = args.filter((a, i) => !a.startsWith("--") && !(i > 0 && args[i - 1].startsWith("--") && !args[i - 1].startsWith("--no-")));
+const [seatArg, mainArg] = positional;
+if (!seatArg || !mainArg || args.includes("--help")) {
+  console.error("usage: trantor harvest <seat-sha> <main-sha> [--card N] [--seat <agent>] [--project <p>] [--no-note]");
+  process.exit(seatArg && mainArg ? 0 : 1);
+}
+
+const repo = process.cwd();
+const project = flag("project") || resolveProject(repo);
+const resolve = (s) => run(repo, ["rev-parse", "--verify", "-q", `${s}^{commit}`]).out || String(s).trim();
+const seat = resolve(seatArg), main = resolve(mainArg);
+if (!run(repo, ["rev-parse", "--verify", "-q", `${mainArg}^{commit}`]).ok) {
+  console.error(`harvest: ${mainArg} is not a commit in ${repo}`);
+  process.exit(1);
+}
+let branch = flag("seat") ? `seat/${flag("seat")}` : "";
+if (!branch) {
+  const holders = run(repo, ["branch", "--list", "seat/*", "--contains", seat, "--format=%(refname:short)"]).out;
+  branch = holders.split("\n").filter(Boolean)[0] || "";
+}
+
+let receipt;
+try { receipt = recordHarvest(project, { seat, main, card: flag("card"), branch, by: "harvest" }); }
+catch (e) { console.error(`harvest: ${e.message}`); process.exit(1); }
+const line = `harvested ${receipt.seat.slice(0, 7)} as ${receipt.main.slice(0, 7)}`;
+console.log(`${line}${branch ? ` (${branch})` : ""}${receipt.card ? ` · card #${receipt.card}` : ""} → ${receiptsPath(project)}`);
+
+if (receipt.card && !args.includes("--no-note")) {
+  const me = `${hostId()}:${project}`;
+  const r = await signedPost("/task/update", { id: receipt.card, note: line, by: me, project }, { session: me, project });
+  if (r.ok) console.log(`card #${receipt.card} noted: ${line}`);
+  else console.error(`warning: card #${receipt.card} not noted (${r.status || r.reason || "hub unreachable"}); the receipt is recorded`);
+}

package/bin/integrate.mjs

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 // `trantor integrate` — collect the crew's work, prove it, ship it.
-//
 // The steps are the ones the orchestrator already performs by hand. The dials decide how far it is
 // allowed to go on its own, and every stop says which dial stopped it, so "why didn't it push"
 // always has an answer.
 import { resolveProject } from "../lib/project.mjs";
 import { resolveAutonomy } from "../lib/autonomy.mjs";
 import { seatWorktrees, commitSeatWork, seatAhead, mergeSeat, verify, git } from "../lib/integrate.mjs";
+import { recordHarvest } from "../lib/harvest.mjs";
 
 const D = "\x1b[2m", B = "\x1b[1m", G = "\x1b[32m", Y = "\x1b[33m", RED = "\x1b[31m", R = "\x1b[0m";
 const args = process.argv.slice(2);
@@ -53,7 +53,14 @@ for (const w of seats) {
     blocked = true;
     continue;
   }
-  if (m.merged) { console.log(`  ${G}merged ${branch} (${ahead} commit(s))${R}`); merged.push(branch); }
+  if (m.merged) {
+    console.log(`  ${G}merged ${branch} (${ahead} commit(s))${R}`);
+    merged.push(branch);
+    // #7748: the receipt `trantor sync` reads later; a merge keeps the seat shas, so this one is
+    // the seat tip -> the merge commit.
+    try { recordHarvest(project, { seat: git(w.dir, ["rev-parse", branch]), main: git(repo, ["rev-parse", "HEAD"]), branch, by: "integrate" }); }
+    catch (e) { console.log(`  ${Y}${branch}: receipt not written (${e.message})${R}`); }
+  }
 }
 
 if (blocked) {

package/bin/sync.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+// `trantor sync [<seat>]` (#7748): realign a seat branch with main from the harvest receipts.
+// Every commit main lacks must carry a receipt; otherwise the sync refuses and names them.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { resolveProject, busDir } from "../lib/project.mjs";
+import { syncSeat, receiptsPath } from "../lib/harvest.mjs";
+
+const D = "\x1b[2m", G = "\x1b[32m", Y = "\x1b[33m", RED = "\x1b[31m", R = "\x1b[0m";
+const args = process.argv.slice(2);
+const flag = (name) => { const i = args.indexOf(`--${name}`); return i >= 0 ? args[i + 1] : ""; };
+const seat = args.find((a, i) => !a.startsWith("--") && !(i > 0 && args[i - 1] === "--project"));
+if (args.includes("--help")) {
+  console.log("usage: trantor sync [<seat>] [--project <p>] [--dry-run] [--no-fetch]   (no seat: the worktree you are in)");
+  process.exit(0);
+}
+
+const project = flag("project") || resolveProject(process.cwd());
+const dir = seat ? join(busDir(), "worktrees", project, seat) : process.cwd();
+if (seat && !existsSync(join(dir, ".git"))) {
+  console.error(`sync: no worktree for seat '${seat}' at ${dir}`);
+  process.exit(1);
+}
+
+const r = syncSeat(dir, { dryRun: args.includes("--dry-run"), fetch: !args.includes("--no-fetch"), project });
+const short = (s) => String(s || "").slice(0, 7);
+if (r.refused) {
+  console.log(`${RED}sync refused${R} · ${r.branch} carries ${r.unharvested.length} commit(s) ${r.target.ref} does not, with no harvest receipt:`);
+  for (const c of r.unharvested) console.log(`  ${short(c.sha)}  ${c.subject}`);
+  if (r.harvested.length) console.log(`${D}${r.harvested.length} other commit(s) are receipted and would be dropped once these are.${R}`);
+  console.log(`${D}Harvest them (trantor harvest <seat-sha> <main-sha> --card N) or park them on another branch first. Receipts: ${receiptsPath(project)}${R}`);
+  process.exit(1);
+}
+if (!r.ok) { console.error(`${RED}sync failed${R}: ${r.reason}`); process.exit(1); }
+if (r.noop) { console.log(`${D}${r.branch} already at ${r.target.ref} (${short(r.head)})${R}`); process.exit(0); }
+const dropped = r.harvested.map(c => `${short(c.sha)}→${short(c.receipt.main)}`).join(", ");
+if (r.dry) {
+  console.log(`${Y}[dry]${R} would move ${r.branch} ${short(r.head)} → ${r.target.ref} ${short(r.target.sha)}${dropped ? ` ${D}(receipted: ${dropped})${R}` : ""}`);
+  process.exit(0);
+}
+console.log(`${G}synced${R} ${r.branch} ${short(r.from)} → ${r.target.ref} ${short(r.to)}${dropped ? ` ${D}(receipted: ${dropped})${R}` : ""}`);

package/hooks/lib/api.mjs

@@ -10,6 +10,7 @@ import { loadOrCreate, loadOrCreateInstance } from "../../lib/identity.mjs";
 import { sfetchJson } from "../../lib/signed-fetch.mjs";
 
 export const DEFAULT_TIMEOUT_MS = 1500;
+export const WRITE_TIMEOUT_MS = 8000;   // #7755: writes get their own budget above the read default
 
 // Hub URL, PER-PROJECT (TDD §12.1): env RELAY_URL, then config `hubs[project]`, then the legacy global
 // `url`, then the local default. Never throws, keeping hooks fail-open.
@@ -175,12 +176,25 @@ export async function signedGet(pathOrUrl, { timeoutMs = DEFAULT_TIMEOUT_MS, ses
 }
 
 // Signed POST → { ok, status, json|null }. Never throws.
-export async function signedPost(pathOrUrl, payload, { timeoutMs = DEFAULT_TIMEOUT_MS, session, instance, project } = {}) {
+// #7755: writes keep their own timeout, and a write carrying `_op` resolves a timeout through
+// one GET /_op — committed returns the stored body as success, rejected returns the stored refusal,
+// unknown reads "ambiguous: timed out, outcome unknown". Never a bare failure for a write that landed.
+export async function signedPost(pathOrUrl, payload, { timeoutMs = WRITE_TIMEOUT_MS, session, instance, project } = {}) {
   const proj = projectOf(project, payload, pathOrUrl);
   const sess = session || sessionFor(proj);
   const durable = loadIdentity(sess);
   const id = instance ? loadInstance(sess, instance) : durable;
   await ensureEnrolled(sess, durable, proj);     // instances never enroll — the DURABLE key does
+  const resolveOp = async (f) => {
+    const op = String(payload?._op || "");
+    if (!f.timedOut || !op) return f;
+    const base = new URL(toUrl(pathOrUrl, proj)).origin;
+    const q = await signedGet(`${base}/_op?id=${encodeURIComponent(op)}`, { session: sess, instance, project: proj });
+    const st = q.ok ? q.json?.status : "unknown";
+    if (st === "committed") return { ok: true, status: q.json.code || 200, json: q.json.body, resolved: "committed" };
+    if (st === "rejected") return { ok: false, status: q.json.code || 400, json: q.json.body, resolved: "rejected" };
+    return { ...f, ambiguous: true, reason: "ambiguous: timed out, outcome unknown" };
+  };
   try {
     // sfetchJson (FROZEN) stringifies the payload + signs with `id` in one call — the single shape
     // every client uses (lib/signed-fetch.mjs). We pass our memoised identity so it doesn't re-load.
@@ -200,5 +214,5 @@ export async function signedPost(pathOrUrl, payload, { timeoutMs = DEFAULT_TIMEO
     const text = await r.text();
     let json = null; try { json = text ? JSON.parse(text) : null; } catch {}
     return { ok: true, status: r.status, json };
-  } catch (e) { return failure(e, timeoutMs); }
+  } catch (e) { return resolveOp(failure(e, timeoutMs)); }
 }

package/hooks/lib/hollow-move.mjs

@@ -0,0 +1,53 @@
+// #7750 — seat-side hollow-move check: the hub is remote and cannot see a seat's worktree, so on
+// a move to testing/done mcp.mjs diffs the worktree against the sha recorded at `doing`, reads
+// checklist ticks and scans the note for a test command. All missing + no declared no-code
+// outcome → the move still lands, note prefixed HOLLOW:, assigner told on the bus.
+import { execFileSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+// A "test command" is a command shape or a pass count — the note contract already demands both.
+const TEST_CMD_RE = /(node\s+test\/|npm\s+(run\s+)?test|pnpm\s+test|yarn\s+test|vitest|pytest|go\s+test|cargo\s+test|make\s+test|\b\d+\s*\/\s*\d+\b|\b\d+\s+passed\b)/i;
+// Declared no-code outcomes (#7750: docs, investigation, refusal, answered on the bus) — a card
+// that says one of these is NEVER flagged, however empty its worktree is.
+const NOCODE_RE = /\b(no[- ]code|docs?[- ]only|investigat\w*|read[- ]only|research[- ]only|analysis[- ]only|answered (on|in) the bus|refus\w+|declin\w+|won'?t fix)\b/i;
+
+export const hasTestCommand = (note) => TEST_CMD_RE.test(String(note || ""));
+export const declaresNoCode = (note) => NOCODE_RE.test(String(note || ""));
+
+function git(cwd, args) {
+  return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+}
+
+// Per-worktree, keyed by card id: <git-dir> is the worktree's OWN dir under a linked worktree
+// (…/.git/worktrees/<seat>), so seats never share each other's bases.
+const basePath = (cwd) => join(git(cwd, ["rev-parse", "--git-dir"]), "hollow-base.json");
+
+// Snapshot HEAD when a card is taken (doing); the testing/done check diffs against this sha.
+export function markDoing(cwd, id) {
+  try {
+    const p = basePath(cwd);
+    let map = {};
+    try { map = JSON.parse(readFileSync(p, "utf8")); } catch { /* first card in this worktree */ }
+    map[id] = git(cwd, ["rev-parse", "HEAD"]);
+    writeFileSync(p, JSON.stringify(map));
+  } catch { /* not a git worktree — no base recorded, and hollowVerdict fails open */ }
+}
+
+// Verdict for a testing/done move. checked:false = no usable base (pre-#7750 card, non-git cwd,
+// base sha lost to a rebase) — fail open rather than flag on a base we cannot trust.
+export function hollowVerdict(cwd, id, note, checklist) {
+  let base;
+  try { base = JSON.parse(readFileSync(basePath(cwd), "utf8"))[id]; } catch { return { checked: false, hollow: false, missing: [] }; }
+  if (!base) return { checked: false, hollow: false, missing: [] };
+  const missing = [];
+  try {
+    // `git diff <base>` covers committed AND uncommitted tracked changes vs the taken-sha.
+    if (!git(cwd, ["diff", "--name-only", base, "--"])) missing.push("diff");
+    if (!git(cwd, ["ls-files", "--others", "--exclude-standard"])) missing.push("new files");
+  } catch { return { checked: false, hollow: false, missing: [] }; }
+  if (!(checklist || []).some((c) => c.done)) missing.push("ticked checklist items");
+  if (!hasTestCommand(note)) missing.push("test command in the note");
+  const hollow = missing.length === 4 && !declaresNoCode(note);
+  return { checked: true, hollow, missing };
+}

package/hub.mjs

@@ -88,6 +88,28 @@ const overseer = createOverseer({
 });
 store.startChangeSubscription(() => events.pushEventToStreams({ ts: Date.now(), type: "hub.reload", project: "", by: "" }));
 
+// #7755: a write carrying `_op` replays its stored outcome on a retry, and GET /_op answers
+// committed / rejected / unknown, so a client timeout never has to guess whether the write landed.
+const opOutcomes = new Map();
+const OP_OUTCOME_WINDOW_MS = 3600000;
+setInterval(() => {
+  const cutoff = Date.now() - OP_OUTCOME_WINDOW_MS;
+  for (const [id, o] of opOutcomes) { if (o.ts < cutoff) opOutcomes.delete(id); }
+}, 60000).unref?.();
+const opIdOf = (b) => String(b?._op || "").slice(0, 80) || null;
+// Only a definite answer is stored: 2xx is committed, 4xx is rejected, a 5xx stays unknown.
+function recordOpOutcome(res, op) {
+  const end = res.end.bind(res);
+  res.end = (chunk, ...rest) => {
+    const code = res.statusCode;
+    if (code < 500 && !opOutcomes.has(op)) {
+      let body = null; try { body = chunk ? JSON.parse(String(chunk)) : null; } catch {}
+      opOutcomes.set(op, { ts: Date.now(), code, status: code < 400 ? "committed" : "rejected", body });
+    }
+    return end(chunk, ...rest);
+  };
+}
+
 let UI = "";
 try { UI = readFileSync(new URL("./ui.html", import.meta.url), "utf8"); } catch {}
 const context = {
@@ -111,6 +133,14 @@ const server = http.createServer(async (req, res) => {
     if (!auth.ok) return authRuntime.json(res, auth.code || 401, { error: auth.error || "unauthorized" });
     const authorization = authRuntime.authorize(auth, req.method, P, authRuntime.projectFromRequest(P, q, b0));
     if (!authorization.ok) return authRuntime.json(res, authorization.code || 403, { error: authorization.error || "forbidden" });
+    if (req.method === "GET" && P === "/_op") {
+      const o = opOutcomes.get(String(q.id || "").slice(0, 80));
+      return authRuntime.json(res, 200, o ? { status: o.status, code: o.code, body: o.body } : { status: "unknown" });
+    }
+    const op = req.method === "POST" ? opIdOf(b0) : null;
+    const seen = op ? opOutcomes.get(op) : null;
+    if (seen) return authRuntime.json(res, seen.code, seen.body);
+    if (op) recordOpOutcome(res, op);
     for (const route of routes) if (await route({ req, res, q, P, auth, ctx: context })) return;
     authRuntime.json(res, 404, { error: "not found" });
   } catch (error) {

package/lib/classify-failure.mjs

@@ -37,6 +37,24 @@ export function stripPromptEcho(errText, promptText) {
  *  printed its whole failure in under a hundred characters and produced nothing else. */
 export const OWN_OUTPUT_ANSWER_MIN = 400;
 
+// ---- the hollow turn (#7759): exit 0, no worktree change, no substantive output ---------------
+// A CLI banner is bytes on a stream, not work. ANSI stripped, a line is CHROME when it is a pure
+// separator, decorative box/block art, or a label a CLI prints about itself (session, model,
+// provider, workdir, version, tokens) — metadata about the run, never the run's answer.
+const BANNER_RE = /[\u2500-\u257F\u2580-\u259F\u25A0-\u25FF]/;
+const SEPARATOR_RE = /^[-=*_~.#]{3,}$/;
+const CHROME_LABEL_RE = /^(?:session|model|provider|workdir|directory|version|tokens|thinking|truncating|truncated|hint|tip|ctrl|openai|opencode|codex|claude|gemini|kimi|deepseek|glm|qwen|dsh)\b/i;
+export const SUBSTANTIVE_MIN = 120;
+
+/** Whether the CLI's echo-stripped output carries anything beyond banner and hook noise: the
+ *  surviving signal lines must total at least SUBSTANTIVE_MIN chars — a sentence or two. A real
+ *  answer clears this easily; a banner contributes nothing once its chrome is dropped (#7759). */
+export function substantiveOutput(ownText) {
+  const lines = String(ownText || "").replace(/\x1b\[[0-9;]*[A-Za-z]/g, "").split("\n").map(l => l.trim()).filter(Boolean);
+  const signal = lines.filter(l => !BANNER_RE.test(l) && !SEPARATOR_RE.test(l) && !CHROME_LABEL_RE.test(l));
+  return signal.join("\n").length >= SUBSTANTIVE_MIN;
+}
+
 /** The #5405 rule, refined twice by #5868: exit 0 + an auth-shaped marker means FAILED only when
  *  the CLI's own output is short enough to be JUST the error — and NEVER when the turn did real
  *  work (newCommit, checked by the runner via git): a shipped commit is a live turn, whatever the
@@ -49,20 +67,22 @@ export function looksLikeAuthDeath(ownText, realWork = false) {
 /** The one-line verdict the seat's jsonl carries (#5868): why the runner judged the turn the way
  *  it did, phrased exactly like the runner's own "classified X because Y" log — so a pane that
  *  scrolls away loses nothing that the telemetry row needs to say. */
-export function verdictFor(realExit, effExit, emptyOutput, ownText) {
-  if (realExit === 0 && effExit === 0) return "classified success because exit 0 with CLI output";
+export function verdictFor(realExit, effExit, emptyOutput, ownText, emptyTurn = false) {
+  if (realExit === 0 && effExit === 0) return emptyTurn
+    ? "classified empty-turn because exit 0 with no worktree change, no substantive output, no bus activity"
+    : "classified success because exit 0 with CLI output";
   if (realExit === 0 && effExit === 1) {
     if (emptyOutput) return "classified empty-output because exit 0 with no output on either stream";
     const m = AUTH_MARKER_RE.exec(String(ownText || ""));
     return `classified auth because ${m ? m[0] : "auth marker"} in the CLI's own short output`;
   }
-  const { reason, matched } = classifyFailure(realExit, String(ownText || ""), emptyOutput);
+  const { reason, matched } = classifyFailure(realExit, String(ownText || ""), emptyOutput, emptyTurn);
   return `classified ${reason} because ${matched}`;
 }
 
 /** Classify one failed turn. Returns { reason, matched } — matched is the evidence excerpt the
  *  runner logs, so the next misclassification is diagnosable from the seat log alone. */
-export function classifyFailure(exit, errText, emptyOutput = false) {
+export function classifyFailure(exit, errText, emptyOutput = false, emptyTurn = false) {
   // #5481: silence with a clean exit is a failure shape, not success — see lastEmptyOutput.
   if (emptyOutput) return { reason: "empty-output", matched: "exit 0 with no output on either stream" };
   const t = String(errText || "").toLowerCase();
@@ -79,6 +99,10 @@ export function classifyFailure(exit, errText, emptyOutput = false) {
   if (m) return { reason: "exhausted", matched: m[0] };
   m = t.match(/unauthor|401|invalid[ _-]?api[ _-]?key|forbidden|403|token expired|expired/);
   if (m) return { reason: "auth", matched: m[0] };
+  // #7759: exit 0 with bytes on the stream but neither a changed worktree nor substantive output
+  // is a HOLLOW turn — the CLI printed its banner and quit. It ranks BELOW every real failure
+  // shape above: an auth-shaped or exhausted exit is that failure, never an empty turn.
+  if (emptyTurn) return { reason: "empty-turn", matched: "exit 0 with no worktree change, no substantive output, no bus activity" };
   return { reason: "crashed", matched: `exit ${exit} with no known failure pattern` };
 }
 

package/lib/harvest.mjs

@@ -0,0 +1,97 @@
+// Harvest receipts (#7748): a seat commit landed on main under a NEW sha (cherry-pick, squash)
+// diverges the seat branch for good. The receipt records seat sha -> main sha -> card so
+// `trantor sync` can realign the seat without anyone re-proving patch-equivalence.
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { busDir } from "./project.mjs";
+
+const SHA_RE = /^[0-9a-f]{7,40}$/;
+
+export function receiptsPath(project, root = busDir()) {
+  return join(root, `harvest-${project}.json`);
+}
+
+export function readReceipts(project, root = busDir()) {
+  const p = receiptsPath(project, root);
+  if (!existsSync(p)) return [];
+  try {
+    const j = JSON.parse(readFileSync(p, "utf8"));
+    return Array.isArray(j?.receipts) ? j.receipts : [];
+  } catch { return []; }
+}
+
+// A hand-typed receipt carries a short sha, so either side may be a prefix of the other.
+export function shaMatches(a, b) {
+  const x = String(a || "").toLowerCase(), y = String(b || "").toLowerCase();
+  return x.length >= 7 && y.length >= 7 && (x.startsWith(y) || y.startsWith(x));
+}
+
+export function recordHarvest(project, { seat, main, card = 0, branch = "", by = "" }, root = busDir()) {
+  const seatSha = String(seat || "").trim().toLowerCase();
+  const mainSha = String(main || "").trim().toLowerCase();
+  if (!SHA_RE.test(seatSha) || !SHA_RE.test(mainSha)) throw new Error("harvest: a sha is 7 to 40 hex characters");
+  const list = readReceipts(project, root).filter(r => !shaMatches(r.seat, seatSha));
+  const receipt = { seat: seatSha, main: mainSha, card: Number(card) || 0, branch: String(branch || ""), by: String(by || ""), ts: Date.now() };
+  list.push(receipt);
+  const p = receiptsPath(project, root);
+  mkdirSync(dirname(p), { recursive: true });
+  const tmp = `${p}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify({ project, receipts: list }, null, 2) + "\n");
+  renameSync(tmp, p);
+  return receipt;
+}
+
+export function run(cwd, args, { timeout = 15000 } = {}) {
+  const r = spawnSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout });
+  return { ok: r.status === 0, out: String(r.stdout || "").trim(), err: String(r.stderr || "").trim() };
+}
+const out = (cwd, args) => { const r = run(cwd, args); return r.ok ? r.out : ""; };
+
+// The runner persists branch.<seat>.base at worktree creation; a worktree made by hand means main.
+export function seatBase(dir, branch) {
+  return out(dir, ["config", "--get", `branch.${branch}.base`]) || "main";
+}
+
+// Realignment target: the remote base when origin carries it, else the local base branch.
+export function syncTarget(dir, base) {
+  const remote = out(dir, ["rev-parse", "--verify", "-q", `refs/remotes/origin/${base}`]);
+  if (remote) return { ref: `origin/${base}`, sha: remote };
+  const local = out(dir, ["rev-parse", "--verify", "-q", `refs/heads/${base}`]);
+  return { ref: base, sha: local };
+}
+
+// Every commit the seat branch carries that the target does not, split by whether a receipt covers it.
+export function auditSeat(dir, { branch, targetRef, receipts }) {
+  const log = out(dir, ["log", "--reverse", "--format=%H%x09%s", `${targetRef}..${branch}`]);
+  const harvested = [], unharvested = [];
+  for (const line of log.split("\n").filter(Boolean)) {
+    const [sha, ...rest] = line.split("\t");
+    const subject = rest.join("\t");
+    const receipt = receipts.find(r => shaMatches(r.seat, sha));
+    (receipt ? harvested : unharvested).push({ sha, subject, receipt });
+  }
+  return { harvested, unharvested };
+}
+
+// Refuses rather than loses: an unharvested commit stops the sync and is named. `reset --keep`
+// carries uncommitted edits across and refuses on its own when one touches a file main changed.
+export function syncSeat(dir, { branch = "", dryRun = false, fetch = true, receipts, root = busDir(), project = "" } = {}) {
+  const current = out(dir, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (!current || current === "HEAD") return { ok: false, reason: `${dir} has no branch checked out (detached HEAD)` };
+  if (branch && branch !== current) return { ok: false, reason: `${dir} is on ${current}, not ${branch}` };
+  branch = current;
+  const base = seatBase(dir, branch);
+  if (fetch) run(dir, ["fetch", "-q", "origin", base], { timeout: 20000 });
+  const target = syncTarget(dir, base);
+  if (!target.sha) return { ok: false, reason: `no ${base} to sync to: neither origin/${base} nor a local ${base} exists` };
+  const audit = auditSeat(dir, { branch, targetRef: target.sha, receipts: receipts || readReceipts(project, root) });
+  const head = out(dir, ["rev-parse", "HEAD"]);
+  const result = { ok: true, branch, base, target, head, ...audit };
+  if (audit.unharvested.length) return { ...result, ok: false, refused: true, reason: `${audit.unharvested.length} unharvested commit(s) on ${branch} would be lost` };
+  if (head === target.sha) return { ...result, noop: true };
+  if (dryRun) return { ...result, dry: true };
+  const r = run(dir, ["reset", "--keep", target.sha]);
+  if (!r.ok) return { ...result, ok: false, reason: `git reset --keep refused: ${r.err || r.out}`.trim() };
+  return { ...result, from: head, to: target.sha };
+}

package/lib/turn-policy.mjs

@@ -95,8 +95,9 @@ export function hasImperative(text) {
   return IMPERATIVE_RE.test(String(text || ""));
 }
 
-/// The safety net for a sender that never set `wake`: a direct message with no card and no
-/// imperative is an ack, an FYI or a queue note, and it batches into the next turn's context.
+/// #7766: no longer a wake gate — on a direct message the sender's wake flag decides alone. What
+/// keeps this alive is the receipt side of #7079: a reply threaded onto a seat's own outcome is an
+/// ack only while it carries no work of its own.
 export function carriesWork(text) {
   return cardRef(text) > 0 || hasImperative(text);
 }

package/mcp.mjs

@@ -7,6 +7,7 @@ import { writeFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join, basename, dirname } from "node:path";
 import { homedir, hostname } from "node:os";
 import { execSync, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { createRequire } from "node:module";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { advise } from "./bin/advise.mjs";
@@ -14,15 +15,12 @@ import { resolveProject, hostId, resolveHub, resolveHubInfo, nonSeatReason, hand
 import { signedPost, signedGet } from "./hooks/lib/api.mjs";
 import { anchorCursor } from "./hooks/lib/inbox-ledger.mjs";
 import { assertNoSecrets } from "./lib/scrub.mjs";
+import { markDoing, hollowVerdict } from "./hooks/lib/hollow-move.mjs";
 
-// ---- runtime dep resolution -------------------------------------------------
-// `claude plugin install` snapshots the REPO, not an npm tarball, so a GitHub-sourced
-// plugin ships no node_modules — and a static `import "@modelcontextprotocol/sdk/..."`
-// then dies with ERR_MODULE_NOT_FOUND before a single line runs. The failure is silent
-// from the user's side: every relay tool just disappears. So resolve these two ourselves.
-// Normal path is untouched (plain `import(spec)`, ESM build, deps present); only when that
-// comes back NOT_FOUND do we borrow the tree from the globally installed `trantor`, which
-// npm always gives real dependencies at the same version as the plugin.
+// Runtime dep resolution: `claude plugin install` snapshots the repo, not an npm tarball, so a
+// GitHub-sourced plugin ships no node_modules and a static SDK import dies with
+// ERR_MODULE_NOT_FOUND before any line runs — silently: every relay tool just disappears.
+// Resolve ourselves: plain import(spec) first; on NOT_FOUND borrow the global trantor's tree.
 const HERE = dirname(fileURLToPath(import.meta.url));
 const req = createRequire(import.meta.url);
 
@@ -75,12 +73,10 @@ const SESSION_AGENT = process.env.RELAY_AGENT || process.env.RELAY_AGENT_FALLBAC
 const SESSION = process.env.RELAY_SESSION
   || (SESSION_AGENT ? `${SESSION_AGENT}:${PROJECT}` : `${hostId()}:${PROJECT}`);
 let cursor = 0;
-// First-call guard: a brand-new MCP process must NOT replay the entire historical backlog (observed:
-// 2,379 msgs / 520KB back to an old asteroids project) the instant relay_inbox/relay_wait is called.
-// The seed anchors to BOOT (this server starts with the session), never to the time of the first call:
-// seeding to "now at first call" swallowed #7282 on 2026-08-20 — the call came 33 minutes into the
-// session, prompted by a nudge ABOUT that message. PEEK only: the hooks own the hub's delivery ledger
-// (sessionstart claims the pre-start backlog); a non-peek seed here marked unseen messages delivered.
+// First-call guard: a new MCP process must NOT replay the historical backlog the instant
+// relay_inbox/relay_wait is called (one project got 2,379 msgs / 520KB back). The seed anchors to
+// BOOT, never to the first call — a "now" seed swallowed #7282. PEEK only: the hooks own the
+// delivery ledger; a non-peek seed here marked unseen messages delivered.
 const BOOT_TS = Date.now();
 let cursorSeeded = false;
 async function seedCursor() {
@@ -92,23 +88,22 @@ async function seedCursor() {
   } catch { /* hub down: the subsequent real call surfaces the error; retry the seed next time */ }
 }
 
-// Every hub call is SIGNED with this session's Ed25519 keypair (TDD §7.3) via the shared client in
-// hooks/lib/api.mjs. Writes: that is what binds /send's `from` to the signer and closes the
-// self-asserted `from` hole (the 2026-07-28 RCE). Reads TOO (the 2026-07-30 agent-UX gap): an
-// enforce hub 401s unsigned reads, which made relay_inbox/board/peers dead for the very agents the
-// bus exists for. Signed reads are scope-filtered by the hub to this identity's grants — for a
-// session reading its own project + DMs that is the intended behavior. The client fail-opens on a
-// down hub (returns {ok:false}); we surface that as a thrown Error so individual tools .catch it.
-// Instance id (docs/INSTANCE-KEYS-CONTRACT.md): the MCP server has no harness session_id, so it
-// mints a random id at boot — its lifetime ≈ the session's. The endorsed subkey it keys signs all
-// traffic; the durable identity keeps enrollment and attribution.
+// Every hub call is SIGNED with this session's Ed25519 keypair (TDD §7.3) via hooks/lib/api.mjs:
+// writes bind /send's `from` to the signer (closing the self-asserted `from` RCE hole), reads stay
+// alive under an enforcing hub and are scope-filtered by the hub to this identity's grants. The
+// client fail-opens on a down hub ({ok:false}); we throw so individual tools .catch it.
+
+// Instance id (docs/INSTANCE-KEYS-CONTRACT.md): no harness session_id exists here, so mint a
+// random id at boot — its lifetime ≈ the session's; the endorsed subkey it keys signs all traffic.
 const INSTANCE_ID = `mcp-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 async function api(method, path, payload, { timeoutMs } = {}) {
   // PROJECT explicitly, never the client's cwd fallback: this server's project is fixed at boot,
   // and letting the hub be re-derived per call is how a session ends up writing to two hubs.
+  // #7755: every write carries an op id; signedPost resolves its own timeout through GET /_op,
+  // so a timed-out write comes back committed, rejected, or ambiguous in those words.
   const r = method.toUpperCase() === "GET"
     ? await signedGet(path, { session: SESSION, instance: INSTANCE_ID, project: PROJECT, timeoutMs })
-    : await signedPost(path, payload, { session: SESSION, instance: INSTANCE_ID, project: PROJECT, timeoutMs });
+    : await signedPost(path, { ...payload, _op: randomUUID() }, { session: SESSION, instance: INSTANCE_ID, project: PROJECT, timeoutMs });
   if (!r.ok) {
     // A timeout is not an outage. `hub 0 on /tasks` read as a DEAD HUB when the hub was 200 OK and
     // merely slow — /tasks is 1.59MB across 941 cards — and a reader who cannot tell them apart
@@ -126,11 +121,10 @@ const fmt = (m) => `#${m.id} [${m.from} -> ${m.to}] ${new Date(m.ts).toLocaleTim
 const server = new McpServer({ name: "trantor", version: "0.1.0" });
 
 server.tool("relay_whoami", "Show this session's relay identity, project, hub URL, HOW that hub was chosen, and whether this session is actually a registered seat.", {}, async () => {
-  // This tool used to POST /register before answering — so asking "where am I?" from a
-  // non-project directory CREATED the phantom seat it then reported, on the local hub, and the
-  // answer looked healthy. A diagnostic must observe, never mutate. It now reports the truth,
-  // including the two things that actually go wrong: an unregistered session, and a hub that was
-  // a fallback rather than a pin.
+  // A diagnostic must observe, never mutate: this tool used to POST /register before answering, so
+  // asking "where am I?" from a non-project directory CREATED the phantom seat it then reported,
+  // and the answer looked healthy. It now reports the truth — an unregistered session, or a hub
+  // that is a fallback rather than a pin.
   const { url, via } = resolveHubInfo(PROJECT);
   const viaText = { env: "RELAY_URL env override", pin: "pinned for this project", global: "GLOBAL DEFAULT — this project is not pinned", default: "BUILT-IN DEFAULT — no config found" }[via] || via;
   let text = `session=${SESSION}\nproject=${PROJECT}\nhub=${url}\nhub_via=${via} (${viaText})\nregistered=${isHomeDirSession ? "NO" : "yes"}`;
@@ -221,10 +215,30 @@ server.tool("relay_phase_goal", "Set what a PHASE is for — its goal — shown
     return { content: [{ type: "text", text: `phase "${phase}" goal set for ${proj}` }] };
   });
 
-server.tool("relay_task_move", "Move a Kanban card as you progress: todo -> doing -> testing -> done. NEVER move straight to done: move to 'testing' when you finish, run the project's tests/typecheck, then 'done' only if green — or 'failed' (with a relay_send explaining what broke) if not. The orchestrator bounces failed cards back to doing. blocked = waiting on something external. A move to 'testing' or 'done' MUST carry a `note` (<=2000 chars): what you changed and the evidence (the test command + counts). The note lands on the card's permanent log — the board shows its ·N count, so a silent move reads as unverified work.",
+server.tool("relay_task_move", "Move a Kanban card as you progress: todo -> doing -> testing -> done. NEVER move straight to done: move to 'testing' when you finish, run the project's tests/typecheck, then 'done' only if green — or 'failed' (with a relay_send explaining what broke) if not. The orchestrator bounces failed cards back to doing. blocked = waiting on something external. A move to 'testing' or 'done' MUST carry a `note` (<=2000 chars): what you changed and the evidence (the test command + counts). The note lands on the card's permanent log — the board shows its ·N count, so a silent move reads as unverified work. A testing/done move with NO worktree diff, no new files, no ticked checklist items and no test command in the note is flagged HOLLOW: and reported to the card's assigner (#7750) — a legitimately no-code card (docs, investigation, refusal, answered on the bus) avoids the flag by declaring that outcome in the note.",
   { id: z.number(), status: z.enum(["todo","doing","testing","failed","done","blocked"]), note: z.string().max(2000).optional().describe("card-log entry (<=2000 chars) — REQUIRED on moves to testing/done: what changed + the evidence (command, pass counts)") },
   async ({ id, status, note }) => {
-    await api("POST", "/task/update", { id, status, note, by: SESSION });
+    // #7750: seat-side hollow-move check. The hub cannot see this worktree, so the evidence is
+    // gathered HERE at report time; a hollow move still lands (never blocks a no-code card), the
+    // note is prefixed HOLLOW: and the card's assigner gets one bus line. Never throws into the move.
+    let outNote = note;
+    try {
+      if (status === "doing") markDoing(process.cwd(), id);
+      if (status === "testing" || status === "done") {
+        const { task } = await api("GET", `/card?project=${encodeURIComponent(PROJECT)}&id=${id}`);
+        const v = hollowVerdict(process.cwd(), id, note, task?.checklist);
+        if (v.checked && v.hollow) {
+          const what = `no ${v.missing.join(", no ")}`;
+          outNote = `HOLLOW: ${what} — ${note || "(no note)"}`.slice(0, 2000);
+          const assigner = task?.by;
+          if (assigner && assigner !== SESSION) {
+            await api("POST", "/send", { from: SESSION, to: assigner, wake: false,
+              text: `HOLLOW move on #${id} -> ${status} by ${SESSION}: ${what}. The move landed; the note is flagged on the card.` });
+          }
+        }
+      }
+    } catch { /* the flag must never break a move */ }
+    await api("POST", "/task/update", { id, status, note: outNote, by: SESSION });
     return { content: [{ type: "text", text: `card #${id} -> ${status}` }] };
   });
 
@@ -328,11 +342,10 @@ server.tool("relay_withdraw_proposal", "Withdraw one of THIS session's PENDING p
     return { content: [{ type: "text", text: `proposal #${id} withdrawn — one queue slot free` }] };
   });
 
-// ONE card, not the board (#6134). A seat used to be told to "query the board for related PAST
-// cards and lessons — 1900+ cards of tribal knowledge", and it did: the whole board, every turn,
-// almost all of it other people's work. This is the same intent at a thousandth of the tokens —
-// the card, what it waits on, its own notes, and the handful of done cards that actually rhyme
-// with it. Client-side on /tasks, so no hub change and it works against any hub version.
+// ONE card, not the board (#6134): a seat told to "query the board for related PAST cards and
+// lessons" pulled 1900+ cards of mostly other people's work, every turn. This is the same intent
+// at a thousandth of the tokens — the card, what it waits on, its notes, and the done cards that
+// rhyme with it. Client-side on /tasks, so no hub change and it works against any hub version.
 const STOPWORDS = new Set(["the","a","an","and","or","of","to","in","on","for","with","is","it","its","that","this","not","but","by","at","as","from","into","out","up","down","when","then","than","so","no","new","one","two","every","all","any"]);
 function titleWords(title) {
   return new Set(String(title || "").toLowerCase().match(/[a-z][a-z0-9_-]{2,}/g)?.filter(w => !STOPWORDS.has(w)) || []);
@@ -378,11 +391,10 @@ server.tool("relay_board", "Show a project's Kanban board (all cards + their sta
     card: z.number().optional().describe("read ONE card instead of the board: the card itself, its notes, and the last five done cards whose title shares a word with it. This is what a seat starting a card should call — the whole board is 1900+ cards of someone else's work.") },
   async ({ project, card }) => {
   const proj = project || PROJECT;
-  // #6983: ask for the SLIM projection, and when opening one card ask for that card full. The board
-  // needs titles and a note COUNT, never every card's note text — on trantor that was 1.55MB and
-  // 625-961ms against a 1500ms budget, which is why this tool intermittently answered "hub 0" when
-  // the hub was 200 OK and merely slow. An older hub ignores both params and returns the full board,
-  // which still renders — so this asks for cheap and works either way, rather than requiring a deploy.
+  // #6983: ask for the SLIM projection, and for that one card full when opening one. The board
+  // needs titles and a note COUNT, never every card's note text: 1.55MB / 625-961ms against a
+  // 1500ms budget is why this tool answered "hub 0" while the hub was 200 OK and merely slow.
+  // An older hub ignores both params and returns the full board, which still renders either way.
   const { tasks } = await api("GET", `/tasks?project=${encodeURIComponent(proj)}&fields=slim${card ? `&card=${encodeURIComponent(card)}` : ""}`);
   if (!tasks.length) return { content: [{ type: "text", text: `${proj}: no cards yet` }] };
   if (card) return { content: [{ type: "text", text: cardView(tasks, card, proj) }] };
@@ -405,7 +417,7 @@ server.tool("relay_peers", "Find who you can talk to: the live agent sessions on
 
 server.tool("relay_send", "Send a live message to another agent session (or 'all' to broadcast). Reach the other agent YOURSELF: if you are about to ask the human to pass something along, tell the session directly instead — asking a person to carry a message between two agents is a failure, not politeness. Don't know the id? relay_peers lists them, linked projects included. Cross-project action is a breach unless the operator linked the projects (`trantor policy link <a> <b> --reason \"<why>\"`) — the hub answers 403 for a send into an unlinked project.",
   { to: z.string().describe("target session id, or 'all'"), text: z.string().describe("message body"),
-    wake: z.boolean().optional().describe("false = context, not a contract: the message batches into the target's next turn instead of buying it a whole CLI session. Use it for acks, FYIs and queue notes; leave it unset for anything you expect worked on."),
+    wake: z.boolean().optional().describe("false = context, not a contract: the message batches into the target's next turn instead of buying it a whole CLI session. With wake unset or true, a direct message ALWAYS earns a turn whatever its text says (#7766) — so set false on every ack, FYI and queue note, not just on obvious chatter."),
     re: z.number().optional().describe("the message id you are ANSWERING. Set it whenever you reply to a specific message. Without it the hub matches your reply to the peer's OLDEST outstanding contract, so answering their newest question silently closes their oldest one and leaves the real one reading WAITING forever — which is how seats end up chasing contracts that were answered long ago.") },
   async ({ to, text, wake, re }) => {
     // The event log is append-only — a secret in it is unrecoverable, so refuse BEFORE
@@ -456,7 +468,7 @@ server.tool("relay_handoff", "Write a rich handoff for THIS session so a fresh s
     // session_id: WHO wrote this. This server has no harness session id, so it records the orch
     // thread's id when the evidence says the writer IS that thread (orchWriterSid). Without it a
     // tool-written orchestrator handoff carries no writer and the baton-hold + map-follow logic in
-    // sessionstart.mjs can never fire (found live 2026-08-28: trantor-1787886998 had session_id null).
+    // sessionstart.mjs can never fire (seen live: an orch handoff carried session_id null).
     const rec = { id: `${name}-${stamp}`, project, projectName: name, machine: hostname(), trigger: "relay_handoff-tool", session_id: orchWriterSid(project, PROJECT), stamp: Number(stamp) || 0, summary: String(summary), gitStatus: git, consumed: false };
     writeFileSync(join(dir, `${rec.id}.json`), JSON.stringify(rec, null, 2));
     await api("POST", "/send", { from: SESSION, to: "all", text: `📋 Handoff ready for ${name} — open a fresh session here to take over (${rec.id}).` }).catch(() => {});
@@ -490,10 +502,8 @@ const HEARTBEAT_MS = Number(process.env.RELAY_HEARTBEAT_MS || 60 * 1000);
 
 // This server's own plugin version, stamped on every /register. Only the tool-use heartbeat HOOK
 // used to write hookVersion, so a fresh-but-idle session's peer row kept its DEAD predecessor's
-// version until the first tool call — misread twice on 2026-08-19 as "wrong plugin version after
-// restart". The MCP boots with the session and registers immediately, so it makes the row truthful
-// from second one. Same lookup as hooks/lib/update-check.mjs: plugin.json beside this file, then
-// package.json (running straight from the repo).
+// version until the first tool call — misread as "wrong plugin version after restart". The MCP
+// registers at boot, making the row truthful from second one. Same lookup as update-check.mjs.
 const MCP_VERSION = (() => {
   for (const rel of ["./.claude-plugin/plugin.json", "./package.json"]) {
     try {
@@ -504,45 +514,32 @@ const MCP_VERSION = (() => {
   return "";
 })();
 
-// Mirror the SessionStart/PostToolUse hooks: some directories aren't project work, and
-// auto-registering from them spawns a phantom project lane that then sits in the sidebar forever.
-// PROJECT falls back to the cwd basename, so the directory name becomes the lane name:
-//   - the home directory itself      → a "<username>" lane
-//   - a plugin-cache snapshot        → a lane named after the VERSION, e.g. "0.17.66"
-// The second one is not hypothetical: `cd ~/.claude/plugins/cache/trantor/trantor/<ver> &&
-// node mcp.mjs` is the documented way to check the relay server still boots after a plugin
-// update, and every such check was leaving a version-numbered lane behind.
-// Opt in explicitly with RELAY_SESSION or RELAY_PROJECT. The MCP server still starts so the
-// user can call relay tools (e.g. relay_whoami) deliberately; we just skip auto-presence.
+// Mirror the SessionStart/PostToolUse hooks: some directories are not project work, and
+// auto-registering from them spawns a phantom project lane that sits in the sidebar forever
+// (home dir → a "<username>" lane; a plugin-cache snapshot → a VERSION-numbered lane, left
+// behind by every documented post-update boot check). Opt in with RELAY_SESSION/RELAY_PROJECT.
 const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-// ONE definition of "is this a seat", shared with the SessionStart hook (lib/project.mjs). When
-// the hook and this server disagreed, a session in a non-repo directory got the hook's "not a
-// seat" verdict AND an MCP registration — a phantom peer on the fallback hub, which is the
-// split-brain the whole fix exists to remove. nonSeatReason() also covers a plain non-git
-// directory (~/development), the case the old home-dir-only check let through.
+// ONE definition of "is this a seat", shared with the SessionStart hook (lib/project.mjs): when
+// the two disagreed, a session in a non-repo directory got the hook's "not a seat" verdict AND an
+// MCP registration — a phantom peer on the fallback hub, the split-brain this removes.
+// nonSeatReason() also covers a plain non-git directory, which the old home-dir-only check missed.
 const nonProjectReason = nonSeatReason(projectDir);
 const isHomeDirSession = !!nonProjectReason;
 
 // #6170: WHAT this session is, when it can know. sessionstart stamps kind "orch" on the
 // orchestrator pane, but that runs once — every MCP beat afterwards was kindless, and the hub's
 // crew exemption reads the peer row's kind, so the orchestrator kept being demoted by its own
-// heartbeat and then warned about as an intruder on its own project. Same test sessionstart uses:
-// TRANTOR_ORCH names the project this pane orchestrates.
+// heartbeat, then warned about as an intruder on its own project. Same test sessionstart uses.
 const KIND = process.env.TRANTOR_ORCH && process.env.TRANTOR_ORCH === PROJECT ? { kind: "orch" } : {};
 
 if (!isHomeDirSession) {
   await api("POST", "/register", { session: SESSION, project: PROJECT, status: `active in ${PROJECT}`, hookVersion: MCP_VERSION, ...KIND })
     .catch((err) => { process.stderr.write(`[trantor-mcp] initial register failed: ${err?.message || err}\n`); });
 
-  // Heartbeat — keep this session's presence fresh for as long as the MCP process lives.
-  // Registration alone decays after the hub's online window (5 min); without this, idle agents
-  // — and EVERY agent after the laptop sleeps (dead connection, no resume event) — fall off the
-  // board while their process is still alive. This is the UNIVERSAL counterpart to the Claude-only
-  // PostToolUse heartbeat hook: it runs inside the relay every agent loads (Claude, codex, gemini,
-  // kimi, deepseek), so the whole crew stays tracked. We POST /register with NO status, so the
-  // hub refreshes lastSeen but preserves the session's meaningful status. setInterval pauses during
-  // sleep and fires on wake, so presence self-heals within one interval; .unref() lets the process
-  // still exit cleanly when the agent closes the stdio transport (no phantom peers).
+  // Heartbeat — presence decays after the hub's 5-min online window, so without this idle agents
+  // (and every agent after laptop sleep) fall off the board while their process is alive. This is
+  // the universal counterpart to the Claude-only PostToolUse hook, running in the relay every
+  // agent loads. NO status on the POST (lastSeen refreshes, status preserved); .unref() keeps exit clean.
   setInterval(() => { api("POST", "/register", { session: SESSION, project: PROJECT, hookVersion: MCP_VERSION, ...KIND }).catch(() => {}); }, HEARTBEAT_MS).unref?.();
 } else {
   process.stderr.write(`[trantor-mcp] ${nonProjectReason} — not auto-registering on the bus (set RELAY_SESSION or RELAY_PROJECT to opt in)\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.57",
+  "version": "0.18.58",
   "type": "module",
   "bin": {
     "trantor": "bin/cli.mjs"