flowviant 0.125.5 → 0.125.7

package/bin/lib/subagentBounds.mjs

@@ -0,0 +1,20 @@
+/** HOW MANY NATIVE CHILDREN ONE CARD RUN RECORDS, THE FIELD CAPS EACH
+ *  CARRIES, AND THE STATUSES A CHILD HAS (2026-10-18, the SOLID pass). The
+ *  server folds at most `TRACE_AGENT_CAP` children per run, clamps each field
+ *  (`agentTraceAgents.ts`) and refuses a handed route to a child it did not
+ *  keep, so every daemon reader that tracks a child keeps the same bound: a
+ *  33rd is never half-reported, admitted by the controller while the trace
+ *  sheds its descriptor. The cap was spelled eight times across the
+ *  controller, the trace relay, runTurn and both Codex readers (the
+ *  codexSubagentEvents split had copied it), and nothing held it to the
+ *  server. A leaf of its own because trace.mjs, which the web's tests import,
+ *  reads it (mcpReportBounds.mjs argues the same); scripts/check-app-parity.mjs
+ *  holds it to the API's `TRACE_AGENT_CAP`/`TRACE_AGENT_FIELD_CAPS` and the
+ *  shared `SUBAGENT_STATUSES`. */
+
+export const SUBAGENT_CAP = 32;
+/** In the order the trace relay sends them. */
+export const SUBAGENT_FIELD_CAPS = Object.freeze({ kind: 80, title: 200, now: 400, brief: 4_000 });
+export const SUBAGENT_STATUSES = Object.freeze(['running', 'waiting', 'asked', 'stopped', 'done']);
+/** A child that has finished or been stopped: the controller revives neither. */
+export const SETTLED_SUBAGENT_STATUSES = Object.freeze(['done', 'stopped']);

package/bin/lib/trace.mjs

@@ -61,12 +61,16 @@
 
 import { THINK_MARKER, scrubNativeText } from './runtimeEvents.mjs';
 import { withoutTurnDeclaration } from './turnDeclaration.mjs';
+import { MAX_MCP_SERVERS, MCP_NAME_MAX, MCP_STATUSES } from './mcpReportBounds.mjs';
+import { SUBAGENT_CAP, SUBAGENT_FIELD_CAPS, SUBAGENT_STATUSES } from './subagentBounds.mjs';
 
 /** One batch every two seconds — the discipline the tab's narrator keeps, for
  *  the same reason: a turn emits hundreds of entries and nobody is reading them
  *  faster than that. */
 export const TRACE_FLUSH_MS = 2_000;
-/** Entries per POST. Matches the server's own per-batch cap. */
+/** Entries per POST. Matches the server's own per-batch cap
+ *  (`agentTrace.ts.TRACE_BATCH_CAP`), which refuses a larger batch whole;
+ *  scripts/check-app-parity.mjs rule 38 holds the two equal. */
 export const TRACE_BATCH = 40;
 /** Entries held while the uplink is down. Past this the OLDEST go: a trace is
  *  scrollback, and the newest steps are the ones somebody watching wants. The
@@ -77,7 +81,7 @@ export const TRACE_BUFFER = 120;
  * (`agentTrace.ts.TRACE_PROSE_CAP`); doing it here too means a pathological line
  * never becomes the POST. The two must move together — daemon at or below the
  * server's, or the server silently does the cutting and this file's caps stop
- * describing what ships.
+ * describing what ships. scripts/check-app-parity.mjs rule 38 holds them equal.
  *
  * 300 UNTIL 2026-09-16, when it was the thing clipping sentences. A trace entry
  * used to be the humanized 160-char label the console prints, so a 300 cap could
@@ -120,6 +124,7 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
    *  by the bare-marker collapse in `prose()` and nothing else. */
   let lastEntry = null;
   const agentReadings = new Map();
+  const mcpSaid = new Set();
   let dirty = orchestrationVersion === 2;
   let markerPending = dirty;
   let timer = null;
@@ -266,13 +271,13 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
       if (!update?.id) return;
       const clean = (v, n) => scrubNativeText(v, n, scrub);
       const fields = {};
-      for (const [key, cap] of Object.entries({ kind: 80, title: 200, now: 400, brief: 4_000 }))
+      for (const [key, cap] of Object.entries(SUBAGENT_FIELD_CAPS))
         if (typeof update[key] === 'string') fields[key] = clean(update[key], cap);
       if (typeof fields.now === 'string') fields.now = fields.now.replace(/\s+/g, ' ').trim();
-      if (['running', 'waiting', 'asked', 'stopped', 'done'].includes(update.status)) fields.status = update.status;
+      if (SUBAGENT_STATUSES.includes(update.status)) fields.status = update.status;
       const previous = agentReadings.get(update.id) ?? {};
       if (agentReadings.has(update.id) && Object.entries(fields).every(([k, v]) => previous[k] === v)) return;
-      if (!agentReadings.has(update.id) && agentReadings.size >= 32) return;
+      if (!agentReadings.has(update.id) && agentReadings.size >= SUBAGENT_CAP) return;
       const reading = { ...previous, ...fields };
       agentReadings.set(update.id, reading);
       // A later update repairs metadata whose first report was shed while
@@ -286,6 +291,26 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
     doing(agentId, text) {
       push({ k: 'doing', agentId: scoped(agentId), t: scrub(String(text)).slice(0, TRACE_PROSE_CAP) });
     },
+    /**
+     * WHAT THE CLI SAID OF ITS MCP SERVERS AT START (2026-10-17): Claude's
+     * init lists each with its status. A server that failed to start read to
+     * the agent and the person as "no MCP access", so each one not connected
+     * is said on the root stream, once per run. No list is unknown and says
+     * nothing; connected is good news and says nothing either.
+     */
+    mcpStatus(servers) {
+      if (!Array.isArray(servers)) return;
+      const fresh = [];
+      for (const s of servers.slice(0, MAX_MCP_SERVERS)) {
+        if (!s || typeof s.name !== 'string' || s.status === 'connected') continue;
+        const name = scrubNativeText(s.name, MCP_NAME_MAX, scrub).replace(/\s+/g, ' ').trim();
+        const status = MCP_STATUSES.has(s.status) ? s.status : 'other';
+        if (!name || mcpSaid.has(`${name}\0${status}`) || mcpSaid.size >= 4 * MAX_MCP_SERVERS) continue;
+        mcpSaid.add(`${name}\0${status}`);
+        fresh.push(`${name} (${status})`);
+      }
+      if (fresh.length) push({ k: 'note', t: scrub(`The CLI reported MCP servers that are not connected: ${fresh.join(', ')}.`).slice(0, TRACE_PROSE_CAP) });
+    },
     flush,
     /** No more entries, no more timers. The queue survives so a final flush can
      *  still deliver it. */

package/bin/lib/turnDeclaration.mjs

@@ -2,7 +2,7 @@
  * normalization/caps; the unmodified answer still goes to parseTurnResult.
  * Only standalone objects and JSON/unlabelled fences count. Code examples
  * inside prose or another language's fence stay as the CLI wrote them. */
-import { jsonObjectClosers } from './agentPlan.mjs';
+import { jsonObjectClosers } from './modelJson.mjs';
 
 const statuses = new Set(['delivered', 'blocked', 'prerequisite', 'nothing']);
 function declaration(body) {

package/bin/lib/turnDiagnostics.mjs

@@ -4,9 +4,10 @@
  * Logging is best effort and rides the daemon's existing bounded private log.
  */
 import { randomUUID } from 'node:crypto';
-import { accessSync, constants, readFileSync, realpathSync, statSync } from 'node:fs';
+import { accessSync, constants, realpathSync, statSync } from 'node:fs';
 import { delimiter, isAbsolute, resolve } from 'node:path';
 import { AUTH_ENV_VARS, claudeAuthContext, claudeCredentialPath } from './claudeAuth.mjs';
+import { settingsAt } from './claudeSettingsArg.mjs';
 import { scrub } from './uplinkScrub.mjs';
 import { printableText } from './printable.mjs';
 import { measuredRuntimeVersion } from './runtimeDetection.mjs';
@@ -47,17 +48,13 @@ function createTurnDiagnostics({ runtime, bin, env, cwd = process.cwd(), profile
   const executable = executableFor(bin, env, cwd);
   let settingsEnv = {};
   if (runtime === 'claude') {
-    const at = args.indexOf('--settings');
-    if (at >= 0) {
-      try {
-        const input = args[at + 1];
-        const settings = JSON.parse(input.startsWith('{') ? input : readFileSync(input, 'utf8'));
-        if (settings.env && typeof settings.env === 'object' && !Array.isArray(settings.env)) {
-          for (const [key, value] of Object.entries(settings.env))
-            if (typeof value === 'string') settingsEnv[key] = value;
-        }
-      } catch { /* CLI settings unavailable */ }
-    }
+    try {
+      const { settings } = settingsAt(args);
+      if (settings?.env && typeof settings.env === 'object' && !Array.isArray(settings.env)) {
+        for (const [key, value] of Object.entries(settings.env))
+          if (typeof value === 'string') settingsEnv[key] = value;
+      }
+    } catch { /* CLI settings unavailable */ }
   }
   // Only byte counts, including each terminating NUL. No values or hashes.
   const argSizes = [bin, ...args].map(value => Buffer.byteLength(value) + 1);

package/bin/lib/turnReceipts.mjs

@@ -0,0 +1,64 @@
+/**
+ * A TURN'S COMMIT RECEIPTS — every sha that landed on its branch while it ran
+ * (2026-10-18, the SOLID pass).
+ *
+ * The rule was spelled three times: the agent run's `commitsBetween`, the
+ * lane's catch (which settles a turn whose run threw, and computed the same
+ * receipts over what the run had measured), and a multi-repository place's
+ * per-repository log (repositoryPlaces.mjs). Two incidents live in it — the
+ * base commits reported as a turn's own, and the six-hour re-run below — so a
+ * fix to one copy that missed another was the risk. A leaf: it imports only
+ * git.mjs's guarded read.
+ *
+ * Every sha that landed on this branch between two points. Measured, never
+ * asserted — this is the whole reason an agent is not asked for its own.
+ *
+ * `--not <base>` and `--no-merges`, because `from..HEAD` alone reports
+ * BASE'S commits as this turn's receipts the moment anything folds base in
+ * — which the stale path does on purpose before a merge. A receipt naming
+ * somebody else's commit is worse than a missing one.
+ *
+ * IT CANNOT THROW, and that guard is the whole point of it being here.
+ *
+ * `git()` throws on a non-zero exit, and `baseRef()` is built from the
+ * project's Base branch setting — free text an owner types, never verified
+ * against the remote. Point it at a branch with no tracking ref (`develop`
+ * on a repo whose remote branch is `dev`) and this exits "fatal: ambiguous
+ * argument". The throw escaped `runAgentTurn` AFTER the CLI had already run
+ * the card, so `postAgentTurn` was never reached, the server never settled
+ * the turn, and the next poll handed back the identical turn — the same
+ * card re-run every poll for six hours, on the operator's shared account,
+ * piling commits onto the review branch, silently.
+ *
+ * An unreadable range means we cannot MEASURE the receipts, which is a
+ * smaller failure than not settling: the turn still reports, and ship-time
+ * reconciliation books whatever no card claimed. Missing beats fabricated
+ * and both beat a stall.
+ *
+ * THE CAP IS THE WIRE'S: agent-turn-done takes `commits` up to 50
+ * (machineAgentTurns.routes.ts), so a longer list is a settle refused.
+ */
+import { gitOrNull } from './git.mjs';
+
+/** The most receipts one settle carries — the API's `commits` max. */
+export const TURN_COMMITS_MAX = 50;
+
+/** The shas on `wt`'s HEAD since `from` and not on `base`, merges left out,
+ *  newest first and capped; `[]` for a range git cannot read. */
+export function commitsSince(wt, from, base) {
+  const out = gitOrNull(['log', '--format=%H', '--no-merges', `${from}..HEAD`, '--not', base], wt);
+  return out?.split('\n').map((x) => x.trim()).filter(Boolean).slice(0, TURN_COMMITS_MAX) ?? [];
+}
+
+/**
+ * The receipts one agent turn settles with: a multi-repository card's own
+ * (`repositoryReceipts()`, every writable repository's, a sha once), else
+ * this worktree's since `before`. `baseRef` is the lane's function, read only
+ * when there is a range to read; no `before` (no worktree, or a branch with
+ * no commits yet) is none.
+ */
+export function turnCommits({ repositoryReceipts, wt, before, baseRef }) {
+  return repositoryReceipts
+    ? [...new Set(repositoryReceipts().map((r) => r.sha))].slice(0, TURN_COMMITS_MAX)
+    : before ? commitsSince(wt, before, baseRef()) : [];
+}

package/bin/lib/turnSubagents.mjs

@@ -0,0 +1,91 @@
+/**
+ * THE NATIVE CHILDREN ONE CLI TURN STARTS, OBSERVED — the readers that follow
+ * them, the bound a turn with no orchestrator keeps on them, and its exit
+ * sweep (2026-10-18, the SOLID pass).
+ *
+ * Split out of runTurn.mjs, the one spawn point every lane uses, because
+ * watching a CLI's own subagents is a second vocabulary with its own reasons
+ * to change: Claude's background agents (its stream, and the agent_progress
+ * rows only its transcript keeps) and Codex's collab children (their
+ * rollouts) arrived in four commits in three days, each another runtime-id
+ * arm inside the spawn function. runTurn keeps the process and its parent
+ * stream; this keeps the children, and a third CLI with native subagents is
+ * an arm here. The Codex thread's close-time reads (its plan windows, its
+ * model) stay in runTurn: they are the turn's, not a child's.
+ *
+ * Two rules ride with it, each argued where it lives below: an orchestrator
+ * bounds and settles its own records, so only an unowned turn is counted
+ * here; and native transcript reads are readouts, so the drain at close is
+ * bounded and never holds the card's answer.
+ */
+
+import { handleStreamLine } from './claudeStream.mjs';
+import { createClaudeSubagents } from './claudeSubagents.mjs';
+import { createClaudeSubagentProgress } from './claudeSubagentProgress.mjs';
+import { createCodexSubagentReader } from './codexSubagents.mjs';
+import { SUBAGENT_CAP } from './subagentBounds.mjs';
+
+/**
+ * `sinks` are the turn's own: its console, activity, tool-event and text
+ * sinks, which a Claude child's transcript rows feed as its stream does.
+ */
+export function createTurnSubagents({ runtime, cwd, since, env, owned, onSubagent, onSpawnResult, resumeThreadId,
+  sinks: { emit, onActivity, onToolEvent, appendText } }) {
+  // An orchestrator bounds its own records and settles them at close
+  // (orchestrator.mjs). Counted here by stream id, refused retries used up
+  // the 32 and later children's updates were dropped; the exit sweep
+  // reported 'stopped' off stream state the controller had already settled.
+  const agentStates = new Map();
+  const reportSubagent = (update) => {
+    if (!update?.id) return;
+    if (!owned) {
+      if (!agentStates.has(update.id) && agentStates.size >= SUBAGENT_CAP) return;
+      agentStates.set(update.id, update.status ?? agentStates.get(update.id) ?? 'running');
+    }
+    onSubagent?.(update);
+  };
+  const subagents = createClaudeSubagents(reportSubagent);
+  const claudeProgress = runtime === 'claude' && onSubagent ? createClaudeSubagentProgress({
+    cwd, since, env,
+    onLine: line => handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, appendText,
+      answerFromResult: true, subagents }),
+  }) : null;
+  const codexAgents = runtime === 'codex' && onSubagent ? createCodexSubagentReader({
+    since, env,
+    onSubagent: reportSubagent, onActivity, onToolEvent,
+    onSpawnResult,
+  }) : null;
+  const resumed = runtime === 'codex' && typeof resumeThreadId === 'string' ? resumeThreadId : null;
+  if (resumed) codexAgents?.thread(resumed);
+  return {
+    /** Claude's child bookkeeping, handed to the parent stream's reader. */
+    collector: subagents,
+    /** Claude's session, off its init: whose transcript to follow. */
+    session: (id) => claudeProgress?.session(id),
+    /** Codex's thread, off `thread.started`: whose rollouts to follow. */
+    thread: (id) => codexAgents?.thread(id),
+    /** A child update the Codex exec stream carried. */
+    update: (update) => codexAgents?.update(update),
+    /** The spawn failed: the readers stop, unawaited. */
+    abandon() {
+      void codexAgents?.stop();
+      void claudeProgress?.stop();
+    },
+    async drain(capMs) {
+      // Native transcript reads are readouts too: a stuck filesystem must
+      // not hold the card's answer. Readers stop scheduling before draining.
+      let progressTimer;
+      try {
+        await Promise.race([
+          Promise.all([codexAgents?.stop(), claudeProgress?.stop()]),
+          new Promise(resolve => { progressTimer = setTimeout(resolve, capMs); }),
+        ]);
+      } finally { clearTimeout(progressTimer); }
+    },
+    /** After the drain: a child an unowned turn still reads as live ended with it. */
+    sweep() {
+      for (const [id, status] of agentStates)
+        if (status === 'running' || status === 'waiting') reportSubagent({ id, status: 'stopped' });
+    },
+  };
+}

package/bin/lib/turnUsage.mjs

@@ -1,12 +1,15 @@
 /**
  * ONE TURN'S TOKENS, ADDED UP ACROSS THE SPAWNS THAT MADE IT (2026-09-28).
  *
- * The agent lane SETS its usage — one spawn, one `result` — and leaves the
- * adding-up to the server. The Terminal tab, the capture chat and the wiki
- * are different: a tab turn whose resume came back empty runs a fresh retry
- * in the same turn, and BOTH spawns spent real tokens; reporting only the
- * second would under-count exactly the turns that went wrong. So those lanes
- * sum what each spawn reported before the one settle carries it.
+ * A turn can be more than one spawn: a tab turn whose resume came back empty
+ * runs a fresh retry in the same turn, and an agent turn resumes its CLI
+ * after an internal wait (agentInternalWait.mjs) or to commit a repository's
+ * work (repositoryDelivery.mjs). Every spawn spent real tokens; reporting
+ * only the last would under-count exactly the turns that went wrong. So the
+ * Terminal tab, the capture chat, the planner, the wiki and the agent lane
+ * (since 2026-10-18, the SOLID pass) sum what each spawn reported through
+ * this, and the server still charges once, behind the one settle that
+ * carries it.
  *
  * The wire shape is the agent lane's, unchanged: `{input, output,
  * cacheCreate, cacheRead, runtime}`. Null-safe on both sides — a spawn that

package/bin/lib/update.mjs

@@ -39,7 +39,7 @@ import { platform, arch } from 'node:process';
 import { pipeline } from 'node:stream/promises';
 import { Readable } from 'node:stream';
 import { relaunchSelf, runningCompiledBinary, runningViaNpx, selfArgv, terminalCommand } from './launchCommand.mjs';
-import { VERSION } from './config.mjs';
+import { DAEMON_INSTANCE, VERSION } from './config.mjs';
 import { compareVersions, versionBelow } from './versionOrder.mjs';
 import { note, ok, warn } from './ui.mjs';
 
@@ -194,6 +194,9 @@ export function reexec(teardown, { viaNpx = false, target = null } = {}, deps =
       // as a rival and the new daemon SIGTERMed this proxy. instance.mjs adopts
       // the lock from this pid when it is really an ancestor of the successor.
       FLOWVIANT_REEXEC_FROM: String(process.pid),
+      // WHO THE SUCCESSOR IS, to the server: this process's own instance, so
+      // the idle tabs' session leases are already its own (config.mjs).
+      FLOWVIANT_DAEMON_INSTANCE: DAEMON_INSTANCE,
       // WHAT WE RESTARTED IN ORDER TO BECOME. The successor compares its own
       // VERSION against this: if it came back still short, the update did not
       // take (a registry serving a stale `latest`, an npx cache that refused to
@@ -223,9 +226,20 @@ export function updateRestartFailed(target) {
   return nowVsAttempted === -1 && targetVsAttempted !== null && targetVsAttempted <= 0;
 }
 
-/** Install @latest globally. Throws on failure (EACCES without sudo, offline…). */
-function installLatest() {
-  execFileSync('npm', ['install', '-g', 'flowviant@latest'], { ...npmOutsideCheckout(), stdio: 'inherit' });
+/**
+ * HOW LONG A GLOBAL INSTALL MAY TAKE (2026-10-19). The install is synchronous
+ * — it holds the event loop for as long as npm runs — and it had no bound, so
+ * a registry or a lock that hung npm hung the whole daemon: no poll, no wake,
+ * no turn, on a machine that read as connected. Five minutes is far past a
+ * real install; past it npm is killed and the failure is the usual one,
+ * retried in fifteen minutes.
+ */
+export const INSTALL_TIMEOUT_MS = 5 * 60_000;
+
+/** Install @latest globally. Throws on failure (EACCES without sudo, offline,
+ *  past `INSTALL_TIMEOUT_MS`…). `exec` and `timeoutMs` are the test seams. */
+export function installLatest({ exec = execFileSync, timeoutMs = INSTALL_TIMEOUT_MS } = {}) {
+  exec('npm', ['install', '-g', 'flowviant@latest'], { ...npmOutsideCheckout(), stdio: 'inherit', timeout: timeoutMs, killSignal: 'SIGKILL' });
 }
 
 /**

package/bin/lib/versionOrder.mjs

@@ -2,7 +2,11 @@
  * VERSION ORDER — the one parser and comparator every version decision on this
  * box uses: the takeover downgrade guard (instance.mjs), the self-update
  * signals (update.mjs, fleet.mjs), the behind marks in the read-only views
- * (views.mjs) and the newest nvm Node (loginPath.mjs).
+ * (views.mjs), the newest nvm Node (loginPath.mjs), and the measured CLI
+ * floors — Claude's and Codex's orchestration (orchestratorHooks.mjs,
+ * runtimeCodex.mjs) and the Codex sandbox helper's (codexResearch.mjs
+ * `CODEX_HELPER_MIN`, read by codexProjectRead.mjs too; 2026-10-18, the SOLID
+ * pass: both kept a hand-rolled reducer and the same spelled-out floor).
  *
  * Split out (SOLID F005) because four hand-written rules disagreed on a
  * version they could not read: one called it EQUAL, one called each
@@ -40,3 +44,9 @@ export function compareVersions(a, b) {
 
 /** True only when BOTH parse and `a` is strictly older. Unknown is not older. */
 export const versionBelow = (a, b) => compareVersions(a, b) === -1;
+
+/** True only when BOTH parse and `a` is at or above `b`. Unknown is not at least. */
+export const versionAtLeast = (a, b) => {
+  const o = compareVersions(a, b);
+  return o === 0 || o === 1;
+};

package/bin/lib/work.mjs

@@ -55,9 +55,9 @@
  *   (and, split earlier: workDiffs, workPreviews, workPullRequests, workShip,
  *   workAgentPlans, workAgentCheck, workAgentPrecheck, workAgentReview,
  *   workAgentTurns, workAgentRecovery, workAgentMerges, workMergeBatch,
- *   workProcesses; and out of workAgentTurns,
- *   SOLID F036: workAgentTurnReports, workAgentTurnExecution, workAgentTurnBegun,
- *   workAgentTurnOutcome; repositoryPlaces + agentRepositories: multi-repo places; the live brief: workAgentBrief, workAgentBriefRunner)
+ *   workProcesses; out of workAgentTurns, SOLID F036: workAgentTurnReports,
+ *   workAgentTurnExecution, workAgentTurnBegun, workAgentTurnOutcome; out of that run (SOLID, 2026-10-18): workAgentTools, workAgentTurnShape, workAgentResume;
+ *   repositoryPlaces + agentRepositories: multi-repo places; the live brief: workAgentBrief, workAgentBriefRunner)
  */
 
 import { trackedRepositorySetup } from './repositorySetup.mjs';
@@ -65,6 +65,7 @@ import { createRepositoryPlaces } from './repositoryPlaces.mjs';
 import { createAgentRepositories } from './agentRepositories.mjs';
 import { createWorkProcesses } from './workProcesses.mjs';
 import { createWorkAgentMerges } from './workAgentMerges.mjs';
+import { createWorkMergeBatch } from './workMergeBatch.mjs';
 import { createWorkAgentTurns } from './workAgentTurns.mjs';
 import { createAgentRecovery } from './workAgentRecovery.mjs';
 import { createWorkAgentCheck } from './workAgentCheck.mjs';
@@ -249,7 +250,7 @@ export function createWorkManager({
     flushWorkReports,
     sweepMergedSessionBranch,
   } = createWorkReportQueue({
-    repoRoot,
+    repoRoot, journalDir: baseDir,
     baseRef,
     workAttempts,
     artifacts,
@@ -260,7 +261,7 @@ export function createWorkManager({
   });
   const { workTokens, mintWorkToken } = createWorkSessionTokens({ getLeaseTtl });
   const { makeNarrator, sayTurnDeferred, lastDeferSaid } = createWorkNarration();
-  const { fetchAttachments, fetchAgentFiles } = createWorkAttachments();
+  const { fetchTabFiles, fetchAgentFiles } = createWorkAttachments();
   const { sessionRuntime, agyRegistryLookup } = createWorkSessionRuntime({ sessionMetaPath });
   const { carryDirtyState } = createAdoptCarry({ sessionMetaPath });
   const { processWorkTurns, interruptWorkTurns, workAnswering } = createWorkSessionTurns({
@@ -286,7 +287,7 @@ export function createWorkManager({
     sessionRuntime,
     agyRegistryLookup,
     carryDirtyState,
-    fetchAttachments,
+    fetchTabFiles,
     makeNarrator,
     sayTurnDeferred,
     lastDeferSaid,
@@ -391,9 +392,8 @@ export function createWorkManager({
     fetchAgentFiles,
   });
   const { processAgentMergeJobs, agentMerges } = createWorkAgentMerges({
-    runCheck, workChildren, groupKillChildren, admit,
-    repositoryPlaces,
-    repoRoot,
+    runBatch: createWorkMergeBatch({ repositoryPlaces, repoRoot, baseDir, inPlace, runCheck, workChildren, groupKillChildren, admit, onRepoChanged, landed }),
+    repositoryPlaces, repoRoot,
     inPlace,
     baseDir,
     gitNet,

package/bin/lib/workAgentMerges.mjs

@@ -1,13 +1,12 @@
-import { createWorkMergeBatch } from './workMergeBatch.mjs';
 import { mergeRepositoryPlace } from './repositoryMerge.mjs';
 import { fleetRequest } from './fleetPost.mjs';
 /** Agent merge claims, pull-request approval, and branch cleanup. */
-import { ensureOpenPr, ghReady, mergeAndVerifyTip, PR_URL_RE, relayedFailure } from './prWorkflow.mjs';
+import { ensureOpenPr, ghReady, mergeAndVerifyTip, PR_URL_RE, relayedFailure, relayedText } from './prWorkflow.mjs';
 import { existsSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { join } from 'node:path';
 import { FLEET_URL, DAEMON_INSTANCE } from './config.mjs';
-import { git, gitOrNull, gitNet as gitNetIn, baseBranchName, isSafePathSegment, sessionBranch, stripUrlUserinfo } from './git.mjs';
+import { git, gitOrNull, gitNet as gitNetIn, baseBranchName, isSafePathSegment, sessionBranch } from './git.mjs';
 import { isPublishRef, publishPushArgs, publishDeleteArgs, publishErrorText } from './agentPublish.mjs';
 import { mergeOutward as shipMergeOutward } from './shipMerge.mjs';
 import { gitMergeIn } from './gitMergeIdentity.mjs';
@@ -29,11 +28,11 @@ export function agentMergeFailureDetail(error) {
     .map((value) => String(value ?? '').trim())
     .filter(Boolean)
     .join('\n');
-  return envScrub(stripUrlUserinfo(output || String(error?.message || error))).slice(0, 2000);
+  return relayedText(output || String(error?.message || error)).slice(0, 2000);
 }
 
 export function createWorkAgentMerges({
-  runCheck, workChildren = new Map(), groupKillChildren = new Set(), admit,
+  runBatch,
   repositoryPlaces,
   repoRoot,
   inPlace,
@@ -116,7 +115,7 @@ export function createWorkAgentMerges({
     const report = async (body) => {
       reported = true;
       if (body?.ok === true) landedRef = job.publishedRef ?? null;
-      await postAgentMerge({ ...body, ...(body.detail ? { detail: envScrub(stripUrlUserinfo(String(body.detail))).slice(0, 2000) } : {}) });
+      await postAgentMerge({ ...body, ...(body.detail ? { detail: relayedText(String(body.detail)).slice(0, 2000) } : {}) });
     };
 
     // A WRITER on the place, exactly as a ship is. It folds base in and pushes
@@ -436,7 +435,6 @@ export function createWorkAgentMerges({
     }
   };
 
-  const runBatch = createWorkMergeBatch({ repositoryPlaces, repoRoot, baseDir, inPlace, runCheck, workChildren, groupKillChildren, admit, onRepoChanged, landed });
   const processAgentMergeJobs = (jobs) => {
     if (!Array.isArray(jobs) || jobs.length === 0) return;
     for (const job of jobs.slice(0, 2)) {

package/bin/lib/workAgentPrecheck.mjs

@@ -106,11 +106,11 @@ export function createWorkAgentPrecheck({ baseRef, admit, sessionMetaPath, workC
   /**
    * THE BRANCH'S OWN COMMITS, subject + trailers, and the card ids they name.
    *
-   * MEASURED, never asserted — the same reason `commitsBetween` exists. The
-   * trailer ids are what let the prompt say "N earlier cards' specs are not on
-   * this box" honestly: the difference between the cards this branch claims and
-   * the specs this disk holds is a fact, and a box that adopted the agent
-   * mid-run is exactly the case where it is non-zero.
+   * MEASURED, never asserted — the same reason `commitsSince` exists
+   * (turnReceipts.mjs). The trailer ids are what let the prompt say "N earlier
+   * cards' specs are not on this box" honestly: the difference between the
+   * cards this branch claims and the specs this disk holds is a fact, and a box
+   * that adopted the agent mid-run is exactly the case where it is non-zero.
    *
    * IT CANNOT THROW. `baseRef()` is free text an owner typed and may name no
    * ref at all; an unreadable range costs the reviewer its context, never the

package/bin/lib/workAgentRecovery.mjs

@@ -4,6 +4,7 @@ import { isSafePathSegment, sessionBranchRef, gitNetAsync } from './git.mjs';
 import { begunTurnRefusal } from './workAgentTurnBegun.mjs';
 import { fleetEndpoint } from './fleetWire.mjs';
 import { fleetRequest } from './fleetPost.mjs';
+import { AGENT_PLACE_PREFIX } from './workPlaces.mjs';
 
 /** Inspect before any cut or CLI. A failed request waits for the next poll. */
 export function createAgentRecovery({
@@ -32,7 +33,7 @@ export function createAgentRecovery({
     for (const job of [...jobs.slice(next), ...jobs.slice(0, next)]) {
       if (!job || !isSafePathSegment(job.agentId) || !isSafePathSegment(job.placeId) ||
           sessionBranchRef(job.placeId) === null || typeof job.sourceKey !== 'string' ||
-          !job.sourceBoxId || job.sourceBoxId === id || job.placeId !== `a-${job.agentId}`) continue;
+          !job.sourceBoxId || job.sourceBoxId === id || job.placeId !== `${AGENT_PLACE_PREFIX}${job.agentId}`) continue;
       const key = `${job.sourceBoxId}:${job.sourceKey}`;
       if (ready.get(job.agentId) === key) { ready.delete(job.agentId); continue; }
       blocked.add(job.agentId);