flowviant 0.116.0 → 0.124.0

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

@@ -33,6 +33,7 @@
  *   workChildren.mjs       the live CLI children, teardown, the admission
  *   workAgentPublish.mjs   pushing and fetching an agent's branch
  *   workPlaceReports.mjs   the worktree readout: settle, burst, sweep
+ *   workArtifactReconcile.mjs an idle agent's stored delivery against its worktree
  *   workReportQueue.mjs    every settle, held and retried until delivered
  *   workSessionTokens.mjs  the per-session work credential
  *   workNarration.mjs      the tab's live line and the deferral sentence
@@ -40,17 +41,22 @@
  *   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,
  *   workAgentTurns, workAgentMerges, workProcesses; and out of workAgentTurns,
- *   SOLID F036: workAgentTurnReports, workAgentTurnExecution,
- *   workAgentTurnBegun, workAgentTurnOutcome)
+ *   SOLID F036: workAgentTurnReports, workAgentTurnExecution, workAgentTurnBegun,
+ *   workAgentTurnOutcome; the live brief: workAgentBrief, workAgentBriefRunner)
  */
 
 import { createWorkProcesses } from './workProcesses.mjs';
@@ -71,6 +77,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';
@@ -86,6 +93,7 @@ import { warn } from './ui.mjs';
 import { FLOWVIANT_OWN_PATHS } from './knowledgeLibrary.mjs';
 import { buildArtifactUpload, changedSince, snapshotArtifacts } from './artifacts.mjs';
 import { createArtifactReporter } from './artifactReporter.mjs';
+import { createWorkArtifactReconcile } from './workArtifactReconcile.mjs';
 import { renderDesignPreview } from './artifactPreview.mjs';
 import { scrub as envScrub, secretIn as envSecretIn } from './uplinkScrub.mjs';
 
@@ -150,6 +158,13 @@ export function createWorkManager({
     listChanged: changedSince,
     buildUpload: buildArtifactUpload,
     renderPreview: renderDesignPreview,
+    // What each place held, per owner, beside its worktree's git dir: it dies
+    // with the worktree, so a recreated one proves no discard (artifactIteration.mjs).
+    // `sessionMetaPath` and `worktreeBornAt` are declared below; both are called only once the manager is built.
+    seenPath: (dir, owner) =>
+      /^[A-Za-z0-9_-]{1,64}$/.test(String(owner)) ? sessionMetaPath(dir, 'flowviant-artifacts-seen', owner) : null,
+    // …and when that worktree was cut, so rows stored before it are never its own.
+    placeBornAt: (dir) => worktreeBornAt(dir),
   });
   /**
    * Snapshot a place's artifact directory before a CLI spawns in it — and make
@@ -186,7 +201,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, worktreeBornAt } =
     createWorkPlaces({ repoRoot, baseDir, baseRef, onRepoChanged });
   const { sessionGroups, noteSessionGroup, pruneSessionGroups, sessionProcesses } =
     createWorkSessionGroups({ repoRoot });
@@ -194,6 +209,15 @@ export function createWorkManager({
     createWorkChildren({ extraLiveTurns });
   const { agentPublished, agentRemoteAt, publishAgentBranch, fetchPublishedBranch } =
     createWorkAgentPublish({ repoRoot, gitNet });
+  const { reconcileIdleArtifacts } = createWorkArtifactReconcile({
+    artifacts,
+    placeLocks,
+    inPlace,
+    placeDir,
+    beforeArtifacts,
+    getArtifactsAccepted,
+    log: (line) => warn(line),
+  });
   const { reportSessionWorktree, reportPlaceWorktrees, burstListeners, reportWorktrees } =
     createWorkPlaceReports({
       repoRoot,
@@ -211,7 +235,6 @@ export function createWorkManager({
   const {
     pendingWorkReports,
     pendingShipReports,
-    postBestEffort,
     REJECT_RETRY_MS,
     settleWorkTurn,
     settleShip,
@@ -232,8 +255,9 @@ export function createWorkManager({
   const { fetchAttachments, fetchAgentFiles } = createWorkAttachments();
   const { sessionRuntime, agyRegistryLookup } = createWorkSessionRuntime({ sessionMetaPath });
   const { carryDirtyState } = createAdoptCarry({ sessionMetaPath });
-  const { processWorkTurns, workAnswering } = createWorkSessionTurns({
+  const { processWorkTurns, interruptWorkTurns, workAnswering } = createWorkSessionTurns({
     repoRoot,
+    baseRef,
     baseDir,
     getMcpUrl,
     getArtifactsAccepted,
@@ -241,7 +265,7 @@ export function createWorkManager({
     inPlace,
     workChildren,
     workAttempts,
-    sessionPlaces,
+    notePlace,
     placeOf,
     placeWtFor,
     sessionMetaPath,
@@ -282,8 +306,9 @@ export function createWorkManager({
 
   const { processPrJobs } = createWorkPullRequests({
     placeOf,
+    placeDir,
+    branchAt,
     repoRoot,
-    baseDir,
     baseRef,
     gitNet,
     landed,
@@ -298,6 +323,8 @@ export function createWorkManager({
     baseDir,
     gitNet,
     baseRef,
+    placeDir,
+    branchAt,
     placeWtFor,
     sessionMetaPath,
     shipping,
@@ -341,7 +368,7 @@ export function createWorkManager({
   });
   const { runReviewEntry } = createWorkAgentReview({ runCheck, runPrecheck });
 
-  const { processAgentTurnJobs, settleAgentTurns, agentTurns, agentChildren, agentReported } = createWorkAgentTurns({
+  const { processAgentTurnJobs, interruptAgentTurns, settleAgentTurns, agentTurns, agentChildren, agentReported } = createWorkAgentTurns({
     REJECT_RETRY_MS,
     baseRef,
     inPlace,
@@ -433,7 +460,7 @@ export function createWorkManager({
   return {
     flushWorkReports,
     learnPlaces,
-    processWorkTurns,
+    processWorkTurns, interruptWorkTurns,
     processShipJobs,
     processDiffJobs,
     processKillJobs,
@@ -445,8 +472,10 @@ export function createWorkManager({
     shutdownPreviews,
     retireWorkSessions,
     reportWorktrees,
+    reconcileIdleArtifacts,
     shutdownWork,
     workBusy,
+    runningAgentCount: () => agentTurns.size,
     // The machine's own admission answer, and what it is counting. Handed to
     // the loop so the lanes it owns — the wiki cartographer (wikiRunner.mjs) — ask the
     // same question, and so the machine snapshot can charge memory to the work
@@ -456,10 +485,12 @@ export function createWorkManager({
     liveTurnCount,
     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.
+    processAgentTurnJobs, interruptAgentTurns,
+    // 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) {

package/bin/lib/workAgentBrief.mjs

@@ -0,0 +1,92 @@
+/** A readout alongside ONE running CLI, never another worker on its branch.
+ * No events since the last snapshot means no model call. A stopped child,
+ * pause, park or lost holder prevents a call or a late result from publishing. */
+import { AGENT_BRIEF_SYSTEM, parseAgentBrief, briefModelFor } from './agentBrief.mjs';
+
+export const AGENT_BRIEF_INTERVAL_MS = 3 * 60_000;
+export const AGENT_BRIEF_FIRST_MS = 20_000;
+export const AGENT_BRIEF_INPUT_MAX = 24_000;
+export function makeAgentBrief({ runtime, model, context, summarize, post, scrub = (s) => s, models = () => [], now = Date.now,
+  setTimer = setTimeout, clearTimer = clearTimeout }) {
+  let running = false;
+  let stopped = false;
+  let timer = null;
+  let sequence = 0;
+  let consumed = 0;
+  let entries = [];
+  let flight = null;
+  let controller = null;
+  let held = null;
+  const append = (kind, data) => {
+    if (stopped || data == null) return;
+    // Scrub before trimming so a cut never turns a secret into an unrecognized prefix.
+    let text;
+    try {
+      text = (typeof data === 'string' ? scrub(data) : JSON.stringify(data, (_key, value) => {
+        // Redact decoded strings BEFORE JSON escapes quotes and newlines;
+        // otherwise a multiline secret no longer matches its learned value.
+        if (typeof value === 'string') return scrub(value);
+        if (value && typeof value === 'object' && !Array.isArray(value))
+          return Object.fromEntries(Object.entries(value).map(([key, item]) => [scrub(key), item]));
+        return value;
+      })).slice(0, 4_000);
+    } catch { return; } // an optional readout must never fail the working CLI
+    if (!text.trim()) return;
+    entries.push({ seq: ++sequence, kind, text });
+    while (entries.length > 100 || entries.reduce((sum, e) => sum + e.text.length, 0) > AGENT_BRIEF_INPUT_MAX) entries.shift();
+  };
+  const schedule = (ms = AGENT_BRIEF_INTERVAL_MS) => {
+    if (timer || stopped || !running) return;
+    timer = setTimer(() => { timer = null; void tick(); }, ms);
+    timer?.unref?.();
+  };
+  const refresh = async () => {
+    if (!running || stopped || (!held && sequence === consumed)) return;
+    // Retry a paid-for reading without paying for another. The API rechecks
+    // holder and turn in the write, and duplicate/older snapshots cannot win.
+    if (held) { if (await post(held)) held = null; return; }
+    const brain = briefModelFor(runtime, typeof model === 'function' ? model() : model, models());
+    if (!brain) return;
+    controller = new AbortController();
+    const state = await context(controller.signal);
+    if (state?.unsupported) { stopped = true; if (timer) clearTimer(timer); timer = null; return; }
+    if (stopped || !running || !state?.active || controller.signal.aborted) return;
+    // Card changes and daemon restarts do not reset the agent's three-minute
+    // cadence. Both dates came from the server, not this machine's clock.
+    if (state.brief && Date.parse(state.sourceAt) - Date.parse(state.brief.updatedAt) < AGENT_BRIEF_INTERVAL_MS) return;
+    const through = sequence;
+    const events = entries.filter((e) => e.seq > consumed);
+    if (!events.length) return;
+    const prompt = JSON.stringify({ previous: state.brief ?? null, taskId: state.taskId ?? null,
+      omittedEvents: Math.max(0, events[0].seq - consumed - 1), events: events.map(({ kind, text }) => ({ kind, text })) });
+    const out = await summarize({ runtime, ...brain, system: AGENT_BRIEF_SYSTEM, prompt, signal: controller.signal });
+    if (stopped || !running || controller.signal.aborted) return;
+    const content = parseAgentBrief(typeof out === 'string' ? out : out?.out, scrub);
+    if (!content) return;
+    consumed = through;
+    entries = entries.filter((e) => e.seq > through);
+    held = { ...content, sourceAt: state.sourceAt ?? new Date(now()).toISOString(), ...(out?.usage ? { usage: out.usage } : {}) };
+    if (await post(held)) held = null;
+  };
+  const tick = () => {
+    if (flight) return flight;
+    flight = refresh().catch(() => {}).finally(() => { flight = null; controller = null; schedule(); });
+    return flight;
+  };
+  return {
+    append, tick,
+    running(active) {
+      running = active;
+      if (active) schedule(AGENT_BRIEF_FIRST_MS);
+      else { if (timer) clearTimer(timer); timer = null; controller?.abort(); }
+    },
+    async stop() {
+      stopped = true;
+      running = false;
+      if (timer) clearTimer(timer);
+      timer = null;
+      controller?.abort();
+      await flight;
+    },
+  };
+}