flowviant 0.117.0 → 0.124.0

package/bin/lib/workAgentTurnExecution.mjs

@@ -23,6 +23,7 @@ import { gitOrNull } from './git.mjs';
 import { stashCard } from './agentCards.mjs';
 import { c } from './ui.mjs';
 import { runTurn } from './runTurn.mjs';
+import { killGroup } from './processGroup.mjs';
 import { SYSTEM_AGENT_FOR, AGENT_TASK_KICKOFF, AGENT_TASK_SPEC, AGENT_HUMAN_KICKOFF, withProjectContext } from './prompts.mjs';
 import { AGENT_TASK_KINDS, agentTaskKindOf, unknownAgentTaskKind } from './agentTaskKinds.mjs';
 import { knowledgeDirFor } from './knowledgeFiles.mjs';
@@ -30,7 +31,9 @@ import { scrub as envScrub } from './uplinkScrub.mjs';
 import { canRun, runtimeById } from './runtimes.mjs';
 import { toolEventOf, CLAUDE_TOOL_PROSE_KINDS } from './runtimeEvents.mjs';
 import { makeTraceRelay } from './trace.mjs';
-import { readBaseTools, prepareAgentTools } from './projectTools.mjs';
+import { mcpJsonServerNamesAbove, readBaseTools, prepareAgentTools } from './projectTools.mjs';
+import { TURN_PROFILES } from './turnProfile.mjs';
+import { postureToolsNote } from './postureTools.mjs';
 import { runTurnResumingOnce } from './resumeLost.mjs';
 import { INTERNAL_WAIT_CONTRACT, runAgentWithInternalWaits } from './agentInternalWait.mjs';
 import { CODEX_THREAD_RE } from './workSessionRuntime.mjs';
@@ -41,6 +44,7 @@ import { ensureArtifactDir, ensureFenceScratch } from './artifacts.mjs';
 import { agentBrowserHome } from './noWindowEnv.mjs';
 
 export function createAgentTurnExecution({
+  makeBrief,
   baseRef,
   baseDir,
   repoRoot,
@@ -107,7 +111,9 @@ export function createAgentTurnExecution({
    * `releaseSlot` hands back the admission reservation the lane took on this
    * turn's behalf, at the moment the CLI actually exists. Idempotent.
    */
-  const runAgentTurnInPlace = async (job, { turnId, agentId, place, releaseSlot, postAgentTurn, measured }) => {
+  /** `run` is the lane's record of this turn (`interrupted`, set by
+   *  `interruptAgentTurns`); absent, nothing can interrupt it. */
+  const runAgentTurnInPlace = async (job, { turnId, agentId, place, releaseSlot, postAgentTurn, measured, run = { interrupted: false } }) => {
     // WORK THAT HAS BEGUN LIVES ON EXACTLY ONE BOX — read BEFORE anything is
     // cut, because `placeWtFor` would cut a rival branch of the same name. The
     // rule and its three-state branch measurement: workAgentTurnBegun.mjs.
@@ -375,8 +381,8 @@ export function createAgentTurnExecution({
     /**
      * Prose the structured event will carry anyway, dropped so a read does
      * not render twice — but ONLY on a runtime whose stream reaches
-     * `onToolEvent` at all. Codex and agy have their own parsers and never
-     * call it, so dropping their tool prose would blank their agents' traces.
+     * `onToolEvent` here. Codex uses completed activity; agy has its own
+     * parser. Dropping their tool prose would blank their agents' traces.
      * `parse: null` is exactly the claudeStream.mjs stream path. See
      * CLAUDE_TOOL_PROSE_KINDS.
      */
@@ -408,6 +414,9 @@ export function createAgentTurnExecution({
      * ever, which holds the self-update and the tray's install for ever.
      */
     const spawnedChildren = new Set();
+    /** The CLI, unless a person already asked to stop this turn (Interrupt
+     *  now): then nothing starts — no fresh retry, no continuation. */
+    const runCli = (args) => (run.interrupted ? Promise.resolve('') : runTurn(args));
     /**
      * WHAT THIS TURN SPENT, AS THE CLI COUNTED IT (2026-09-19).
      *
@@ -426,6 +435,8 @@ export function createAgentTurnExecution({
     /** THE MODEL THE TURN RAN ON, as its CLI named it (turnModel.mjs) — rides
      *  every settle `usage` rides, for the same reason; null sends no key. */
     let model = null;
+    const brief = makeBrief?.({ agentId, turnId, runtime: rt, model: () => model ?? job.model });
+    brief?.append('prompt', job.task ? { title: job.task.title, message: job.body, discussion: job.cardThread, brief: job.task.brief, criteria: job.task.criteria } : job.body);
     /**
      * THE AGENT'S LAST MESSAGE, ALONE — where the final JSON object lives.
      * Codex's `out` is every message plus stderr plus error text, and
@@ -437,11 +448,32 @@ export function createAgentTurnExecution({
     /** The agent's artifact directory as it stood before this turn — the
      *  tab lane's rule, in the agent's own worktree (2026-09-22). */
     const artifactsBefore = beforeArtifacts(wt);
+    const artifactInstructions = getArtifactsAccepted()
+      ? await artifacts.prepare?.({ placeDir: wt, before: artifactsBefore, agentId }) ?? '' : '';
     let projectTools = null;
     try {
       // A turn reads the base ref afresh. Changes the agent has made to its
       // own worktree cannot silently change the next turn's tools.
       projectTools = prepareAgentTools(readBaseTools(repoRoot, baseRef()), rt, process.env, wt, { codexHome: codexAgentHome });
+      const mountsProjectMcp = TURN_PROFILES[posture]?.projectMcp === true && (rt === 'claude' || rt === 'codex');
+      // A fenced posture on a runner that ignores its own file there (Codex's
+      // `--ignore-user-config`) takes the servers as `fencedMount` instead.
+      const fencedMount = mountsProjectMcp && posture !== 'build' ? projectTools.fencedMount : null;
+      // THE MACHINE'S OWN SERVERS ON CLAUDE (2026-10-11, the owner): the turn
+      // is not strict, and every `.mcp.json` name from the worktree up is
+      // disabled so only the base copy speaks for the project. Null (an
+      // unboundable walk) mounts strictly: the base copy alone.
+      const claudeDisabled = mountsProjectMcp && rt === 'claude' ? mcpJsonServerNamesAbove(wt) : null;
+      // What this card's posture withholds, said to the agent — with the
+      // servers it did and did not mount, and why — so it relays the fence
+      // instead of inventing a setting (postureTools.mjs). Empty for a code card.
+      const toolsNote = postureToolsNote({
+        posture,
+        runtime: rt,
+        mounted: !mountsProjectMcp ? [] : fencedMount ? fencedMount.mounted : projectTools.mcpServers,
+        machine: mountsProjectMcp && (rt === 'codex' || claudeDisabled != null),
+        unmounted: [...projectTools.mcpUnmounted.map((u) => ({ ...u, source: 'project' })), ...(fencedMount ? fencedMount.unmounted : [])],
+      });
       const agentTurnArgs = {
         prompt:
           job.kind === 'task' && job.task
@@ -451,6 +483,8 @@ export function createAgentTurnExecution({
                 // The card's discussion (0.106.0), printed inside THE CARD by
                 // the same builder the stash above wrote down — and the files
                 // on it (0.112.0), after it, the same way.
+                resumeBody: job.body,
+                investigationContext: job.investigationContext,
                 cardThread: job.cardThread,
                 cardFiles: files.card,
                 position: job.position ?? 1,
@@ -458,7 +492,10 @@ export function createAgentTurnExecution({
               })
             : AGENT_HUMAN_KICKOFF({
                 agentName: job.agentName,
+                // INTERRUPT NOW: the previous run was stopped to send this.
+                interrupted: job.interrupted === true,
                 message: job.body ?? '',
+                investigationContext: job.investigationContext,
                 askedByName: job.askedByName,
                 task: job.task,
                 // The discussion on the one card this message is about, in a
@@ -476,26 +513,28 @@ export function createAgentTurnExecution({
         // different things about the same directory.
         // Spoken to the CLI that runs it (0.115.0): a mockup on Codex is
         // told it is Codex, never Claude.
-        system: withProjectContext(SYSTEM_AGENT_FOR(taskKind, runtimeById(rt)?.label), {
+        system: withProjectContext(SYSTEM_AGENT_FOR(taskKind, runtimeById(rt)?.label, { prerequisitesAccepted: job.prerequisitesAccepted === true }), {
           knowledgeDir: knowledgeDirFor(repoRoot),
           // ARTIFACTS (0.94.0), while the server can show one — an agent's
           // land on its page, under the facts row.
           artifacts: getArtifactsAccepted(),
-        }) + `\n\n${INTERNAL_WAIT_CONTRACT}` + (projectTools.instructions ? `\n\n${projectTools.instructions}` : ''),
+        }) + (toolsNote ? `\n\n${toolsNote}` : '') + (artifactInstructions ? `\n\n${artifactInstructions}` : '') + `\n\n${INTERNAL_WAIT_CONTRACT}` + (projectTools.instructions ? `\n\n${projectTools.instructions}` : ''),
         agentTools: projectTools,
-        ...(projectTools.codexHome ? { mcpEnv: { CODEX_HOME: projectTools.codexHome } } : {}),
+        ...((projectTools.codexHome || fencedMount) ? { mcpEnv: { ...(projectTools.codexHome ? { CODEX_HOME: projectTools.codexHome } : {}), ...(fencedMount?.env ?? {}) } } : {}),
         // NOBODY IS AT THIS SCREEN (2026-09-29): no display, BROWSER=none, and
         // a browser profile of the agent's own, kept beside its Codex home —
         // so a Chrome it starts to look at its page never reaches the
         // person's (noWindowEnv.mjs).
         browserHome: agentBrowserHome(sessionMetaPath, wt, agentId),
-        // The base branch's MCP servers, for a code card: Claude's in this
-        // turn's own 0600 file, strictly; Codex's already in its private
-        // home's config.toml (projectToolRuntimes.mjs, 2026-10-10), which
-        // its fenced postures ignore — never `-c` pairs on argv.
-        ...(posture === 'build' && rt === 'claude'
-          ? { mcpArgs: ['--strict-mcp-config', '--mcp-config', projectTools.mcpPath] }
-          : {}),
+        // Reviewed project servers and the machine's configured servers, on
+        // initial cards, answers and review iterations alike.
+        ...(mountsProjectMcp && rt === 'claude'
+          ? {
+              mcpArgs: [...(claudeDisabled ? [] : ['--strict-mcp-config']), '--mcp-config', projectTools.mcpPath],
+              projectMcpServers: projectTools.mcpServers,
+              ...(claudeDisabled ? { machineMcp: claudeDisabled } : {}),
+            }
+          : fencedMount ? { mcpArgs: fencedMount.args } : {}),
         knowledgeDir: knowledgeDirFor(repoRoot),
         // The kind's posture, as the one turn profile (turnProfile.mjs):
         // build for code, the fenced design/research postures otherwise.
@@ -518,6 +557,7 @@ export function createAgentTurnExecution({
         // narrator keeps: overwritten, never appended, and ignored by the
         // board past ~90 seconds.
         onActivity: (a) => {
+          brief?.append(a?.kind ?? 'activity', a?.full ?? a?.label);
           const line = a?.label;
           if (!line) return;
           // THE TRACE TAKES EVERY LINE; the pulse takes one every two
@@ -543,7 +583,13 @@ export function createAgentTurnExecution({
         // Workbench's tool cards are built from, scrubbed at collection by
         // the builder itself (bounded window BEFORE its caps; see
         // toolEventOf). A tool it does not know pushes nothing.
-        onToolEvent: (name, input) => {
+        onToolEvent: (name, input, meta) => {
+          brief?.append(meta?.result ? 'tool result' : 'tool call', meta?.result
+            ? { id: meta.id, exitCode: meta.exitCode, isError: meta.isError, output: meta.output }
+            : { name, input });
+          // Codex request/result pairs feed capture/planner evidence. This
+          // append-only agent trace already relays its completed activity.
+          if (meta?.runtime === 'codex') return;
           trace.tool(toolEventOf(name, input, wt, envScrub));
         },
         // The CLI's own per-turn token counts, off the `result` event. One
@@ -566,6 +612,8 @@ export function createAgentTurnExecution({
         // (runTurn.mjs, `initHarvestFor`). An agent-only box learns from the
         // startup probe and its Terminal tabs.
         onSpawn: (ch) => {
+          brief?.running(true);
+          ch.once('close', () => { if (child === ch) brief?.running(false); });
           child = ch;
           spawnedChildren.add(ch);
           // The AGENT it serves — what the machine snapshot charges this
@@ -583,6 +631,8 @@ export function createAgentTurnExecution({
           // and a place id IS one. It is what lets a hard stop actually reach
           // the CLI — see `retireWorkSessions`.
           agentChildren.set(place, ch);
+          // Asked to stop between the check and the spawn.
+          if (run.interrupted) killGroup(ch);
         },
       };
       /**
@@ -597,7 +647,7 @@ export function createAgentTurnExecution({
        * MENTIONS a missing session is never run twice.
        */
       out = await runAgentWithInternalWaits(
-        (args, continuing) => continuing ? runTurn(args) : runTurnResumingOnce(runTurn, args, {
+        (args, continuing) => continuing ? runCli(args) : runTurnResumingOnce(runCli, args, {
           // A Codex write-up always runs fresh over its copy (codexResearch
           // .mjs), so there is no lost conversation to retry it for.
           resume: rt === 'codex' && posture === 'research' ? false : args.resume,
@@ -615,6 +665,7 @@ export function createAgentTurnExecution({
         } }
       );
     } finally {
+      await brief?.stop();
       // What the CLI counted, for the lane's catch if anything below throws.
       measured.usage = usage;
       measured.model = model;
@@ -664,16 +715,36 @@ export function createAgentTurnExecution({
        * floor: it must never delay the settle behind it.
        */
       void reportSessionWorktree(place).catch(() => {});
-      // …and what it drew to SHOW the person (2026-09-22): uploaded against
-      // the AGENT, so it lands on the agent's page whoever is looking.
-      // Fire-and-forget for the same reason — never delay the settle.
-      void artifacts
-        .report({ placeDir: wt, before: artifactsBefore, agentId, turnId })
-        .catch(() => {});
+      // A file card delivers uploaded bytes, not an in-memory retry. Otherwise
+      // its dependent card can start while Review has nothing to show.
+      await artifacts.report({ placeDir: wt, before: artifactsBefore, agentId, turnId, requireStored: kind.artifact != null });
     }
 
 
     const commits = commitsBetween(wt, before);
+    /**
+     * A PERSON INTERRUPTED IT (Interrupt now). Whatever the CLI printed was
+     * cut off, so there is no outcome to read: the turn reports `interrupted`
+     * with what it measured — the commits it made, its spend, the branch —
+     * and leaves the worktree exactly as the stopped run left it. The message
+     * sent to interrupt it runs next, here, resuming this conversation. No
+     * limit, no park and no review entry: none of that happened.
+     */
+    if (run.interrupted) {
+      measured.ranCli = spawnedChildren.size > 0;
+      await postAgentTurn({
+        turnId,
+        outcome: 'nothing',
+        interrupted: true,
+        ran: spawnedChildren.size > 0,
+        commits,
+        ...(usage ? { usage } : {}),
+        ...(model ? { model } : {}),
+        ...(branch ? { branch } : {}),
+        worktree: wt,
+      });
+      return;
+    }
     // WHAT THE TURN REPORTS is one decision, off what was measured here
     // (workAgentTurnOutcome.mjs). The side effects it implies stay on this
     // side: the machine's limit state, the park, and the review-entry beat.

package/bin/lib/workAgentTurnOutcome.mjs

@@ -25,6 +25,7 @@ import { limitLine } from './cliLimit.mjs';
 import { parseTurnResult } from './agentPlan.mjs';
 import { changedArtifacts, scanArtifacts } from './artifacts.mjs';
 import { scrub as envScrub } from './uplinkScrub.mjs';
+import { usableImageArtifact } from './imageArtifact.mjs';
 
 export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage, model = null, commits, artifactsBefore, branch, wt }) {
   const res = (lastAnswer && parseTurnResult(lastAnswer)) || parseTurnResult(out);
@@ -110,7 +111,8 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
    */
   if (res.outcome === 'delivered' && kind.artifact) {
     const want = kind.artifact.match;
-    const has = (l) => l.some((e) => want.test(e.name));
+    const has = (l) => l.some((e) => want.test(e.name)
+      && (kind.posture !== 'image' || usableImageArtifact(e)));
     const standing = scanArtifacts(wt);
     const wrote = has(changedArtifacts(artifactsBefore, standing));
     const present = wrote || ((job.kind !== 'task' || job.redo === true) && has(standing));
@@ -126,11 +128,18 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
       });
     }
   }
+  const prerequisite = res.prerequisite;
+  const cannotRequest = prerequisite && job.prerequisitesAccepted !== true
+    ? 'This server does not support prerequisite-card requests yet. This work has not been delivered.'
+    : prerequisite?.taskKind === 'image' && (job.runtime ?? 'claude') !== 'codex'
+      ? 'This agent runs on a CLI that cannot generate images. Image cards require Codex’s own image generation; this agent cannot run the requested texture work.'
+      : null;
   return report(
     {
       turnId,
+      ...(prerequisite && !cannotRequest ? { prerequisite } : {}),
       outcome: res.outcome,
-      answer: envScrub(res.answer ?? '').slice(0, 8000),
+      answer: cannotRequest ?? envScrub(res.answer ?? '').slice(0, 8000),
       ...(commits.length ? { commits } : {}),
       // SCRUBBED like the answer beside it: a raised card lands in the
       // project doc every member reads, and a brief quoting the `.env` the

package/bin/lib/workAgentTurns.mjs

@@ -25,6 +25,8 @@ import { c, note } from './ui.mjs';
 import { createAgentTurnReports } from './workAgentTurnReports.mjs';
 import { createAgentTurnExecution } from './workAgentTurnExecution.mjs';
 import { failedTurnSettlement } from './workAgentTurnOutcome.mjs';
+import { killGroup } from './processGroup.mjs';
+import { createAgentBriefRunner } from './workAgentBriefRunner.mjs';
 
 export function createWorkAgentTurns({
   REJECT_RETRY_MS,
@@ -48,6 +50,7 @@ export function createWorkAgentTurns({
   agentRemoteAt,
   /** The turn's files, fetched into its worktree (workAttachments.mjs, 0.112.0). */
   fetchAgentFiles,
+  makeBrief = createAgentBriefRunner({ admit, workChildren }),
 }) {
   const {
     postAgentTurn,
@@ -91,8 +94,23 @@ export function createWorkAgentTurns({
    * directory names, and those are places.
    */
   const agentChildren = new Map(); // placeId -> child process
+  /**
+   * INTERRUPT NOW (2026-10-13) — each turn this lane has taken: its place and
+   * whether a person asked to stop it. A stop kills the CLI's PROCESS GROUP
+   * (it is spawned detached, so the commands it started go with it); a turn
+   * asked to stop before it spawned never spawns.
+   */
+  const agentRuns = new Map(); // turnId -> { place, interrupted }
+  /** Turns answered `ran: false` here, so a roster read made before that
+   *  settle landed is not answered again at once. */
+  const notRunningSaid = new Map(); // turnId -> when
+  /** Agents whose run this lane just stopped: the next turn is the one sent to
+   *  interrupt it, and is told so even when the roster that handed it over was
+   *  read before the stop's settle landed. Taken once, for a little while. */
+  const stoppedFor = new Map(); // agentId -> when
 
   const { runAgentTurnInPlace, commitsBetween } = createAgentTurnExecution({
+    makeBrief,
     baseRef,
     baseDir,
     repoRoot,
@@ -172,12 +190,18 @@ export function createWorkAgentTurns({
     // A WRITER on the agent's own place — see the lane header. Only `a-<id>`
     // places: those are agents' by construction, and anything else here would
     // be a tab's directory, where a turn is a reader by the product's own law.
+    const run = agentRuns.get(turnId) ?? { place, interrupted: false };
     await inPlace(place, place.startsWith('a-'), async () => {
       try {
-        await runAgentTurnInPlace(job, { turnId, agentId, place, releaseSlot, postAgentTurn: settleOnce, measured });
+        await runAgentTurnInPlace(job, { turnId, agentId, place, releaseSlot, postAgentTurn: settleOnce, measured, run });
+        if (run.interrupted && measured.ranCli) stoppedFor.set(agentId, Date.now());
       } catch (error) {
         if (settled) return;
         const commits = measured.wt ? commitsBetween(measured.wt, measured.before) : [];
+        if (run.interrupted) {
+          await postAgentTurn({ turnId, outcome: 'nothing', interrupted: true, ran: true, commits, ...(measured.usage ? { usage: measured.usage } : {}) });
+          return;
+        }
         await postAgentTurn(
           failedTurnSettlement({
             turnId,
@@ -235,7 +259,7 @@ export function createWorkAgentTurns({
     }
   };
 
-  const processAgentTurnJobs = (jobs) => {
+  const processAgentTurnJobs = (jobs, { reportsOnly = false } = {}) => {
     const list = Array.isArray(jobs) ? jobs : [];
     pruneHeldReports(list);
     /** One deferral line per tick, however many turns were offered. */
@@ -244,6 +268,7 @@ export function createWorkAgentTurns({
       const id = String(job?.id || '');
       if (!id || agentTurns.has(id)) continue;
       const held = agentReported.get(id);
+      if (reportsOnly && !held) continue;
       // A body the server REFUSED waits out its backoff — still held, so the
       // CLI is never re-run in the meantime.
       if (held && (agentRejectedUntil.get(id) ?? 0) > Date.now()) continue;
@@ -306,11 +331,16 @@ export function createWorkAgentTurns({
       }
       const releaseSlot = admit.reserve();
       agentTurns.add(id);
-      void runAgentTurn(job, releaseSlot).finally(() => {
+      agentRuns.set(id, { place: String(job.placeId), interrupted: false });
+      const stopped = stoppedFor.get(String(job.agentId));
+      stoppedFor.delete(String(job.agentId));
+      const run = stopped != null && Date.now() - stopped < 120_000 ? { ...job, interrupted: true } : job;
+      void runAgentTurn(run, releaseSlot).finally(() => {
         // Belt for every path that never reached a spawn — the release is
         // idempotent, so the normal case releases twice.
         releaseSlot();
         agentTurns.delete(id);
+        agentRuns.delete(id);
       });
     }
   };
@@ -347,5 +377,31 @@ export function createWorkAgentTurns({
     await Promise.allSettled(posts);
   };
 
-  return { processAgentTurnJobs, settleAgentTurns, agentTurns, agentChildren, agentReported };
+  /**
+   * THE AGENT RUNS A PERSON ASKED TO STOP (`roster.interruptAgentTurns`, read
+   * before the jobs). One this lane is running is stopped — the CLI's group
+   * killed — and reports `interrupted` once its CLI is gone. One that finished
+   * here keeps its own settle. One this lane is not running is answered `ran:
+   * false`, and the server puts it back in the queue untouched.
+   */
+  const interruptAgentTurns = (ids) => {
+    const at = Date.now();
+    for (const [id, when] of notRunningSaid) if (at - when > 30_000) notRunningSaid.delete(id);
+    for (const id of Array.isArray(ids) ? ids : []) {
+      if (typeof id !== 'string' || !id) continue;
+      const run = agentRuns.get(id);
+      if (run) {
+        if (!run.interrupted) note(`${c.cyan('agent')} ${c.dim('— interrupting the running turn')}`);
+        run.interrupted = true;
+        const child = agentChildren.get(run.place);
+        if (child) killGroup(child);
+        continue;
+      }
+      if (agentReported.has(id) || notRunningSaid.has(id)) continue;
+      notRunningSaid.set(id, at);
+      void postAgentTurn({ turnId: id, outcome: 'nothing', interrupted: true, ran: false }).catch(() => {});
+    }
+  };
+
+  return { processAgentTurnJobs, interruptAgentTurns, settleAgentTurns, agentTurns, agentChildren, agentReported };
 }

package/bin/lib/workArtifactReconcile.mjs

@@ -0,0 +1,79 @@
+/**
+ * AN IDLE AGENT'S DELIVERY, RECONCILED WITHOUT A TURN (2026-10-11).
+ *
+ * A local discard reached the server only when a turn settled, so an agent
+ * waiting in Review kept every stored file a daemon had not relayed removing:
+ * the marketing imagery card showed nine images while its worktree held the
+ * two the person kept, and nothing would change until somebody sent another
+ * message. So each agent worktree this machine holds is measured against its
+ * stored inventory once per process, under the place's writer lock and never
+ * beside a turn — the reporter's own evidence rule (artifactIteration.mjs)
+ * decides what is a discard. Only agents: a tab's next turn is the natural
+ * moment to reconcile a conversation, and a delivery in Review has none.
+ *
+ * A failure is said in the log and tried again on a later beat, a bounded
+ * number of times; the stored files stay listed, which is the truth.
+ */
+import { existsSync } from 'node:fs';
+
+/** Attempts per agent per process, and the wait between two of them. */
+const MAX_TRIES = 4;
+const RETRY_MS = 60_000;
+
+export function createWorkArtifactReconcile({
+  artifacts,
+  placeLocks,
+  inPlace,
+  placeDir,
+  beforeArtifacts,
+  getArtifactsAccepted,
+  log = () => {},
+  now = Date.now,
+}) {
+  const done = new Set(); // agent places reconciled by this process
+  const tries = new Map(); // agent place -> { n, at }
+  let sweeping = null;
+
+  const reconcileOne = async (place) => {
+    const wt = placeDir(place);
+    if (!wt || !existsSync(wt)) return;
+    const agentId = place.slice(2);
+    try {
+      await inPlace(place, true, () => artifacts.reconcile({ placeDir: wt, before: beforeArtifacts(wt), agentId }));
+      done.add(place);
+      tries.delete(place);
+    } catch (error) {
+      const n = (tries.get(place)?.n ?? 0) + 1;
+      tries.set(place, { n, at: now() });
+      log(`agent ${agentId}: artifact cleanup incomplete — ${error?.message ?? error}` +
+        (n >= MAX_TRIES ? ' (not retried again until the daemon restarts)' : ''));
+    }
+  };
+
+  /** The roster's live places; agent ones are `a-<agentId>`. Never awaited by the poll. */
+  const reconcileIdleArtifacts = (activeIds) => {
+    if (!Array.isArray(activeIds) || !getArtifactsAccepted()) return null;
+    if (sweeping) return sweeping;
+    const live = new Set(activeIds);
+    for (const id of done) if (!live.has(id)) done.delete(id);
+    for (const id of tries.keys()) if (!live.has(id)) tries.delete(id);
+    const due = activeIds.filter((place) => {
+      if (typeof place !== 'string' || !place.startsWith('a-') || place.length <= 2) return false;
+      if (done.has(place) || placeLocks.has(place)) return false; // a turn or a merge is there
+      const t = tries.get(place);
+      return !t || (t.n < MAX_TRIES && now() - t.at >= RETRY_MS);
+    });
+    if (due.length === 0) return null;
+    // One place at a time: each is an inventory read and its removals.
+    sweeping = (async () => {
+      try {
+        for (const place of due) await reconcileOne(place);
+      } finally {
+        sweeping = null;
+      }
+    })();
+    return sweeping;
+  };
+
+  return { reconcileIdleArtifacts };
+}

package/bin/lib/workCappedTurn.mjs

@@ -60,6 +60,7 @@ export async function runCappedTurn({
   onSpawn = () => {},
   onInit = () => {},
   removeTranscript = removeTranscriptSoon,
+  signal,
 }) {
   // Wiring mistakes, refused before anything spawns: a hook inside turnArgs
   // would be silently replaced below, and a missing cap would fire at once.
@@ -74,7 +75,14 @@ export async function runCappedTurn({
   const capped = new Promise((resolve) => {
     stopWaiting = resolve;
   });
+  const cancel = () => {
+    wedged = true;
+    try { child?.kill('SIGKILL'); } catch { /* already gone */ }
+    stopWaiting('');
+  };
+  signal?.addEventListener('abort', cancel, { once: true });
   try {
+    if (signal?.aborted) { cancel(); return { out: '', wedged, spawned: false, sessionId }; }
     const turn = runTurn({
       ...turnArgs,
       onInit: (i) => {
@@ -96,11 +104,13 @@ export async function runCappedTurn({
         }, capMs);
         timer.unref?.();
         onSpawn(ch);
+        if (signal?.aborted) cancel();
       },
     });
     const out = await Promise.race([turn, capped]);
     return { out, wedged, spawned: child !== null, sessionId };
   } finally {
+    signal?.removeEventListener('abort', cancel);
     if (timer) clearTimeout(timer);
     if (child) workChildren.delete(child);
     releaseSlot();

package/bin/lib/workCommandAudit.mjs

@@ -64,7 +64,14 @@ export function createCommandAudit({ sessionId, turnId, runtime, cwd }) {
     // used to cut the command at 2000 before it reached this scrub, so a
     // secret straddling that character kept its prefix. They now hand a
     // bounded window, and the server's cap is applied here, last.
-    auditBatch.push({ command: scrubCut(a.command, MAX_COMMAND_CHARS), at: new Date().toISOString() });
+    auditBatch.push({ command: scrubCut(a.command, MAX_COMMAND_CHARS), at: new Date().toISOString(),
+      ...(a.observation ? { observation: {
+        ...(a.observation.id ? { id: scrubCut(a.observation.id, 160) } : {}),
+        outcome: a.observation.outcome ?? 'unknown',
+        ...(Number.isSafeInteger(a.observation.exitCode) ? { exitCode: a.observation.exitCode } : {}),
+        ...(a.observation.errorCategory ? { errorCategory: a.observation.errorCategory } : {}),
+      } } : {}),
+    });
     if (auditBatch.length >= 25) flushAudit();
   };
   return { flushAudit, auditCommand };

package/bin/lib/workPlaces.mjs

@@ -12,7 +12,7 @@
  * the session lane's turn intake both go through it (audit 2026-10-10, F141),
  * so a lane that learns a place cannot store one unvalidated.
  */
-import { existsSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { git, isSafePathSegment, hasCommits, gitFailure, sessionBranch } from './git.mjs';
 
@@ -290,5 +290,21 @@ export function createWorkPlaces({ repoRoot, baseDir, baseRef, onRepoChanged })
     }
   };
 
-  return { placeOf, notePlace, learnPlaces, placeDir, branchAt, placeWtFor, sessionMetaPath };
+  /**
+   * WHEN `git worktree add` CUT THIS WORKTREE: its private git dir's
+   * `commondir`, written once at creation and left alone by commits, lock,
+   * repair and move. A recreated worktree is a new birth. Null for the
+   * checkout (no such file) and for anything unreadable — read by the
+   * artifact reporter, which then has no evidence a place held older rows.
+   */
+  const worktreeBornAt = (wt) => {
+    const path = sessionMetaPath(wt, 'commondir');
+    try {
+      return path ? statSync(path).mtimeMs : null;
+    } catch {
+      return null;
+    }
+  };
+
+  return { placeOf, notePlace, learnPlaces, placeDir, branchAt, placeWtFor, sessionMetaPath, worktreeBornAt };
 }