trantor 0.18.59 → 0.18.60

package/bin/crew-runner.mjs

@@ -10,12 +10,13 @@ import { loadOrCreate } from "../lib/identity.mjs";
 import { signedHeaders } from "../lib/signed-fetch.mjs";
 import { ensureEnrolled } from "../lib/enroll.mjs";
 import { redactKeys } from "../lib/redact.mjs";
+import { applyWorktreeDeclaration, ensureSeatWorktree, provisioningLines, readWorktreeDeclaration } from "../lib/seat-worktree.mjs";
 import {
   AUTH_MARKER_RE, classifyFailure, looksLikeAuthDeath,
-  verdictFor, substantiveOutput,
+  verdictFor, substantiveOutput, stallVerdict, cutSignalFor,
   readPromptText, stripPromptEcho,
 } from "../lib/classify-failure.mjs";
-import { capWake, capBcast, pickLessons, composePrompt } from "./crew-payload.mjs";
+import { capWake, capBcast, pickLessons, composePrompt, contractBase, baseLine } from "./crew-payload.mjs";
 import {
   cardRefs, wakeCard, carriesWork, parseTurnTokens, parseResetAt, reasonWithBalances, quotaResetAt, PARKING_REASONS,
   senderProjectOf, isLinkedProject, stateSkipReason,
@@ -39,80 +40,33 @@ const DIR = process.argv[3] || process.cwd();
 // fork the host's "builtbetter.ai" into a separate "builtbetter" lane.
 const PROJ = process.env.RELAY_PROJECT || resolveProject(DIR);
 
-function safePathSegment(s) {
-  return String(s).replace(/\.{2,}/g, "_").replace(/[^A-Za-z0-9_.-]/g, "_");
-}
-
 function gitOut(args, cwd = DIR) {
   const r = spawnSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 8000 });
   return r.status === 0 ? String(r.stdout || "").trim() : "";
 }
 
-function ensureSeatWorktree(sourceDir) {
-  if (process.env.TRANTOR_NO_WORKTREE === "1") return sourceDir;
-  const root = gitOut(["-C", sourceDir, "rev-parse", "--show-toplevel"], sourceDir);
-  if (!root) return sourceDir;
-
-  spawnSync("git", ["-C", root, "worktree", "prune"], { stdio: "ignore", timeout: 8000 });
-  const seatDir = join(homedir(), ".agent-bus", "worktrees", safePathSegment(PROJ), safePathSegment(AGENT));
-  const branch = `seat/${AGENT}`;
-  if (existsSync(seatDir)) {
-    const ok = gitOut(["-C", seatDir, "rev-parse", "--is-inside-work-tree"], seatDir) === "true";
-    if (ok) {
-      // #5403: a worktree created once builds against THAT day's main forever — every wave since
-      // has needed a hand fast-forward. Refresh only when it is CLEAN: a dirty tree is a seat's
-      // unintegrated work and a diverged branch is a decision, and refreshing must never eat
-      // either. Failure to refresh is loud but non-fatal: stale beats broken.
-      const dirty = gitOut(["-C", seatDir, "status", "--porcelain"], seatDir);
-      if (dirty === "") {
-        const head = gitOut(["-C", root, "rev-parse", "HEAD"], root);
-        const ff = head && spawnSync("git", ["-C", seatDir, "merge", "--ff-only", head], { stdio: "ignore", timeout: 15000 });
-        if (ff && ff.status === 0) console.log(`\x1b[2m[runner]\x1b[0m ${branch} worktree refreshed to ${head.slice(0, 7)}`);
-        else console.log(`\x1b[33m[runner]\x1b[0m ${branch} worktree diverged from main HEAD — left as-is (integrate or reset it)`);
-      } else {
-        console.log(`\x1b[33m[runner]\x1b[0m ${branch} worktree has uncommitted work — not refreshed`);
-      }
-      return seatDir;
-    }
-    console.log(`\x1b[33m[runner]\x1b[0m worktree path exists but is not a git worktree: ${seatDir} — using ${sourceDir}`);
-    return sourceDir;
-  }
-
-  try { mkdirSync(join(homedir(), ".agent-bus", "worktrees", safePathSegment(PROJ)), { recursive: true }); } catch {}
-
-  // Fast-forward the base branch before branching: the worktree should build
-  // against the latest main, not a stale checkout. (#5403)
-  const base = gitOut(["-C", root, "rev-parse", "--abbrev-ref", "HEAD"], root);
-  if (base) {
-    const remote = gitOut(["-C", root, "rev-parse", "--abbrev-ref", `${base}@{upstream}`], root);
-    if (remote) {
-      const ff = spawnSync("git", ["-C", root, "merge", "--ff-only", remote], { stdio: "ignore", timeout: 15000 });
-      if (ff && ff.status === 0) console.log(`\x1b[2m[runner]\x1b[0m ${base} fast-forwarded to ${remote}`);
-    }
-  }
-
-  const r = spawnSync("git", ["-C", root, "worktree", "add", "--no-track", "-B", branch, seatDir, "HEAD"], {
-    encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 30000,
-  });
-  if (r.status === 0) {
-    // Persist the base branch so the Review lens can name the real base instead
-    // of guessing via merge-base. Stale metadata is unset, not trusted. (#5403)
-    if (base) {
-      spawnSync("git", ["-C", seatDir, "config", `branch.${branch}.base`, base], { stdio: "ignore", timeout: 5000 });
+function seatWorktree(sourceDir) {
+  const wt = ensureSeatWorktree({ sourceDir, project: PROJ, agent: AGENT });
+  // #7760: a worktree is a git checkout — it lacks the gitignored files the build needs and cannot
+  // resolve relative sibling packages. The project's declaration provides both before the first turn.
+  if (wt.root) {
+    const decl = readWorktreeDeclaration(wt.root);
+    if (decl) {
+      const applied = applyWorktreeDeclaration(decl, { root: wt.root, seatDir: wt.dir });
+      const lines = wt.created ? provisioningLines(applied) : provisioningLines({ linked: [], provisioned: [], operator: applied.operator, problems: applied.problems });
+      for (const l of lines) console.log(`\x1b[2m[runner]\x1b[0m ${l}`);
     }
-    // Set push.autoSetupRemote so a plain git push creates and sets upstream on
-    // first push (git >= 2.37, older clients ignore it). (#5403)
-    const pushAuto = gitOut(["-C", seatDir, "config", "--get", "push.autoSetupRemote"], seatDir);
-    if (!pushAuto) {
-      spawnSync("git", ["-C", seatDir, "config", "push.autoSetupRemote", "true"], { stdio: "ignore", timeout: 5000 });
-    }
-    return seatDir;
   }
-  console.log(`\x1b[33m[runner]\x1b[0m could not create ${branch} worktree — using ${sourceDir}`);
-  return sourceDir;
+  return wt.dir;
 }
 
-const TURN_DIR = ensureSeatWorktree(DIR);
+const TURN_DIR = seatWorktree(DIR);
+
+// #7754: the integration head is the orchestrator's LOCAL main, which this linked worktree already
+// holds as the ref `main`; origin/main trails it whenever integration commits are unpushed.
+const localMainHead = () => gitOut(["rev-parse", "--verify", "--quiet", "main^{commit}"], TURN_DIR);
+const resolvesHere = (sha) =>
+  spawnSync("git", ["cat-file", "-e", `${sha}^{commit}`], { cwd: TURN_DIR, stdio: "ignore", timeout: 8000 }).status === 0;
 
 // #6154: opencode records each session with its directory; the newest row for OUR worktree is the
 // only session a resume may pin. Fail-open: no row means a fresh turn, never a stranger's session.
@@ -284,7 +238,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 a contract omits a fact you cannot proceed without, ASK — never invent the value: relay_ask(<card>, <question>) blocks the card with your question, keeps the turn owed (no park, no failure), and resumes you when the assigner's answer lands; an invented value that reads as reasoned is the worst outcome this crew ships (#7756). 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.`;
+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 a contract omits a fact you cannot proceed without, ASK — never invent the value: relay_ask(<card>, <question>) blocks the card with your question, keeps the turn owed (no park, no failure), and resumes you when the assigner's answer lands; an invented value that reads as reasoned is the worst outcome this crew ships (#7756). 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. A contract's \`base: <sha>\` line is the integration head: start your seat branch at that sha (\`git reset --hard <sha>\` on the fresh branch), never at origin/main, which trails the orchestrator's unpushed integration commits; the object is already here as the ref \`main\`. If \`git cat-file -e <sha>\` fails, say \`cannot resolve base <sha>\` on the bus and move the card to blocked instead of reasoning from origin/main. Every testing/done note names the sha you verified against as \`verified at <sha>\`; a note without it is flagged HOLLOW. 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;
@@ -406,6 +360,7 @@ async function reportFailure(exit, trigger, undelivered = 0, reasonOverride = ""
   const status = down ? `down: ${reason} · ${consecFails} fails` : `errored: ${reason}`;
   await api("/register", { session: SESSION, project: PROJ, status, llm: AGENT, model: MODEL, kind: "agent" }).catch(() => {});
   const hint = reason === "exhausted" ? " — needs `trantor swap`"
+    : reason === "stalled" ? " — CLI silent for the whole watchdog window: check the provider, or `trantor swap`"
     : reason === "auth" ? " — check credentials"
     : reason === "backend-error" ? " — provider backend error (NOT quota): retry, or `trantor swap` to another provider"
     : reason === "missing-cli" ? " — CLI not on PATH"
@@ -454,7 +409,10 @@ async function parkSeat(reason, undelivered, resetHint = 0) {
   const when = resetAt ? new Date(resetAt).toLocaleString() : "";
   if (!parkAnnounced) {
     parkAnnounced = true;
-    const text = redactKeys(`⛔ ${SESSION} PARKED (${reason}) — holding ${undelivered} message(s), redelivery stopped ${when ? `until ${when}` : `until \`trantor up ${AGENT}\``}`);
+    // #7752: a stalled park names the CLI and its model — the swap decision needs both, and this
+    // line is the one place the room reads them together.
+    const named = reason === "stalled" ? ` — ${AGENT}${MODEL ? `, model ${MODEL}` : " (cli default model)"}` : "";
+    const text = redactKeys(`⛔ ${SESSION} PARKED (${reason}${named}) — holding ${undelivered} message(s), redelivery stopped ${when ? `until ${when}` : `until \`trantor up ${AGENT}\``}`);
     await api("/send", { from: SESSION, to: "all", text, project: PROJ, kind: "status" }).catch(() => {});
     const orch = `${hostId()}:${PROJ}`;
     if (orch !== SESSION) await api("/send", { from: SESSION, to: orch, text, project: PROJ, kind: "alert" }).catch(() => {});
@@ -648,6 +606,10 @@ let inFollowUp = false;
 // overwrites it with its own state, so a caller reading it after the chain sees the state of the
 // LAST turn — which is what decides whether a failed chain died to the box or to the API.
 let lastTurnCut = false;
+// #7752: whether the turn that just ended was a SILENT cut — the watchdog's stall marker (every
+// liveness channel quiet for the whole window), not the box. Same overwrite semantics as
+// lastTurnCut: the follow-up's own ending is what the ladder reads.
+let lastTurnStalled = false;
 // The card the CURRENT CLI session belongs to (#6134). 0 = the kickoff session, which belongs to
 // no card, so the first contract that names one starts a session of its own.
 let sessionCard = 0;
@@ -728,13 +690,21 @@ async function runTurn(prompt, isFirst, trigger = "kickoff", opts = {}) {
   // CLI can write lines the watchdog sees. CUTF is written by the shell's time box: cut, not crashed.
   const CUTF = join(homedir(), ".agent-bus", `turncut-${AGENT}-${PROJ}`);
   try { unlinkSync(CUTF); } catch {}
+  // #7752: written by the watchdog's kill mode when EVERY liveness channel has been quiet for
+  // the whole window; the box sweeps on the marker, so a silent turn ends at the stall window
+  // instead of burning the box. Unlinked at turn start and again with the cut cleanup.
+  const STALLF = join(homedir(), ".agent-bus", `turnstall-${AGENT}-${PROJ}`);
+  try { unlinkSync(STALLF); } catch {}
   // Touched by the stderr scrubber as its LAST act (the shell below); node waits for it after
   // spawnSync before reading ERRF — see the drain note at the spawnSync call.
   const DRAINF = join(homedir(), ".agent-bus", `turndrain-${AGENT}-${PROJ}`);
   try { unlinkSync(DRAINF); } catch {}
   try {
     writeFileSync(STAMPF, JSON.stringify({ turn: TURN, startedAt: Date.now(), runner: RUNNER_ID }));
-    const wd = spawn(process.execPath, [join(import.meta.dirname, "turn-watchdog.mjs"), STAMPF, ERRF, String(WD_MS), SESSION, PROJ, HUB, TRANSCRIPT_DIR, TURN_DIR],
+    const wd = spawn(process.execPath, [join(import.meta.dirname, "turn-watchdog.mjs"), STAMPF, ERRF, String(WD_MS), SESSION, PROJ, HUB, TRANSCRIPT_DIR, TURN_DIR,
+      // #7752: the stall marker only exists when a box does — with no box there is no sweep to
+      // end the turn, so the watchdog stays report-only (reporting is the whole job, boxless).
+      TURN_MAX_MS ? STALLF : ""],
       { detached: true, stdio: "ignore" });
     WD_CHILD = wd;
     wd.unref();
@@ -743,13 +713,21 @@ async function runTurn(prompt, isFirst, trigger = "kickoff", opts = {}) {
   // (setsid escapes a group signal, never its parent). The marker file tells node "cut", not "crashed".
   const sweep = `sweep() { local p; for p in $(pgrep -P $1 2>/dev/null); do sweep $p; done; kill -KILL $1 2>/dev/null; }`;
   // #7742: the box must neither hold the sid capture pipe nor orphan its sleep on turn exit.
+  // #7752: the box POLLS instead of one long sleep — the watchdog's stall marker (a silent
+  // turn) breaks the loop at the stall window, the deadline breaks it at the full box, and only
+  // the deadline path writes CUTF so the runner can tell the two cuts apart.
   const box = TURN_MAX_MS ? `
 ${sweep}
 ( trap 'kill "$sleeppid" 2>/dev/null; wait "$sleeppid" 2>/dev/null; exit 0' TERM
-  sleep ${Math.ceil(TURN_MAX_MS / 1000)} & sleeppid=$!
-  wait "$sleeppid"
+  deadline=$(( $(date +%s) + ${Math.ceil(TURN_MAX_MS / 1000)} ))
+  while :; do
+    [ -f "${STALLF}" ] && break
+    [ "$(date +%s)" -ge "$deadline" ] && break
+    sleep 1 & sleeppid=$!
+    wait "$sleeppid"
+  done
   kill -0 $job 2>/dev/null || exit 0
-  : > ${CUTF}
+  [ -f "${STALLF}" ] || : > ${CUTF}
   sweep $job
 ) >/dev/null 2>&1 & boxpid=$!` : "\nboxpid=";
   const shell = `set -o pipefail
@@ -782,9 +760,11 @@ exit $turn_exit`;
   if (TURN_MAX_MS) { spawnOpts.timeout = TURN_MAX_MS + 30000; spawnOpts.killSignal = "SIGKILL"; }
   const r = spawnSync("/bin/bash", ["-c", shell], spawnOpts);
   // The shell's box leaves the marker; the backstop leaves an ETIMEDOUT. Either way the turn was
-  // cut, not merely failed.
+  // cut, not merely failed. A stall marker (#7752) outranks the box marker: a turn silent for
+  // the whole window is a stall however the sweep found it.
   const boxed = existsSync(CUTF);
-  const cut = !!TURN_MAX_MS && (boxed || r.error?.code === "ETIMEDOUT");
+  const stallCut = existsSync(STALLF);
+  const cut = !!TURN_MAX_MS && (boxed || stallCut || r.error?.code === "ETIMEDOUT");
   // DRAIN before classifying, never on a CUT turn (the sweep killed the scrubber, its marker never
   // comes). bash 3.2 `wait` skips process substitutions, so wait for DRAINF, bounded.
   if (!cut) {
@@ -798,9 +778,12 @@ exit $turn_exit`;
     // Belt and braces after the shell's descendant sweep: anything still sharing the turn's group.
     if (r.pid) { try { process.kill(-r.pid, "SIGKILL"); } catch {} }
     try { unlinkSync(CUTF); } catch {}
-    log(`\x1b[33mturn cut at the ${Math.round(TURN_MAX_MS / 1000)}s time box — CLI and every descendant ended${boxed ? "" : " (node backstop: bash itself was wedged)"}\x1b[0m`);
+    try { unlinkSync(STALLF); } catch {}
+    if (stallCut) log(`\x1b[33mturn STALLED — no bytes on either stream and no transcript advance for ${Math.round(WD_MS / 60000)}m; ended at the stall window, not the ${Math.round(TURN_MAX_MS / 1000)}s box\x1b[0m`);
+    else log(`\x1b[33mturn cut at the ${Math.round(TURN_MAX_MS / 1000)}s time box — CLI and every descendant ended${boxed ? "" : " (node backstop: bash itself was wedged)"}\x1b[0m`);
   }
   lastTurnCut = cut;
+  lastTurnStalled = cut && stallCut;
   // #5869: scrub AT REST, synchronously, before anything reads the file back. The explicit shell
   // wait above drains the live stderr scrubber first; this pass is defense in depth for redaction.
   try { writeFileSync(ERRF, redactKeys(readFileSync(ERRF, "utf8"))); } catch {}
@@ -854,7 +837,9 @@ exit $turn_exit`;
   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, lastEmptyTurn);
+  // A silent cut names its own verdict (#7752): the exit under it is the sweep's SIGPIPE, never
+  // a provider failure.
+  const verdict = stallCut ? stallVerdict() : 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);
@@ -864,10 +849,11 @@ exit $turn_exit`;
     // actually carried counts.
     if (c) tokens = c.input + c.output + c.cache_read + c.cache_creation;
   }
-  // #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" : lastEmptyTurn ? "empty" : "completed");
+  // #6289: every ledger row names in ONE field what happened to the turn — cut (the box ended
+  // it), stalled (the watchdog window ended it, #7752), 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 ? (stallCut ? "stalled" : "cut") : (effExit !== 0 ? "api-error" : lastEmptyTurn ? "empty" : "completed");
   // #7756: a clean turn that ASKED its assigner is demoted-but-owed, not "completed". The judge
   // (deliverWake's /contracts read) renames the ledger row, so "asked" is what the log keeps.
   let finalOutcome = outcome;
@@ -876,6 +862,10 @@ exit $turn_exit`;
   }
   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: finalOutcome, tokens };
   if (cut) telemetryRow.cut = true;
+  if (stallCut) telemetryRow.stalled = true;
+  // #7752: a cut turn's 141 is the sweep's SIGPIPE, recorded as the cut signal — never read as
+  // a quota or crash pattern downstream.
+  if (cut) { const sig = cutSignalFor(realExit); if (sig) telemetryRow.cutSignal = sig; }
   telemetry(telemetryRow);
   log(`turn ended (exit ${realExit}${effExit !== realExit ? ` → effective ${effExit} (${lastEmptyOutput ? "empty-output" : "auth"})` : ""}, ${((Date.now() - t0) / 1000).toFixed(0)}s)`);
   if (realExit === 0 && effExit === 0) { cmuxStatus("idle", "#8a94a6", "robot"); herdrAgent("idle"); }   // finished this turn, waiting for the next
@@ -1175,12 +1165,10 @@ function askedExcerpt(message) {
     // reply-linked outcomes, and the old stable marker before direct-address logic sees them. Status
     // broadcasts are presence chatter and are dropped rather than saved as future prompt context.
     msgs = msgs.filter(m => !isReceipt(m) && !isStatusBroadcast(m));
-    // #7778: ids in the seen-set were already handed to the model through the session's own inbox
-    // read mid-turn (the reconcile at the last clean turn boundary recorded them). The poll still
-    // serves them — it filters by THIS runner's cursor, not the shared ledger — so the second
-    // reader stands down here, and the cursor adopts the consumed ids so the hub stops re-serving.
-    // Filtering BEFORE the wake/bcast split keeps a dupe out of the demoted-sender notice too:
-    // the seat DID turn on that message, and #7766's notice must not say otherwise.
+    // #7778: ids in the seen-set already reached the model through the session's own inbox read
+    // mid-turn (recorded at the last clean turn boundary). The poll filters by THIS runner's cursor,
+    // not the shared ledger, so the second reader stands down here and the cursor adopts the consumed
+    // ids. Filtering BEFORE the wake/bcast split keeps a dupe out of #7766's demoted-sender notice.
     if (seenLedger.length) {
       const seenIds = new Set(seenLedger.map(e => e.id));
       const dupes = msgs.filter(m => seenIds.has(m.id));
@@ -1258,17 +1246,10 @@ function askedExcerpt(message) {
     log("parked — waiting for the next message");
   }
 
-  // Run the pending batch. The messages are cleared ONLY on exit 0; any other outcome leaves them
-  // queued, on disk, with a backoff — which is the whole point of the change.
-  // #7778 — one message, one delivery, whichever path sees it first. The session's own inbox read
-  // and this runner's /poll are two readers of one bus with no shared cursor: a message the seat
-  // read and answered MID-TURN was re-polled after the turn and woken AGAIN (seen live: a seat
-  // answered inside its turn, then a second turn 16s later re-quoted the same message verbatim).
-  // The hub's deliveredUpTo is the one ledger both paths already write, so at a CLEAN turn
-  // boundary every id above our poll cursor but at-or-below it was necessarily consumed by the
-  // session-side path. Those ids go into the persisted seen-set; the poll filter stands the
-  // second reader down. A failed, parked or hollow turn reconciles NOTHING — dedupe must never
-  // swallow a message the seat still owes, so only full success is trusted to mark history read.
+  // The pending batch is cleared ONLY on exit 0; any other outcome leaves it queued on disk with a
+  // backoff. #7778: the session's inbox read and this /poll are two readers of one bus with no shared
+  // cursor, so a message answered mid-turn was woken AGAIN. The hub's deliveredUpTo is the ledger both
+  // write: at a CLEAN boundary the ids it covers join the seen-set; a failed or parked turn marks nothing.
   async function reconcileSessionReads(upToCursor) {
     try {
       const peer = await api(`/peer?session=${encodeURIComponent(SESSION)}`);
@@ -1343,6 +1324,22 @@ function askedExcerpt(message) {
     // #6134: ONE SESSION PER CARD; a different card starts a fresh CLI session and the seat is told.
     // #7061: bound by SHAPE, not position, so an order opening with what shipped binds the right card.
     const card = wakeCard(wakeForTurn, { session: SESSION });
+    // #7754: the contract carries the integration head as `base: <sha>` — the wake's own line if it
+    // has one, else local main. A sha this worktree cannot resolve is never worked from origin/main:
+    // the card goes to blocked and the assigner is told, and no model turn is spent on it.
+    const base = contractBase(wakeForTurn) || localMainHead();
+    if (base && card && !resolvesHere(base)) {
+      const text = `cannot resolve base ${base} in ${TURN_DIR} (git cat-file -e failed) — #${card} moved to blocked; push or fetch that sha, or name one this worktree can reach`;
+      log(text);
+      await api("/task/update", { id: card, status: "blocked", note: text, by: SESSION }).catch(() => {});
+      const owed = assigners.map(a => a.from).filter(f => f && f !== SESSION);
+      for (const to of (owed.length ? owed : ["all"]))
+        await api("/send", { from: SESSION, to, text, project: PROJ, kind: "alert" }).catch(() => {});
+      pendingWake = [];
+      savePending([], pendingBcast);
+      return;
+    }
+    const baseText = base ? `\n${baseLine(base)}\n` : "";
     const fresh = card > 0 && card !== sessionCard;
     if (card) sessionCard = card;
     const cited = [...new Set(wakeForTurn.flatMap(m => cardRefs(m.text)))];
@@ -1354,7 +1351,7 @@ function askedExcerpt(message) {
         ? `\n(This turn is card #${card} — the wake cites ${cited.length} cards; the rest are context.)\n`
         : "");
     const prompt = composedTurn({
-      wakeText, ctxText, againText: againText + freshText + dutyNudgeDirective(dutyPlan),
+      wakeText, ctxText, againText: againText + freshText + baseText + dutyNudgeDirective(dutyPlan),
       tailText: "\nAct on what's addressed to you, then end your turn.\n\n",
       rulesText: RULES, lessons,
     });
@@ -1370,7 +1367,7 @@ function askedExcerpt(message) {
           // broadcasts, the redelivery note, and any rejection the last step earned. None of it
           // may reach the preamble, or the prefix stops being byte-identical and the cache claim
           // dies quietly (§4.6).
-          observation: [stateObservation, wakeText, ctxText, againText + freshText].filter(Boolean).join("\n"),
+          observation: [stateObservation, wakeText, ctxText, againText + freshText + baseText].filter(Boolean).join("\n"),
         })
         : await runTurn(prompt, fresh, deliveryFails ? `${trigger} (redelivery)` : trigger, { judgeOutcome: askJudge });
     }
@@ -1414,11 +1411,15 @@ function askedExcerpt(message) {
     }
     if (ec) {
       deliveryFails++;
-      // #6131: a silent turn on a seat whose plan reads spent is exhaustion wearing a crash's
-      // clothes. Only that one reason is ever re-read, and only from the seat's own balance rows.
-      let reason = classify(ec);
+      // #7752: a SILENT cut is a stall, whatever the captured text contains — the qwen
+      // specimen's err file carried a "rate-limit" line and the seat was parked exhausted on a
+      // turn the box itself had killed. The wake stays owed (#7759's shape): the queue is kept,
+      // the ladder retries, and the second silent chain parks as "stalled".
+      let reason = lastTurnStalled ? "stalled" : classify(ec);
       let quotaReset = 0;
       if (reason === "empty-output") {
+        // #6131: a silent turn on a seat whose plan reads spent is exhaustion wearing a crash's
+        // clothes. Only that one reason is ever re-read, and only from the seat's balance rows.
         const rows = await balanceRows();
         reason = reasonWithBalances(reason, rows);
         // The rows that just proved the plan is spent also carry when it lifts — a park that names
@@ -1427,9 +1428,10 @@ function askedExcerpt(message) {
       }
       savePending(pendingWake, pendingBcast);
       await reportFailure(ec, "message", pendingWake.length, reason);
-      // #6289: TWO consecutive exit-1 turns on one contract PARK the seat (time-box when the chain
-      // died to cuts, api-error otherwise), holding the queue until `trantor up`.
-      const parkReason = PARKING_REASONS.has(reason) ? reason : (lastTurnCut ? "time-box" : "api-error");
+      // #6289: TWO consecutive failed turns on one contract PARK the seat — "stalled" for a
+      // silent chain (#7752), time-box when the chain died to cuts, api-error otherwise —
+      // holding the queue until `trantor up`.
+      const parkReason = lastTurnStalled ? "stalled" : (PARKING_REASONS.has(reason) ? reason : (lastTurnCut ? "time-box" : "api-error"));
       if (PARKING_REASONS.has(reason) || deliveryFails >= 2) {
         retryAt = await parkSeat(parkReason, pendingWake.length, quotaReset);
         // RUNNER_PARK_MAX_MS is set only by `trantor duty up` (launchd keepalive): past the ceiling,
@@ -1444,7 +1446,9 @@ function askedExcerpt(message) {
           }, wakeIn).unref?.();
         }
         await notifyAssigners(assigners,
-          `⛔ your contract is PARKED on ${SESSION} (${parkReason}) — not retrying · asked: "${asked}"`);
+          reason === "stalled"
+            ? `⛔ your contract is PARKED on ${SESSION} (stalled: two turns silent for the whole watchdog window) — not retrying · asked: "${asked}"`
+            : `⛔ your contract is PARKED on ${SESSION} (${parkReason}) — not retrying · asked: "${asked}"`);
         lastTurnAt = Date.now();
         return;
       }
@@ -1452,7 +1456,9 @@ function askedExcerpt(message) {
       retryAt = Date.now() + wait;
       // The room hears the broadcast above; the one who is actually blocked hears it directly.
       await notifyAssigners(assigners,
-        `⚠️ your contract FAILED on ${SESSION} (exit ${ec}, ${reason}) · retrying in ${Math.round(wait / 1000)}s · asked: "${asked}"`);
+        reason === "stalled"
+          ? `🫥 your contract STALLED on ${SESSION} (no output for the whole watchdog window; ended at the window, not the box) · wake stays owed · retrying in ${Math.round(wait / 1000)}s · asked: "${asked}"`
+          : `⚠️ 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 (turnAsk) {
       // #7756: a clean exit that ASKED is not "done". The wake stays owed — queued on disk with

package/bin/crew.mjs

@@ -9,6 +9,7 @@ import { down, prune } from "./crew/state.mjs";
 import { spawnTerminal, spawnTmux } from "./crew/tmux.mjs";
 import { epochMs, failedAgents, verifyCrew } from "./crew/verify.mjs";
 import { guardCrossProjectUp } from "./crew/worktrees.mjs";
+import { preflightFirstSeat } from "./crew/preflight.mjs";
 import { resolveAgentLaunchSpecs } from "../lib/agent-preferences.mjs";
 import { readConfig } from "../lib/project.mjs";
 
@@ -51,7 +52,7 @@ function connect() {
   call(process.execPath, [join(ctx.root, "bin/connect.mjs")], { env: ctx.env });
 }
 
-function runUp(args, verify = true) {
+async function runUp(args, verify = true) {
   const options = parseUpArgs(args);
   const requested = resolveAgentLaunchSpecs(options.specs, readConfig());
   options.specs = requested.specs;
@@ -67,6 +68,8 @@ function runUp(args, verify = true) {
   connect();
   console.log(`[crew] hub for ${ctx.project}: ${ctx.hub} (baked into every seat; CREW_HUB=<url> overrides)`);
   console.log(`— bringing up crew for ${ctx.project} (${ctx.mux === "terminal" ? "Terminal windows" : ctx.mux}) —`);
+  // #7760: build once in the first seat's worktree before any seat gets a contract.
+  if (!ctx.dry) await preflightFirstSeat(ctx, options.specs[0].split(":")[0]);
   const skipped = [];
   const started = epochMs();
   spawnCrew(options, skipped);
@@ -92,7 +95,7 @@ function runUp(args, verify = true) {
   return reportSkipped(skipped);
 }
 
-function swap(args) {
+async function swap(args) {
   const [oldAgent, replacement, ...flags] = args;
   if (!oldAgent || !replacement) {
     console.log("usage: trantor swap <oldAgent> <newAgent[:provider[/model]]> [--task K --difficulty D]");
@@ -101,7 +104,7 @@ function swap(args) {
   console.log(`— tearing down old seat '${oldAgent}' in ${ctx.project} —`);
   down(ctx, [oldAgent], adapters);
   console.log(`— spawning replacement: ${replacement} —`);
-  const code = runUp([...flags, replacement]);
+  const code = await runUp([...flags, replacement]);
   if (!code) console.log(`— swapped. RESEND the contract to '${replacement.split(":")[0]}' (it joined fresh with no context). —`);
   return code;
 }
@@ -110,7 +113,7 @@ let code = 0;
 if (command === "down") code = down(ctx, rawArgs, adapters);
 else if (command === "prune") { prune(ctx, adapters); console.log(`— pruned dead crew rows (${ctx.statePath}) —`); }
 else if (command === "open") code = openOrchestrator(ctx, rawArgs);
-else if (command === "swap") code = swap(rawArgs);
-else if (command === "up") code = guardCrossProjectUp(ctx) ? runUp(rawArgs) : 1;
+else if (command === "swap") code = await swap(rawArgs);
+else if (command === "up") code = guardCrossProjectUp(ctx) ? await runUp(rawArgs) : 1;
 else { usage(); code = 1; }
 process.exit(code);

package/bin/turn-watchdog.mjs

@@ -2,7 +2,10 @@
 // Turn watchdog (#5684, reworked #6206). runTurn is spawnSync — the runner cannot watch its own
 // turn — so this DETACHED helper does: armed at turn start, disarmed by turn end. A turn past
 // the window with NO new activity earns ONE direct stall report to the foreman (episode, never a
-// timer storm), and the turn is never killed — reporting is the whole job.
+// timer storm). With no stall file (report-only mode) the turn is never killed — reporting is
+// the whole job. With one (#7752, kill mode) a turn silent on EVERY channel for the whole
+// window is also ENDED at the window: the marker tells the runner's shell box to sweep early,
+// so the kill itself still lives in exactly one place — the shell that owns $job.
 //
 // #6206: stdout silence is NOT a stall — `claude -p` prints nothing until the turn ends by
 // design, so a seat editing five files was reported STALLED while its transcript advanced.
@@ -12,13 +15,13 @@
 // instance id, so a survivor of a replaced runner exits on mismatch or runner death instead of
 // re-matching the NEW runner's turn number (the 09:47 false alarm was exactly that orphan).
 //
-//   node bin/turn-watchdog.mjs <stampFile> <errFile> <windowMs> <session> <project> <hubUrl> <transcriptDir> <workDir>
-import { readFileSync, statSync, readdirSync } from "node:fs";
+//   node bin/turn-watchdog.mjs <stampFile> <errFile> <windowMs> <session> <project> <hubUrl> <transcriptDir> <workDir> [stallFile]
+import { readFileSync, writeFileSync, statSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { hostId } from "../lib/project.mjs";
 import { signedPost } from "../hooks/lib/api.mjs";
 
-const [stampFile, errFile, windowMsRaw, session, project, hub, transcriptDir = "", workDir = ""] = process.argv.slice(2);
+const [stampFile, errFile, windowMsRaw, session, project, hub, transcriptDir = "", workDir = "", stallFile = ""] = process.argv.slice(2);
 // SAFETY: the 10-minute floor lives in crew-runner.mjs (the default when TRANTOR_TURN_WATCHDOG_MS
 // is unset); this fallback only covers a missing argument. Drills pass tiny windows on purpose.
 const windowMs = Number(windowMsRaw) || 10 * 60 * 1000;
@@ -71,6 +74,37 @@ let baseErr = errSize();
 const armedAt = armed.startedAt || Date.now();
 const SLACK = 2000;   // timestamp granularity + scheduler drift under load
 
+// #7752 kill mode: poll liveness continuously and, on a whole window of silence on EVERY
+// channel, write the stall marker, report once, exit. The runner's shell box sweeps the CLI
+// when it sees the marker, so a silent turn ends at the window instead of burning the box.
+// stderr liveness is measured ROLLING here (growth since the last poll, not since arm): the
+// question is "any bytes in this window", not "any bytes ever".
+if (stallFile) {
+  const poll = Math.max(250, Math.min(windowMs / 4, 10000));
+  let lastErrAt = armedAt;
+  for (;;) {
+    await sleep(poll);
+    const s = readStamp();
+    if (!s || s.turn !== armed.turn || (armed.runner && s.runner !== armed.runner)) process.exit(0); // turn ended, or a NEWER runner owns the stamp now
+    if (!runnerAlive()) process.exit(0);                       // our runner is gone — never speak for it
+    const now = Date.now();
+    const size = errSize();
+    if (size > baseErr + 200) { baseErr = size; lastErrAt = now; }   // new bytes: alive
+    const freshCut = Math.max(armedAt, now - windowMs - SLACK);
+    const tr = transcriptDir ? newestMtime(transcriptDir) : 0;
+    const wk = workDir ? newestMtime(workDir) : 0;
+    if (tr > freshCut || wk > freshCut || now - lastErrAt < windowMs) continue;   // producing work: alive
+    try { writeFileSync(stallFile, ""); } catch {}
+    const mins = Math.round((now - armedAt) / 60000);
+    const orch = `${hostId()}:${project}`;
+    const text = `⏱ ${session} turn STALLED — ${mins}m with no activity (turn ${s.turn}; last seen: ${describeLast({ tr, wk })}, stderr ${baseErr > 0 ? `${baseErr}B` : "silent"}); ending the turn at the stall window, not the box.`;
+    // Direct = wake. The foreman first; if this seat IS the foreman's own runner, say it to all.
+    const to = orch === session ? "all" : orch;
+    try { await signedPost(`${hub}/send`, { from: session, to, text, project }, { session }); } catch {}
+    process.exit(0);                                            // one report per turn, by construction
+  }
+}
+
 for (;;) {
   await sleep(windowMs);
   const s = readStamp();

package/hooks/lib/hollow-move.mjs

@@ -12,8 +12,14 @@ const TEST_CMD_RE = /(node\s+test\/|npm\s+(run\s+)?test|pnpm\s+test|yarn\s+test|
 // 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;
 
+// #7754: the note names the sha it verified against, or a gate cannot tell green-on-the-wrong-base
+// from green. Required on its own, not only when every other piece of evidence is missing too.
+const VERIFIED_AT_RE = /\bverified at\s+([0-9a-f]{7,40})\b/i;
+const VERIFIED_AT_MISSING = "verified-at sha in the note";
+
 export const hasTestCommand = (note) => TEST_CMD_RE.test(String(note || ""));
 export const declaresNoCode = (note) => NOCODE_RE.test(String(note || ""));
+export const namesVerifiedSha = (note) => VERIFIED_AT_RE.test(String(note || ""));
 
 function git(cwd, args) {
   return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
@@ -48,6 +54,11 @@ export function hollowVerdict(cwd, id, note, checklist) {
   } 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);
+  const evidenceless = missing.length === 4;
+  const unanchored = !namesVerifiedSha(note);
+  // The flag names only what tripped it: the four evidence gaps together, or the missing sha alone.
+  if (!evidenceless) missing.length = 0;
+  if (unanchored) missing.push(VERIFIED_AT_MISSING);
+  const hollow = (evidenceless || unanchored) && !declaresNoCode(note);
   return { checked: true, hollow, missing };
 }

package/lib/classify-failure.mjs

@@ -37,6 +37,20 @@ 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;
 
+/** #7752: what a CUT turn's exit says about WHY the CLI died. 141 is 128+13 — SIGPIPE: the time
+ *  box's sweep ends a CLI still holding the turn's pipes, so the pipe death is the box's
+ *  signature, recorded in the ledger row as the cut signal. Any other exit is not a signal. */
+export function cutSignalFor(exit) {
+  return Number(exit) === 141 ? "SIGPIPE" : "";
+}
+
+/** #7752: the verdict line for a SILENT cut — a turn that put bytes on neither stream and
+ *  advanced no transcript for the whole watchdog window, ended by the runner at the window
+ *  instead of the box. Named here so the drill pins the exact string the ledger carries. */
+export function stallVerdict() {
+  return "classified stalled because no bytes on either stream and no transcript advance for the whole watchdog window";
+}
+
 // ---- 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,
@@ -87,6 +101,11 @@ export function classifyFailure(exit, errText, emptyOutput = false, emptyTurn =
   if (emptyOutput) return { reason: "empty-output", matched: "exit 0 with no output on either stream" };
   const t = String(errText || "").toLowerCase();
   if (exit === 127) return { reason: "missing-cli", matched: "exit 127 — command not found" };
+  // #7099/#7752: 141 is the box's own signature (SIGPIPE — the sweep ended a CLI still holding
+  // the turn's pipes), recorded as the cut signal. The provider's answer never landed, so no
+  // quota or crash pattern may match it: a captured "rate-limit" line once parked a silent
+  // qwen seat as exhausted on a turn the box itself had killed.
+  if (Number(exit) === 141) return { reason: "cut-signal", matched: "exit 141 — SIGPIPE from the time box sweep, not a provider failure" };
   // #5684: a provider BACKEND failure is not quota — it wants retry/swap, not a window wait.
   // The specimen (#5683): codex's "unexpected status 404 Not Found … /responses/compact" was
   // labelled "exhausted" and the operator was advised to wait out a window that did not exist.