flowviant 0.116.0 → 0.124.0

package/bin/lib/workAgentTurnExecution.mjs

@@ -19,20 +19,23 @@
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { PROJECT_ID } from './config.mjs';
 import { setRuntimeLimit } from './daemonState.mjs';
-import { git } from './git.mjs';
+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';
 import { scrub as envScrub } from './uplinkScrub.mjs';
-import { canRun, RUNTIMES } from './runtimes.mjs';
-import { recordSkills, recordMcpServers } from './runtimeCapabilities.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';
 import { brainFor } from './workBrain.mjs';
 import { begunTurnRefusal } from './workAgentTurnBegun.mjs';
@@ -41,6 +44,7 @@ import { ensureArtifactDir, ensureFenceScratch } from './artifacts.mjs';
 import { agentBrowserHome } from './noWindowEnv.mjs';
 
 export function createAgentTurnExecution({
+  makeBrief,
   baseRef,
   baseDir,
   repoRoot,
@@ -95,15 +99,8 @@ export function createAgentTurnExecution({
      * reconciliation books whatever no card claimed. Missing beats fabricated
      * and both beat a stall.
      */
-    let out;
-    try {
-      out = git(['log', '--format=%H', '--no-merges', `${from}..HEAD`, '--not', baseRef()], wt);
-    } catch {
-      return [];
-    }
-    return typeof out === 'string'
-      ? out.split('\n').map((x) => x.trim()).filter(Boolean).slice(0, 50)
-      : [];
+    const out = gitOrNull(['log', '--format=%H', '--no-merges', `${from}..HEAD`, '--not', baseRef()], wt);
+    return out?.split('\n').map((x) => x.trim()).filter(Boolean).slice(0, 50) ?? [];
   };
 
   /**
@@ -114,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.
@@ -147,19 +146,13 @@ export function createAgentTurnExecution({
      * `runAgentMerge` learned this two commits ago and says so in its own
      * comment; this is the same call, in the same file, left unguarded. Both
      * facts are OPTIONAL to a turn — they describe the branch, they do not
-     * gate the work — so failing to read them costs a null, not the turn.
+     * gate the work — so failing to read them costs a null, not the turn:
+     * git.mjs's `gitOrNull`, the one spelling of that rule.
      */
-    const readGit = (args) => {
-      try {
-        return (git(args, wt) || '').trim() || null;
-      } catch {
-        return null;
-      }
-    };
     // WHERE THE BRANCH WAS BEFORE THIS TURN, so the commits reported are the
     // ones this turn actually made.
-    const before = readGit(['rev-parse', 'HEAD']);
-    const branch = readGit(['symbolic-ref', '--quiet', '--short', 'HEAD']);
+    const before = gitOrNull(['rev-parse', 'HEAD'], wt);
+    const branch = gitOrNull(['symbolic-ref', '--quiet', '--short', 'HEAD'], wt);
     // …and the same three facts for the lane's catch: a turn that throws past
     // here is still settled with what was measured (workAgentTurns.mjs).
     measured.wt = wt;
@@ -176,9 +169,9 @@ export function createAgentTurnExecution({
      * posture, which can write ONLY `.flowviant/artifacts/` (claudePosture.mjs).
      *
      * A RUNTIME THAT CANNOT EXPRESS THE POSTURE IS REFUSED, NOT IMPROVISED.
-     * Antigravity declares none of them and Codex declares `design` (since
-     * 0.115.0) and `image` but not `research` (runtimeCodex.mjs,
-     * runtimeAntigravity.mjs), and the only
+     * Antigravity declares none of them; Codex declares `design` (since
+     * 0.115.0), `image` and `research` (0.117.0, over an isolated copy —
+     * codexResearch.mjs) (runtimeCodex.mjs, runtimeAntigravity.mjs), and the only
      * alternative to refusing is running the card as a BUILD turn with
      * permissions skipped — an agent writing code for an ask that was a
      * mockup, reporting success. `nothing` puts the agent in Stuck saying so.
@@ -220,7 +213,7 @@ export function createAgentTurnExecution({
     // entry in agentTaskKinds.mjs; nothing below branches on the kind name.
     const kind = AGENT_TASK_KINDS[taskKind];
     const posture = kind.posture;
-    if (!canRun(RUNTIMES[rt], posture)) {
+    if (!canRun(runtimeById(rt), posture)) {
       await postAgentTurn({
         turnId,
         outcome: 'nothing',
@@ -388,12 +381,12 @@ 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.
      */
-    const doubledKinds = RUNTIMES[rt]?.parse ? null : CLAUDE_TOOL_PROSE_KINDS;
+    const doubledKinds = runtimeById(rt)?.parse ? null : CLAUDE_TOOL_PROSE_KINDS;
 
     /**
      * WHICH BRAIN THIS CONTAINER WAS PINNED TO — the same `brainFor` the tab
@@ -421,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).
      *
@@ -439,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
@@ -450,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
@@ -464,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,
@@ -471,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
@@ -489,24 +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, RUNTIMES[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(),
-        }) + (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),
-        ...(posture === 'build' && rt === 'claude'
-          ? { mcpArgs: ['--strict-mcp-config', '--mcp-config', projectTools.mcpPath] }
-          : posture === 'build' && rt === 'codex'
-            ? { mcpArgs: projectTools.codexArgs }
-            : {}),
+        // 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.
@@ -523,13 +551,13 @@ export function createAgentTurnExecution({
         },
         // Present only when the container named one — see brainFor.
         ...brain,
-        streamJson: true,
         answerFromResult: true,
         label: c.cyan('[agent]'),
         // The CLI's own tail, relayed. Throttled by the same rule the tab's
         // 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
@@ -555,12 +583,19 @@ 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
-        // result per turn, so this is a set and not an accumulate — the
-        // adding-up happens SERVER-side, behind the settle's idempotent win,
+        // result per CLI invocation. Internal-wait recovery combines those
+        // counts before this callback; project accounting still happens
+        // SERVER-side, behind the settle's idempotent win,
         // because a retried settle must not charge the same turn twice.
         // …tagged with WHICH CLI counted it (2026-09-24), so the server can
         // split an agent's spend per CLI rather than labelling a codex
@@ -571,17 +606,14 @@ export function createAgentTurnExecution({
         onModel: (m) => {
           model = m;
         },
-        // WHAT THE CLI SAYS IT CAN BE ASKED FOR, AND WHICH CONNECTORS NEED A
-        // LOGIN — the same free fact off the same init event the tab lane
-        // records (2026-09-23). Without it a box that only ever runs agents
-        // taught the app its skills and connectors ONCE, from the startup
-        // probe, and never again: a connector signed into at the box kept
-        // reading "needs authorization" for the life of the process.
-        onInit: (i) => {
-          recordSkills(i.skills);
-          recordMcpServers(i.mcpServers);
-        },
+        // No skills or connectors are harvested here (2026-10-10): every
+        // agent turn narrows them — `--setting-sources user` and the reviewed
+        // plugin, `--strict-mcp-config` — so its init is not the machine's
+        // (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
@@ -599,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);
         },
       };
       /**
@@ -612,16 +646,26 @@ export function createAgentTurnExecution({
        * (resumeLost.mjs, SOLID F001): a successful answer that merely
        * MENTIONS a missing session is never run twice.
        */
-      out = await runTurnResumingOnce(runTurn, agentTurnArgs, {
-        resume,
-        runtime: rt,
-        beforeFresh: () => {
-          seenThreadId = null;
+      out = await runAgentWithInternalWaits(
+        (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,
+          runtime: rt,
+          beforeFresh: () => {
+            seenThreadId = null;
+            lastAnswer = null;
+            model = null;
+          },
+        }),
+        { ...agentTurnArgs, onContinuation: (n) => {
           lastAnswer = null;
-          model = null;
-        },
-      });
+          trace.prose('text', `The machine resumed this card after an internal wait (continuation ${n}).`);
+          void postAgentActivity(agentId, 'resuming after an internal wait');
+        } }
+      );
     } finally {
+      await brief?.stop();
       // What the CLI counted, for the lane's catch if anything below throws.
       measured.usage = usage;
       measured.model = model;
@@ -671,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/workAgentTurnReports.mjs

@@ -14,8 +14,9 @@
  * Daemon→server reports, every one of them: no version floor, and a permanent
  * 4xx is the server saying it will never take the body (see each POST).
  */
-import { FLEET_URL, FLEET_TOKEN, USER_AGENT } from './config.mjs';
-import { fleetEndpoint } from './fleetWire.mjs';
+import { FLEET_URL } from './config.mjs';
+import { fleetEndpoint, isConsideredRefusal } from './fleetWire.mjs';
+import { fleetHeaders, postFleetJson } from './fleetPost.mjs';
 
 export function createAgentTurnReports({ REJECT_RETRY_MS }) {
   const AGENT_TURN_DONE_URL = fleetEndpoint('agent-turn-done', FLEET_URL);
@@ -53,16 +54,7 @@ export function createAgentTurnReports({ REJECT_RETRY_MS }) {
     const turnId = String(body.turnId);
     agentReported.set(turnId, { body, at: Date.now() });
     try {
-      const res = await fetch(AGENT_TURN_DONE_URL, {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${FLEET_TOKEN}`,
-          'User-Agent': USER_AGENT,
-          'Content-Type': 'application/json',
-        },
-        signal: AbortSignal.timeout(30_000),
-        body: JSON.stringify(body),
-      });
+      const res = await postFleetJson(AGENT_TURN_DONE_URL, body, { timeoutMs: 30_000 });
       const j = await res.json().catch(() => null);
       /**
        * ONLY A 2xx IS DELIVERED. The server answers an already-settled,
@@ -79,7 +71,7 @@ export function createAgentTurnReports({ REJECT_RETRY_MS }) {
       if (res.ok) {
         agentReported.delete(turnId);
         agentRejectedUntil.delete(turnId);
-      } else if (res.status >= 400 && res.status < 500 && res.status !== 408 && res.status !== 429) {
+      } else if (isConsideredRefusal(res.status)) {
         agentRejectedUntil.set(turnId, Date.now() + REJECT_RETRY_MS);
       }
       return j?.data ?? null;
@@ -102,20 +94,8 @@ export function createAgentTurnReports({ REJECT_RETRY_MS }) {
    */
   const postAgentTrace = async (body) => {
     try {
-      const res = await fetch(AGENT_TRACE_URL, {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${FLEET_TOKEN}`,
-          'User-Agent': USER_AGENT,
-          'Content-Type': 'application/json',
-        },
-        signal: AbortSignal.timeout(15_000),
-        body: JSON.stringify(body),
-      });
-      return (
-        res.ok ||
-        (res.status >= 400 && res.status < 500 && res.status !== 408 && res.status !== 429)
-      );
+      const res = await postFleetJson(AGENT_TRACE_URL, body, { timeoutMs: 15_000 });
+      return res.ok || isConsideredRefusal(res.status);
     } catch {
       return false; // a blip — the same entries go again at the same seq
     }
@@ -125,11 +105,7 @@ export function createAgentTurnReports({ REJECT_RETRY_MS }) {
     try {
       await fetch(AGENT_ACTIVITY_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({ agentId, text }),
       });
@@ -142,11 +118,7 @@ export function createAgentTurnReports({ REJECT_RETRY_MS }) {
     try {
       await fetch(AGENT_PARKED_URL, {
         method: 'POST',
-        headers: {
-          Authorization: `Bearer ${FLEET_TOKEN}`,
-          'User-Agent': USER_AGENT,
-          'Content-Type': 'application/json',
-        },
+        headers: fleetHeaders(),
         signal: AbortSignal.timeout(15_000),
         // `runtime` scopes the park to that CLI's agents; a server that does
         // not know the key parks every agent, which is what it always did.

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);
       });
     }
   };
@@ -318,9 +348,10 @@ export function createWorkAgentTurns({
   /**
    * SETTLE EVERYTHING IN FLIGHT, because this process is about to go away.
    *
-   * The one caller is the displacement stand-down: the project's machine moved
-   * to another box, so nothing here will be re-offered to us and nothing else
-   * knows these turns were running. An abandoned turn sits pending until the
+   * The one caller is the roster's stand-down (holder.mjs): the project's
+   * machine moved to another box, this box was removed from the project, or
+   * Flowviant stopped it (2026-10-10) — so nothing here will be re-offered to
+   * us and nothing else knows these turns were running. An abandoned turn sits pending until the
    * server's six-hour expiry while the board shows an agent working on a machine
    * that has gone — the wedge every settle path in this lane exists to avoid.
    *
@@ -346,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 };
 }