flowviant 0.115.0 → 0.117.0

package/bin/lib/vault.mjs

@@ -27,16 +27,79 @@ import {
 } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { join, relative, sep } from 'node:path';
+import { gitRaw } from './git.mjs';
 import { planVaultSync } from './vaultDiff.mjs';
 
 const SYNC_STATE = '.flowviant-sync.json';
 
-/** Create the vault dir + its private git history (best-effort). */
+/**
+ * EVERY GIT CALL IN THE VAULT, AND NONE OF THE VAULT'S OWN PROGRAMS
+ * (2026-10-10, the audit). The vault is a directory a cartographer turn writes:
+ * Codex's wiki profile can write all of it, `.git` included, and Claude's list
+ * denies its `.git` only as far as the CLI keeps its word. A `core.fsmonitor`
+ * planted in `<vault>/.git/config` ran on the daemon's own `git add -A` — the
+ * daemon, with the daemon's environment, outside every turn's fence — and a
+ * planted hook would run on its `git commit`. So the daemon's git here runs
+ * with the monitor off and hooks pointed at nothing, and commits `--no-verify`.
+ * Command-line `-c` outranks every config file.
+ */
+const VAULT_GIT_FENCE = Object.freeze(['-c', 'core.fsmonitor=false', '-c', 'core.hooksPath=/dev/null']);
+export function vaultGit(args, dir) {
+  return execFileSync('git', [...VAULT_GIT_FENCE, ...args], { cwd: dir, stdio: 'ignore' });
+}
+
+/**
+ * …AND NO PROGRAM THE VAULT'S CONFIG NAMES. `-c` can switch off the monitor
+ * and the hooks by name, but not a program the config invents a name for: a
+ * `[filter "x"] clean = <cmd>` beside a `.gitattributes` of `* filter=x` ran
+ * on the fenced `git add -A` all the same (measured, git 2.55), and so would a
+ * `gpg.program` under `commit.gpgSign`. Nothing a vault needs is in its config
+ * beyond what `git init` writes, so a config holding anything else was not the
+ * daemon's — and the local commit is skipped, in words, rather than run. The
+ * sync itself is unaffected: it reads files, never git. A config git cannot
+ * read is the same answer.
+ */
+const INIT_CONFIG_KEYS = new Set([
+  'core.repositoryformatversion',
+  'core.filemode',
+  'core.bare',
+  'core.logallrefupdates',
+  'core.ignorecase',
+  'core.precomposeunicode',
+  'core.symlinks',
+  'extensions.objectformat',
+  'extensions.refstorage',
+]);
+export function vaultConfigForeignKey(dir) {
+  let listed;
+  try {
+    // `--local` reads the config THIS repository resolves to — through a
+    // planted `commondir` or a `.git` file too. It does NOT follow includes
+    // (a file option turns them off), so an `include.path` is caught by its
+    // own key (measured, git 2.55). Reading config runs nothing.
+    listed = gitRaw([...VAULT_GIT_FENCE, 'config', '--local', '--list', '-z'], dir, { stdio: ['ignore', 'pipe', 'ignore'] });
+  } catch {
+    return '(unreadable)';
+  }
+  // `-z`: each entry is `key\nvalue\0`, so a value with a newline in it
+  // cannot pass for a key of its own.
+  for (const entry of listed.split('\0')) {
+    if (!entry) continue;
+    const key = entry.split('\n')[0].toLowerCase();
+    if (!INIT_CONFIG_KEYS.has(key)) return key;
+  }
+  return null;
+}
+
+/** Create the vault dir + its private git history (best-effort). With NO
+ *  template (2026-10-10): a person's `init.templateDir` can carry a `config`
+ *  of its own, which `git init` copies in (measured, git 2.55) — and which the
+ *  check above would then refuse on every sync. A vault needs none of it. */
 export function ensureVault(dir) {
   mkdirSync(dir, { recursive: true });
   if (!existsSync(join(dir, '.git'))) {
     try {
-      execFileSync('git', ['init', '-q'], { cwd: dir, stdio: 'ignore' });
+      vaultGit(['init', '-q', '--template='], dir);
     } catch {
       /* git unavailable — the vault still works, just unversioned */
     }
@@ -68,14 +131,19 @@ function walkMd(dir, base = dir, out = [], errors = { count: 0 }) {
 
 /** Best-effort local history commit — identity pinned so it works on machines
  *  with no global git config, and never touches the user's identity. */
-function commitVault(dir, message) {
+function commitVault(dir, message, warn) {
+  // No `.git` of its own (git was unavailable at init, or a turn removed it):
+  // unversioned — and never a `git add -A` that walks UP into whatever
+  // repository encloses the vault.
+  if (!existsSync(join(dir, '.git'))) return;
+  const foreign = vaultConfigForeignKey(dir);
+  if (foreign) {
+    warn(`wiki vault history not committed — its git config holds \`${foreign}\`, which Flowviant did not write (${dir})`);
+    return;
+  }
   try {
-    execFileSync('git', ['add', '-A'], { cwd: dir, stdio: 'ignore' });
-    execFileSync(
-      'git',
-      ['-c', 'user.name=flowviant', '-c', 'user.email=wiki@flowviant.local', 'commit', '-q', '-m', message],
-      { cwd: dir, stdio: 'ignore' }
-    );
+    vaultGit(['add', '-A'], dir);
+    vaultGit(['-c', 'user.name=flowviant', '-c', 'user.email=wiki@flowviant.local', 'commit', '-q', '--no-verify', '-m', message], dir);
   } catch {
     /* nothing to commit / git unavailable — fine */
   }
@@ -124,6 +192,6 @@ export async function syncVault({ dir, url, token, userAgent, finalize, grounded
   }
 
   writeFileSync(join(dir, SYNC_STATE), JSON.stringify(plan.state));
-  commitVault(dir, plan.finalized ? `sweep${groundedAtSha ? ` @ ${groundedAtSha.slice(0, 7)}` : ''}` : `update${groundedAtSha ? ` @ ${groundedAtSha.slice(0, 7)}` : ''}`);
+  commitVault(dir, plan.finalized ? `sweep${groundedAtSha ? ` @ ${groundedAtSha.slice(0, 7)}` : ''}` : `update${groundedAtSha ? ` @ ${groundedAtSha.slice(0, 7)}` : ''}`, warn);
   return { pages: plan.pages, uploaded: plan.uploaded, deleted: plan.deleted };
 }

package/bin/lib/vaultDiff.mjs

@@ -21,9 +21,12 @@ import { createHash } from 'node:crypto';
 
 // Mirror the server contract (shared schema) — a page that violates it is
 // skipped with a warning (and carried forward if previously synced), never
-// allowed to 400 the whole request and wedge the sync.
+// allowed to 400 the whole request and wedge the sync. The release parity gate
+// (scripts/check-app-parity.mjs, 2026-10-10, audit F142) holds these to the
+// shared WIKI_VAULT_* names, CHUNK_FILES within the per-request file cap, and
+// isSafePath to isSafeVaultPath over a vector list.
 export const MAX_FILE_BYTES = 262_144;
-const MAX_PATH_CHARS = 300;
+export const MAX_PATH_CHARS = 300;
 export const MAX_FILES = 400;
 export const CHUNK_FILES = 30;
 export const CHUNK_BYTES = 700_000;

package/bin/lib/views.mjs

@@ -7,32 +7,37 @@
  * status line for a server that did not answer is left out, never guessed.
  */
 
-import { execFileSync, spawn } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import { closeSync, existsSync, openSync, readSync, statSync } from 'node:fs';
-import { FLEET_URL, USER_AGENT, VERSION } from './config.mjs';
+import { StringDecoder } from 'node:string_decoder';
+import { APP_URL, FLEET_URL, USER_AGENT, VERSION } from './config.mjs';
 import { detectRepoRoot, listStoredProjects, projectLabel, resolveStoredCredential } from './credentials.mjs';
 import { desktopStatusRemote, installChannel } from './desktopContract.mjs';
 import { daemonLogPath } from './daemonState.mjs';
+import { git as runGit } from './git.mjs';
 import { daemonRunningFor } from './instance.mjs';
 import { agoFrom } from './machineListing.mjs';
+import { printable, printableText } from './printable.mjs';
 import { detectRuntimes } from './runtimeDetection.mjs';
 import { c } from './ui.mjs';
 import { versionBelow } from './versionOrder.mjs';
 
-const APP_URL = process.env.FLOWVIANT_APP_URL || 'https://app.flowviant.com';
-
 // "Behind" in these views is versionBelow (versionOrder.mjs): an unreadable
 // version is never marked older — a read-only view states nothing it cannot
 // measure.
 
 function agentLine(agent, now) {
-  if (agent.asks) return `${agent.name} · ${c.yellow('asks you a question')}`;
+  // A member names an agent; this prints it to a terminal. Scrubbed like every
+  // other server string this daemon prints (2026-10-10, the audit's F151;
+  // see printable.mjs).
+  const name = printable(agent.name);
+  if (agent.asks) return `${name} · ${c.yellow('asks you a question')}`;
   const since = agent.status === 'working' && !agent.parked && agent.since ? Date.parse(agent.since) : NaN;
   const minutes = Number.isFinite(since) ? Math.max(0, Math.floor((now - since) / 60_000)) : null;
   const took = minutes == null ? '' : ` ${minutes < 60 ? `${minutes}m` : `${Math.floor(minutes / 60)}h ${minutes % 60}m`}`;
   const word = agent.parked ? 'parked' : agent.status;
   const cards = `${agent.delivered} of ${agent.total} ${agent.total === 1 ? 'card' : 'cards'}${agent.delivered ? ' delivered' : ''}`;
-  return `${agent.name} · ${word === 'working' ? c.blue(`working${took}`) : word} · ${cards}`;
+  return `${name} · ${word === 'working' ? c.blue(`working${took}`) : word} · ${cards}`;
 }
 
 /** `flowviant status`, rendered from the same document `status --json --remote` prints. */
@@ -51,7 +56,7 @@ export function renderStatus(status, { now = Date.now() } = {}) {
       lines.push(label('here', `not running — run ${c.cyan('flowviant')} in that repo`));
     } else if (project.running === true) {
       const serves = role === 'serving' ? c.green('serving')
-        : role === 'inactive' ? `inactive${remote?.servingBoxName ? ` — ${remote.servingBoxName} serves this project` : ''}`
+        : role === 'inactive' ? `inactive${remote?.servingBoxName ? ` — ${printable(remote.servingBoxName)} serves this project` : ''}`
         : project.holder === 'serving' ? c.green('serving') : null;
       lines.push(label('here', serves ? `running · ${serves}` : 'running'));
     }
@@ -61,7 +66,9 @@ export function renderStatus(status, { now = Date.now() } = {}) {
     if (agents && agents.length > 0) {
       agents.forEach((agent, i) => lines.push(label(i === 0 ? 'agents' : '', agentLine(agent, now))));
     }
-    if (remote?.pressure?.reason) lines.push(label('waiting', `Waiting for the machine — ${remote.pressure.reason}.`));
+    // The server scrubs these two (machineBoxes.ts, machinePressure.ts); the
+    // CLI keeps its belt, as printable.mjs explains.
+    if (remote?.pressure?.reason) lines.push(label('waiting', `Waiting for the machine — ${printable(remote.pressure.reason)}.`));
     for (const rt of project.runtimes ?? []) {
       if (rt.parkedByLimit && rt.message) lines.push(label('limit', `${rt.id} hit its limit: “${rt.message}”`));
     }
@@ -94,19 +101,36 @@ export function resolveProjectForView(argv = process.argv, cwd = process.cwd())
   };
 }
 
-/** The last `count` lines of a file, read from its end. */
+/**
+ * The last `count` lines of a file, read from its end — PRINTABLE (2026-10-10,
+ * the audit's F133). A daemon before this release logged member-written card
+ * titles raw, so a replay could carry an OSC 52 into whichever terminal runs
+ * `flowviant logs`. `printableText` keeps the lines' shape; a log written on a
+ * TTY loses its colours with everything else.
+ */
 export function tailLines(path, count) {
   const size = statSync(path).size;
   const want = Math.min(size, 256 * 1024);
   const buf = Buffer.alloc(want);
   const fd = openSync(path, 'r');
   try { readSync(fd, buf, 0, want, size - want); } finally { closeSync(fd); }
-  const lines = buf.toString('utf8').split('\n');
+  const lines = printableText(buf.toString('utf8')).split('\n');
   if (lines.at(-1) === '') lines.pop();
   if (want < size) lines.shift(); // the first line is cut mid-way
   return { text: lines.slice(-count).join('\n'), size };
 }
 
+/**
+ * What `logs -f` prints of each new chunk: decoded as a STREAM, because a read
+ * can end inside a multi-byte character, and scrubbed like the tail. A sequence
+ * split across two reads loses its ESC in the first and its terminator in the
+ * second, so what is left of it is plain text.
+ */
+export function createLogFollower() {
+  const decoder = new StringDecoder('utf8');
+  return (buf) => printableText(decoder.write(buf));
+}
+
 export async function runLogs(argv = process.argv) {
   const which = resolveProjectForView(argv);
   if (!which.entry) { console.error(which.message); process.exit(1); }
@@ -125,6 +149,7 @@ export async function runLogs(argv = process.argv) {
   // Poll rather than fs.watch: the daemon rotates the file (a rename), and a
   // watch on the old inode would go quiet exactly then.
   let offset = existsSync(path) ? statSync(path).size : 0;
+  const followed = createLogFollower();
   for (;;) {
     await new Promise((resolve) => setTimeout(resolve, 500));
     if (!existsSync(path)) continue;
@@ -134,7 +159,7 @@ export async function runLogs(argv = process.argv) {
     const buf = Buffer.alloc(size - offset);
     const fd = openSync(path, 'r');
     try { readSync(fd, buf, 0, buf.length, offset); } finally { closeSync(fd); }
-    process.stdout.write(buf);
+    process.stdout.write(followed(buf));
     offset = size;
   }
 }
@@ -173,7 +198,7 @@ export async function runDoctor({ cwd = process.cwd(), fetchImpl = fetch } = {})
   const add = (state, text, fix) => { if (state === false) failed++; lines.push(check(state, text, fix)); };
 
   let git = null;
-  try { git = String(execFileSync('git', ['--version'], { timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] })).trim(); } catch { /* absent */ }
+  try { git = runGit(['--version'], undefined, { timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] }); } catch { /* absent */ }
   add(Boolean(git), git ?? 'git is not installed', 'Install git; agents work in git worktrees.');
 
   const installed = detectRuntimes().filter((rt) => rt.installed);

package/bin/lib/wikiRunner.mjs

@@ -21,24 +21,23 @@
  */
 
 import { existsSync } from 'node:fs';
-import { execFileSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { FLEET_URL, FLEET_TOKEN, USER_AGENT } from './config.mjs';
-import { git, resetWorktree, originSlug, isSafePathSegment } from './git.mjs';
+import { git, gitOrNull, gitRaw, resetWorktree, originSlug, isSafePathSegment, SHA1_ABBREV_RE } from './git.mjs';
 import { c, note, ok, warn } from './ui.mjs';
 import { sawSentinel } from './claude.mjs';
 import { runTurn as defaultRunTurn } from './runTurn.mjs';
 import { SYSTEM_WIKI, WIKI_KICKOFF, SYSTEM_REGROUND, REGROUND_KICKOFF } from './prompts.mjs';
 import { ensureVault, syncVault } from './vault.mjs';
 import { scrub as envScrub } from './uplinkScrub.mjs';
-import { RUNTIMES } from './runtimes.mjs';
+import { runtimeLabel } from './runtimes.mjs';
 import { pickRuntimeFor as defaultPickRuntimeFor } from './runtimeDetection.mjs';
-import { recordMcpServers, recordSkills } from './runtimeCapabilities.mjs';
 import { THINK_MARKER } from './runtimeEvents.mjs';
 import { fleetEndpoint } from './fleetWire.mjs';
-import { postToFleet } from './fleetPost.mjs';
+import { fleetHeaders, postToFleet } from './fleetPost.mjs';
 import { addUsage } from './turnUsage.mjs';
+import { printable } from './printable.mjs';
 
 export function createWikiRunner({
   repoRoot,
@@ -126,11 +125,7 @@ export function createWikiRunner({
     try {
       await fetch(WIKI_PROGRESS_URL, {
         method: 'POST',
-        headers: {
-          Authorization: `Bearer ${FLEET_TOKEN}`,
-          'User-Agent': USER_AGENT,
-          'Content-Type': 'application/json',
-        },
+        headers: fleetHeaders(),
         signal: AbortSignal.timeout(15_000),
         body: JSON.stringify(safe),
       });
@@ -148,22 +143,10 @@ export function createWikiRunner({
    * sweep queued, for the rest of the day. Best-effort: an older server 404s
    * once and the TTL is still the backstop it always was.
    */
-  const postWikiAbandoned = async () => {
-    try {
-      await fetch(WIKI_ABANDONED_URL, {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${FLEET_TOKEN}`,
-          'User-Agent': USER_AGENT,
-          'Content-Type': 'application/json',
-        },
-        signal: AbortSignal.timeout(15_000),
-        body: '{}',
-      });
-    } catch {
-      /* best-effort — the request's own TTL still expires it */
-    }
-  };
+  // No longer a near copy of `postToFleet` (decisions.md's 2026-09-26 open
+  // item, closed audit 2026-10-10 F136): the same post, on its own 15 s
+  // ceiling. Never throws — the request's own TTL still expires it.
+  const postWikiAbandoned = () => postToFleet(WIKI_ABANDONED_URL, {}, { timeoutMs: 15_000 });
 
   const enqueueSweep = (job) => {
     if (!job || job.requestedAt === lastSweepAt) return;
@@ -187,7 +170,19 @@ export function createWikiRunner({
       type: 'reground',
       intentId,
       prUrl,
-      title: title || 'a delivered task',
+      // A CARD'S TITLE, which any member writes (and intake can seed from a
+      // stranger's ticket), printed by the drain's narration six times and put
+      // in the prompt. SANITIZED AT THE INTAKE like the pages below (2026-10-10,
+      // the audit's F097): an OSC 52 in a title rewrote the operator's
+      // clipboard the moment the card shipped. printable() takes the whole
+      // display-control class, newlines included, so a title is one line.
+      title:
+        (typeof title === 'string'
+          ? printable(title)
+              .replace(/\s+/g, ' ')
+              .trim()
+              .slice(0, 300)
+          : '') || 'a delivered task',
       // What the PLAN thought this would invalidate. A hint, not the truth —
       // the turn still reads the real changed files; this catches pages whose
       // frontmatter file list has drifted, or that document a concept rather
@@ -239,13 +234,11 @@ export function createWikiRunner({
     if (!Array.isArray(shas) || shas.length === 0) return null;
     const files = new Set();
     for (const sha of shas.slice(0, 50)) {
-      if (!/^[0-9a-f]{7,40}$/i.test(String(sha))) continue;
+      // git.mjs's SHA-1 shape, either case — the shape this lookup has
+      // always taken (audit 2026-10-10, F749).
+      if (!SHA1_ABBREV_RE.test(String(sha).toLowerCase())) continue;
       try {
-        const out = execFileSync(
-          'git',
-          ['show', '--name-only', '--pretty=format:', String(sha)],
-          { cwd: repoRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }
-        );
+        const out = gitRaw(['show', '--name-only', '--pretty=format:', String(sha)], repoRoot);
         for (const line of out.split('\n')) {
           const f = line.trim();
           if (f) files.add(f);
@@ -399,12 +392,8 @@ export function createWikiRunner({
             }
           }
           resetWorktree(wikiWt, getBaseRef());
-          let sha = '';
-          try {
-            sha = git(['rev-parse', 'HEAD'], wikiWt);
-          } catch {
-            /* detached/no HEAD — still writes the map, just ungrounded */
-          }
+          // No HEAD → '' — still writes the map, just ungrounded.
+          const sha = gitOrNull(['rev-parse', 'HEAD'], wikiWt) ?? '';
           // Sync the vault after the turn regardless of the sentinel: a died
           // sweep's partial pages still persist (merge, no prune) — only a
           // COMPLETED sweep finalizes, so an interrupted one can't erase pages.
@@ -441,7 +430,7 @@ export function createWikiRunner({
             warn('wiki generation skipped — no installed CLI can run a vault-scoped turn');
             return;
           }
-          const wikiLabel = RUNTIMES[wikiRt].label;
+          const wikiLabel = runtimeLabel(wikiRt);
           if (task.type === 'sweep') {
             sweepAttempts++;
             note(`${c.cyan('wiki')} ${c.dim(`— regenerating: your ${wikiLabel} is reading the repo…`)}`);
@@ -454,19 +443,11 @@ export function createWikiRunner({
               vaultDir,
               runtime: wikiRt,
               label: c.cyan('[wiki]'),
-              streamJson: true,
+              // No skills or connectors are harvested off a wiki turn: it is
+              // fenced (no settings source, strict MCP), so its init names less
+              // than the machine has (runTurn.mjs, `initHarvestFor`).
               onActivity,
               onUsage: onUsage(wikiRt),
-              // FREE SKILLS, off a turn that was running anyway. This stream is
-              // already parsed and its init event already carries the CLI's own
-              // resolved skill set — the same fact a tab turn teaches — so the
-              // only thing missing was the handler. The wiki turn runs in a
-              // detached worktree of THIS repo, so its `.claude/skills` and the
-              // machine's personal ones resolve identically to a tab's.
-              onInit: (i) => {
-                recordSkills(i.skills);
-                recordMcpServers(i.mcpServers);
-              },
               onSpawn: (ch) => {
                 wikiChild = ch;
               },
@@ -512,14 +493,8 @@ export function createWikiRunner({
                 vaultDir,
                 runtime: wikiRt,
                 label: c.cyan('[wiki]'),
-                streamJson: true,
                 onActivity,
                 onUsage: onUsage(wikiRt),
-                // Same free harvest as the sweep above.
-                onInit: (i) => {
-                  recordSkills(i.skills);
-                  recordMcpServers(i.mcpServers);
-                },
                 onSpawn: (ch) => {
                   wikiChild = ch;
                 },
@@ -579,10 +554,14 @@ export function createWikiRunner({
           // Terminal frame so the app cover clears promptly (don't wait for the
           // freshness window to lapse). force-sent past the throttle.
           await postWikiProgress(frame({ done: true, ...(usage ? { usage } : {}) }), true);
-          // Safety net: the wiki turn is read-only on the repo by CONTRACT, but
-          // permission enforcement is a curated tool list, not a path jail —
-          // discard anything a confused turn wrote to the worktree so it can
-          // never leak into a later turn or a push.
+          // Safety net: the wiki turn is read-only on the repo by CONTRACT.
+          // Claude's list writes only the vault (claudePosture.mjs
+          // `wikiPermFor`, 2026-10-10) and Codex's kernel profile likewise,
+          // but Antigravity's flags cannot say "only the vault" — so discard
+          // anything a turn wrote to the worktree before it can leak into a
+          // later turn or a push. It reaches the worktree ONLY: a write
+          // anywhere else is the posture's to refuse, never this reset's to
+          // undo.
           try {
             resetWorktree(wikiWt, getBaseRef());
           } catch {

package/bin/lib/work.mjs

@@ -40,11 +40,16 @@
  *   workSessionRuntime.mjs which CLI a tab speaks, which conversation resumes
  *   workAdoptCarry.mjs     adoption's dirty carry
  *   workSessionTurns.mjs   a tab's turn, start to settle
+ *   workTurnShape.mjs      what that turn is — plain, plan, capture or build —
+ *                          and its prompt pair (pure, 2026-10-10)
  *   workRetire.mjs         held sessions, retirement, manual-place freshening
  *   workToolLog.mjs        one turn's tool cards, folded and capped (pure)
  *   workCommandAudit.mjs   one turn's `$ …` audit, batched to the server
  *   workBrain.mjs          the model and effort a turn may put on argv (pure)
  *   workIntake.mjs         one incoming ticket drafted into a card, read-only (2026-09-28)
+ *   workCappedTurn.mjs     one capped read-only consult turn: its child, its slot,
+ *                          its cap and its transcript — the planner, the pre-review
+ *                          and intake all run one (2026-10-10)
  *   turnLock.mjs           whether a live CLI of ours holds a directory's turn
  *   (and, split earlier: workDiffs, workPreviews, workPullRequests, workShip,
  *   workAgentPlans, workAgentCheck, workAgentPrecheck, workAgentReview,
@@ -71,6 +76,7 @@ import { createWorkChildren } from './workChildren.mjs';
 import { createWorkAgentPublish } from './workAgentPublish.mjs';
 import { createWorkPlaceReports } from './workPlaceReports.mjs';
 import { createWorkReportQueue } from './workReportQueue.mjs';
+import { postBestEffort } from './fleetPost.mjs';
 import { createWorkSessionTokens } from './workSessionTokens.mjs';
 import { createWorkNarration } from './workNarration.mjs';
 import { createWorkAttachments } from './workAttachments.mjs';
@@ -186,7 +192,7 @@ export function createWorkManager({
   const gitNet = (args, ms) => gitNetIn(args, repoRoot, ms);
 
   // ── THE SESSION'S OWN HALF — built first, because the lanes below are handed it.
-  const { sessionPlaces, placeOf, learnPlaces, placeDir, placeWtFor, sessionMetaPath } =
+  const { placeOf, notePlace, learnPlaces, placeDir, branchAt, placeWtFor, sessionMetaPath } =
     createWorkPlaces({ repoRoot, baseDir, baseRef, onRepoChanged });
   const { sessionGroups, noteSessionGroup, pruneSessionGroups, sessionProcesses } =
     createWorkSessionGroups({ repoRoot });
@@ -211,7 +217,6 @@ export function createWorkManager({
   const {
     pendingWorkReports,
     pendingShipReports,
-    postBestEffort,
     REJECT_RETRY_MS,
     settleWorkTurn,
     settleShip,
@@ -241,7 +246,7 @@ export function createWorkManager({
     inPlace,
     workChildren,
     workAttempts,
-    sessionPlaces,
+    notePlace,
     placeOf,
     placeWtFor,
     sessionMetaPath,
@@ -282,8 +287,9 @@ export function createWorkManager({
 
   const { processPrJobs } = createWorkPullRequests({
     placeOf,
+    placeDir,
+    branchAt,
     repoRoot,
-    baseDir,
     baseRef,
     gitNet,
     landed,
@@ -298,6 +304,8 @@ export function createWorkManager({
     baseDir,
     gitNet,
     baseRef,
+    placeDir,
+    branchAt,
     placeWtFor,
     sessionMetaPath,
     shipping,
@@ -457,9 +465,11 @@ export function createWorkManager({
     processAgentPlanJobs,
     processIntakeJobs,
     processAgentTurnJobs,
-    // Only the displacement stand-down calls this — see its comment. Exported
-    // rather than hooked into `shutdownWork` because the signal handlers cannot
-    // await, and a settle that is not awaited is a settle that did not happen.
+    // Only the roster's stand-down calls this — a displacement, a removal or a
+    // commanded stop (holder.mjs, `standDownDisplaced`); see its comment.
+    // Exported rather than hooked into `shutdownWork` because the signal
+    // handlers cannot await, and a settle that is not awaited is a settle that
+    // did not happen.
     settleAgentTurns,
     processAgentMergeJobs,
     freshenManualPlaces,

package/bin/lib/workAdoptCarry.mjs

@@ -6,7 +6,6 @@
  * promise of its own (the source is never written, a problem becomes one line
  * for the agent to say), reached once, from the session lane's adopt path.
  */
-import { execFileSync } from 'node:child_process';
 import { cpSync, lstatSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { git, gitRaw, splitNul } from './git.mjs';
@@ -31,9 +30,8 @@ export function createAdoptCarry({ sessionMetaPath }) {
       // text file) must round-trip byte-exact or the apply corrupts what it
       // carries. 64MB of headroom — a dirtier tree than that fails the read
       // here and is SAID, below, rather than half-applied.
-      const patch = execFileSync('git', ['diff', 'HEAD', '--binary'], {
-        cwd: srcCwd,
-        stdio: ['ignore', 'pipe', 'pipe'],
+      const patch = gitRaw(['diff', 'HEAD', '--binary'], srcCwd, {
+        encoding: 'buffer',
         maxBuffer: 64 * 1024 * 1024,
       });
       if (patch.length) {