flowviant 0.117.0 → 0.124.1

package/bin/lib/workAgentTurnExecution.mjs

@@ -1,3 +1,4 @@
+import { finishRepositoryDelivery, allResolutionsCommitted } from './repositoryDelivery.mjs';
 /**
  * ONE AGENT TURN, RUN: the worktree, the CLI, and what it left behind.
  *
@@ -23,6 +24,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,17 +32,25 @@ 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';
 import { brainFor } from './workBrain.mjs';
+import { refreshRestartBase } from './workAgentRecovery.mjs';
 import { begunTurnRefusal } from './workAgentTurnBegun.mjs';
 import { agentTurnSettlement } from './workAgentTurnOutcome.mjs';
 import { ensureArtifactDir, ensureFenceScratch } from './artifacts.mjs';
 import { agentBrowserHome } from './noWindowEnv.mjs';
+import { CLAUDE_SESSION_RE, RESUME_MARKERS } from './conversationIds.mjs';
+import { createDeliveryReporter } from './workDelivery.mjs';
+import { createLiveMessages } from './workLiveMessages.mjs';
 
 export function createAgentTurnExecution({
+  agentRepositories,
+  makeBrief,
   baseRef,
   baseDir,
   repoRoot,
@@ -59,7 +69,9 @@ export function createAgentTurnExecution({
   postAgentActivity,
   postAgentParked,
   fetchAgentFiles,
+  makeLiveMessages = createLiveMessages,
 }) {
+  const reportDelivery = createDeliveryReporter();
   /** How long the final flush may hold the settle. Bounded because the settle
    *  is the turn's contract and the trace is a readout: a wedged uplink costs
    *  the tail of a trace, never the answer behind it. */
@@ -107,7 +119,14 @@ 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 } }) => {
+    let repositoryRun = null;
+    const setupController = new AbortController();
+    run.abortSetup = () => setupController.abort();
+    if (run.interrupted) setupController.abort();
+    try {
     // 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.
@@ -118,7 +137,10 @@ export function createAgentTurnExecution({
         return;
       }
     }
-    const dir = placeWtFor(place);
+    if (!(await refreshRestartBase(job, repoRoot))) return;
+    repositoryRun = await agentRepositories?.prepare(job, place, { signal: setupController.signal });
+    measured.repositoryReceipts = repositoryRun?.receipts;
+    const dir = repositoryRun ?? placeWtFor(place);
     if (!dir) {
       // No worktree and none could be cut. `nothing`, WITH git's own words:
       // without them the agent sat in Stuck with no question and no reason
@@ -288,10 +310,13 @@ export function createAgentTurnExecution({
       }
     }
     let seenThreadId = null;
+    const claudeMarker = rt === 'claude' ? sessionMetaPath(wt, RESUME_MARKERS.claude, agentId) : null;
+    let claudeResumeId = null;
+    try { const id = readFileSync(claudeMarker, 'utf8').trim(); if (CLAUDE_SESSION_RE.test(id)) claudeResumeId = id; } catch { /* unknown */ }
     const resume =
       rt === 'codex'
         ? Boolean(codexResumeId)
-        : rt === 'claude' && Boolean(ranMarker && existsSync(ranMarker));
+        : rt === 'claude' && (Boolean(claudeResumeId) || Boolean(ranMarker && existsSync(ranMarker)));
     /**
      * …AND THE HOME THAT THREAD IS FILED UNDER, KEPT PER AGENT (2026-09-29).
      *
@@ -375,8 +400,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 +433,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 +454,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,12 +467,49 @@ 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 sources = repositoryRun?.sources ?? [];
+      const source = sources.find((r) => r.wt === wt);
+      const snapshot = readBaseTools(source?.repoRoot ?? repoRoot, source?.baseRef ?? baseRef());
+      for (const other of sources.filter((r) => r !== source)) {
+        const base = readBaseTools(other.repoRoot, other.baseRef);
+        snapshot.instructions.push(...[...base.instructions, ...base.skillFiles].map((file) => ({ ...file, path: `repositories/${other.folder}/${file.path}` })));
+      }
+      projectTools = prepareAgentTools(snapshot, rt, process.env, wt, { codexHome: codexAgentHome, turnServers: repositoryRun?.tool ? { card_repositories: repositoryRun.tool.config } : {} });
+      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 = {
+        ...(rt === 'claude' ? { liveMessages: (run.live = makeLiveMessages({
+          scope: 'agent', turnId, cwd: wt, sessionMetaPath, interrupted: () => run.interrupted,
+          format: async (followup) => {
+            const attached = followup.attachments?.length ? await fetchAgentFiles(wt, followup.attachments.map((file) => ({ ...file, from: 'message' }))) : { message: [], card: [] };
+            return AGENT_HUMAN_KICKOFF({ agentName: job.agentName, message: followup.body + (followup.libraryPrompt ?? ''),
+              askedByName: followup.askedByName, task: job.task, cardThread: job.cardThread,
+              messageFiles: attached.message, cardFiles: files.card, position: job.position ?? 1, total: job.total ?? 1 });
+          },
+        })) } : {}),
         prompt:
           job.kind === 'task' && job.task
             ? AGENT_TASK_KICKOFF({
@@ -451,6 +518,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 +527,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 +548,29 @@ 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}` : '') + (repositoryRun ? `\n\n${repositoryRun.note}\nRepository command argv: ${JSON.stringify([repositoryRun.tool?.config.command, ...(repositoryRun.tool?.config.args.slice(0, -1) ?? []), "__repository", "<name>"])}` : ''),
         agentTools: projectTools,
-        ...(projectTools.codexHome ? { mcpEnv: { CODEX_HOME: projectTools.codexHome } } : {}),
+        writableDirs: repositoryRun?.writableDirs,
+        ...((projectTools.codexHome || fencedMount || repositoryRun?.tool) ? { mcpEnv: { ...(projectTools.codexHome ? { CODEX_HOME: projectTools.codexHome } : {}), ...(fencedMount?.env ?? {}), ...(repositoryRun?.tool?.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.
@@ -503,7 +578,11 @@ export function createAgentTurnExecution({
         cwd: wt,
         runtime: rt,
         resume,
-        resumeThreadId: codexResumeId || undefined,
+        resumeThreadId: codexResumeId || claudeResumeId || undefined,
+        onInit: (init) => {
+          if (claudeMarker && CLAUDE_SESSION_RE.test(init.sessionId ?? ''))
+            try { writeFileSync(claudeMarker, init.sessionId); } catch { /* best effort */ }
+        },
         onThreadId: (id) => {
           seenThreadId = String(id ?? '').trim() || seenThreadId;
         },
@@ -518,7 +597,8 @@ export function createAgentTurnExecution({
         // narrator keeps: overwritten, never appended, and ignored by the
         // board past ~90 seconds.
         onActivity: (a) => {
-          const line = a?.label;
+          brief?.append(a?.kind ?? 'activity', a?.full ?? a?.label);
+          let line = a?.label;
           if (!line) return;
           // THE TRACE TAKES EVERY LINE; the pulse takes one every two
           // seconds. Two channels, one stream, and the drop-sampler stays a
@@ -533,7 +613,12 @@ export function createAgentTurnExecution({
           // daemon carried for all of them. The PULSE below is deliberately
           // still `line`: it is one overwritten line on a board, and a
           // paragraph there would be a paragraph nobody can read.
-          if (!doubledKinds || !doubledKinds.has(a.kind)) trace.prose(a.kind, a.full ?? line);
+          if (!doubledKinds || !doubledKinds.has(a.kind)) {
+            const full = a.full ?? line;
+            const readable = trace.prose(a.kind, full);
+            if (readable === null) return;
+            if (readable !== full) line = envScrub(readable).replace(/\s+/g, ' ').trim().slice(0, 160);
+          }
           const now = Date.now();
           if (now - (lastAgentBeat.get(agentId) ?? 0) < 2_000) return;
           lastAgentBeat.set(agentId, now);
@@ -543,7 +628,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,8 +657,12 @@ export function createAgentTurnExecution({
         // (runTurn.mjs, `initHarvestFor`). An agent-only box learns from the
         // startup probe and its Terminal tabs.
         onSpawn: (ch) => {
+          if (rt !== 'claude') reportDelivery('agent', job, 'taken');
+          brief?.running(true);
+          ch.once('close', () => { if (child === ch) brief?.running(false); });
           child = ch;
           spawnedChildren.add(ch);
+          measured.ranCli = true;
           // The AGENT it serves — what the machine snapshot charges this
           // child's memory to.
           workChildren.set(ch, agentId);
@@ -583,6 +678,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 +694,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,
@@ -614,11 +711,30 @@ export function createAgentTurnExecution({
           void postAgentActivity(agentId, 'resuming after an internal wait');
         } }
       );
+      out = await finishRepositoryDelivery({
+        job, run: repositoryRun, out, answer: () => lastAnswer,
+        resume: async (prompt) => {
+          lastAnswer = null;
+          const counted = usage;
+          return runCli({
+            ...agentTurnArgs, prompt, liveContinuation: true,
+            onUsage: (next) => agentTurnArgs.onUsage(Object.fromEntries(
+              ['input', 'output', 'cacheCreate', 'cacheRead'].map((k) =>
+                [k, (counted?.[k] ?? 0) + (next?.[k] ?? 0)])
+            )),
+            writableDirs: repositoryRun.sourcesNow().filter((r) => r.wt !== wt).map((r) => r.wt),
+            resume: true,
+            resumeThreadId: seenThreadId ?? agentTurnArgs.resumeThreadId,
+          });
+        },
+      });
     } finally {
+      await brief?.stop();
       // What the CLI counted, for the lane's catch if anything below throws.
       measured.usage = usage;
       measured.model = model;
       projectTools?.cleanup();
+
       /**
        * THE TAIL, BEFORE THE SETTLE — so the last thing the agent did is on
        * the record by the time the board is told the turn is over.
@@ -664,16 +780,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);
+    const commits = repositoryRun ? [...new Set(repositoryRun.receipts().map((r) => r.sha))].slice(0, 50) : 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.
@@ -700,12 +836,14 @@ export function createAgentTurnExecution({
       // reported as `nothing` — it did not deliver and it did not ask.
       await postAgentParked(limit, rt);
     }
+    if (job.kind === 'merge_resolve' && repositoryRun) body.mergeResolved = allResolutionsCommitted(repositoryRun.sourcesNow());
     const reply = await postAgentTurn(body);
     // The queue just emptied. Run the project's own check and the AI
     // pre-review HERE, in the worktree we are already standing in and still
     // hold the lock on — see `runReviewEntry`. Only after the settle that may
     // say delivered: the three `nothing` settles never opened it.
     if (final && reply?.review === true) await runReviewEntry(agentId, wt, job.agentName);
+    } finally { await repositoryRun?.tool?.close(); }
   };
 
   return { runAgentTurnInPlace, commitsBetween };

package/bin/lib/workAgentTurnOutcome.mjs

@@ -25,6 +25,8 @@ 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';
+import { withoutTurnDeclaration } from './turnDeclaration.mjs';
 
 export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage, model = null, commits, artifactsBefore, branch, wt }) {
   const res = (lastAnswer && parseTurnResult(lastAnswer)) || parseTurnResult(out);
@@ -38,7 +40,9 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
    * makes the match mean what it says: the CLI failed and this is the
    * sentence it failed with.
    */
-  const limit = res ? null : limitLine(out);
+  // An unreadable protocol object is not a native CLI diagnostic either.
+  const readableOut = res ? '' : withoutTurnDeclaration(out);
+  const limit = res ? null : limitLine(readableOut);
   /** What the caller posts, and whether it is the one settle that may say
    *  delivered (the only one whose reply can open the review-entry beat).
    *  Every one carries the model the CLI said it ran on, when it said
@@ -59,13 +63,16 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
   }
 
   if (!res) {
+    const raw = lastAnswer || out;
+    const readable = lastAnswer ? withoutTurnDeclaration(raw) : readableOut;
     return report({
       turnId,
       outcome: 'nothing',
       // The CLI's own words when it produced any. A turn that explained why
       // it stopped is far more use than "the agent stopped".
-      answer: out.trim()
-        ? envScrub(out).slice(-1500)
+      answer: raw.trim()
+        ? readable.trim() ? envScrub(readable).slice(-1500)
+          : 'The turn returned an unreadable outcome declaration. This work has not been delivered.'
         : 'the turn produced no output on the machine — its CLI may be signed out',
       ...(commits.length ? { commits } : {}),
       ...(usage ? { usage } : {}),
@@ -110,7 +117,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 +134,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