flowviant 0.125.21 → 0.125.22

package/bin/lib/agentCards.mjs

@@ -70,6 +70,24 @@ export function stashCard(path, taskId, spec) {
   }
 }
 
+/**
+ * WHAT THE AGENT SAID IT DID NOT DELIVER on a card (2026-10-25, turnGaps.mjs),
+ * kept beside the spec so the pre-review can read the request, the diff and
+ * the agent's own account of what is missing together. Same append rule; the
+ * reader keeps the last declaration per card.
+ */
+export function stashGaps(path, taskId, gaps) {
+  if (!path || !Array.isArray(gaps)) return false;
+  const id = String(taskId ?? '').trim();
+  if (!id) return false;
+  try {
+    appendFileSync(path, JSON.stringify({ taskId: id.slice(0, 64), gaps }) + '\n');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * What this box holds, newest spec per card, in the order the cards were worked.
  *
@@ -89,6 +107,7 @@ export function readStash(path) {
    *  order stays the order the cards were first handed out — which is the order
    *  the branch was built in, and the order a reviewer reads them in. */
   const byId = new Map();
+  const gapsById = new Map();
   for (const line of raw.split('\n')) {
     if (!line.trim()) continue;
     let v;
@@ -99,10 +118,14 @@ export function readStash(path) {
     }
     if (!v || typeof v !== 'object') continue;
     const taskId = typeof v.taskId === 'string' ? v.taskId.trim() : '';
+    if (taskId && Array.isArray(v.gaps)) {
+      gapsById.set(taskId, v.gaps);
+      continue;
+    }
     const prompt = typeof v.prompt === 'string' ? v.prompt : '';
     if (!taskId || !prompt.trim()) continue;
     byId.set(taskId, prompt);
   }
-  const all = [...byId].map(([taskId, prompt]) => ({ taskId, prompt }));
+  const all = [...byId].map(([taskId, prompt]) => ({ taskId, prompt, ...(gapsById.has(taskId) ? { gaps: gapsById.get(taskId) } : {}) }));
   return all;
 }

package/bin/lib/agentPlan.mjs

@@ -35,6 +35,7 @@ import { AGENT_TASK_KINDS } from './agentTaskKinds.mjs';
 import { blockedAnswer } from './agentAsk.mjs';
 import { isResearchUse } from './researchUse.mjs';
 import { candidateObjects } from './modelJson.mjs';
+import { parseGaps } from './turnGaps.mjs';
 
 /** The biggest a single proposal may be. Bounds on a machine, not a policy:
  *  the server caps these again at its own boundary. */
@@ -272,6 +273,8 @@ export function parseTurnResult(text, scrub = envScrub) {
         ...(typeof v.automation === 'string' && v.automation.trim()
           ? { automation: scrub(v.automation.trim()) } : {}),
         ...(parseTestFindings(v.testFindings, scrub) ? { testFindings: parseTestFindings(v.testFindings, scrub) } : {}),
+        // What it says it did not deliver (turnGaps.mjs): absent is unknown.
+        ...(parseGaps(v.gaps, scrub) ? { gaps: parseGaps(v.gaps, scrub) } : {}),
         ...progressOf(v, scrub),
         raised: Array.isArray(v.raised)
           ? v.raised

package/bin/lib/agentQueueContext.mjs

@@ -14,6 +14,9 @@ an order alone is not a declared dependency. requirements.status=missing is
 unavailable, never an empty brief. Discussions carry their existing omission
 counts and may be unavailable; do not treat a shortened discussion as full
 requirements. The brief and criteria marked full are supplied without clipping.
+sourceChats are the person's exact words in the New task chat these cards were
+planned in, up to each card's landing; a brief is the planner's paraphrase of
+them, and links, references and file lists there are part of the request.
 Human messages are exact recorded words across this agent, with the preceding
 question when present. taskId on a message is where it was recorded, not an
 implicit scope restriction. target.kind=agent explicitly addresses the whole
@@ -32,7 +35,9 @@ relying on an excluded decision; do not recover it from older native memory.
 Latest outcomes and progress are reported summaries, not complete specifications,
 proof that checks passed, human acceptance or evidence that bytes exist locally.
 Stored outputs name exact ids/turns/hashes, not a successful local read. Retained
-result selections preserve their exact scope. Use the active turn's measured
+result selections preserve their exact scope. localInputs lists the retained
+paths that exist in this worktree this turn; any other retained path named in
+the snapshot does not. Use the active turn's measured
 input manifest and prerequisite receipts before relying on files; never replace
 or regenerate missing selected inputs or assume queue knowledge discovers them.
 Only execute the active turn's assigned work. Upcoming cards are context, not
@@ -44,6 +49,20 @@ only relevant prior findings/decisions/input identities, not the entire queue.
 ${fence('AGENT QUEUE SNAPSHOT', context)}`;
 }
 
+/** THE CARD'S SOURCE CHAT, as words the pre-review reads beside its spec
+ * (2026-10-25): the stash is per card and the snapshot is gone by review
+ * entry, so the person's request is kept with the spec it shaped. Empty when
+ * the card landed from no chat (or the server sent no source chats). */
+export function sourceChatText(context, taskId) {
+  const chats = (context?.sourceChats?.chats ?? []).filter((c) => Array.isArray(c.taskIds) && c.taskIds.includes(taskId));
+  if (!chats.length) return '';
+  const said = chats.flatMap((c) => [
+    ...(c.messages ?? []).map((m) => `${m.answering ? `(answering: ${m.answering})\n` : ''}${m.body}`),
+    ...(c.omitted ? [`(${c.omitted} more message${c.omitted === 1 ? '' : 's'} omitted)`] : []),
+  ]);
+  return `\n\nTHE PERSON'S OWN WORDS (the New task chat this card was planned in; the brief above paraphrases them):\n${said.join('\n\n')}`;
+}
+
 /** The gate supplies active identity/fences, not upcoming work to a child.
  * Relevant findings still travel with the root's focused assignment. */
 export function agentChildScope(job) {

package/bin/lib/artifactContracts.mjs

@@ -82,6 +82,49 @@ is missing, so you lead:
   outside decision — stop and name exactly that dependency; a skip never
   supplies it.`;
 
+/**
+ * THE WHOLE REQUEST, NOT ONLY THE BRIEF (2026-10-25) — every agent contract
+ * closes on it, before HELP_THEM_DECIDE.
+ *
+ * Eighteen merged runs were audited and most delivered part of what was asked
+ * while every check passed: a Codex planner could not open a Claude Design
+ * file and wrote "use only the described controls as scope" into the brief;
+ * the Claude agent, which could open it, never tried; an agent recast the
+ * design states between its cards as "decisions"; another satisfied "measure
+ * the waits" with a timer it wrote. The brief is a paraphrase, the person's
+ * words now ride the queue snapshot (`sourceChats`), a reference the agent
+ * can open is the agent's to open, and the delivery says what is missing
+ * (`gaps`, turnGaps.mjs) instead of leaving the person to find it.
+ */
+export const WHOLE_REQUEST = `THE WHOLE REQUEST, NOT ONLY THE BRIEF:
+- A brief is a planner's paraphrase. When the queue snapshot carries
+  "sourceChats", those are the person's exact words from the chat this card
+  was planned in: read them before you start. Links, design references, file
+  lists and pasted text there are part of the request.
+- A REFERENCE YOU CAN OPEN, YOU OPEN. Read every design or reference that the
+  brief, the source chat, the card's discussion or the person's messages link
+  to before you build against it. A claude.ai/design link is read with a
+  DesignSync tool where your CLI offers one: load it (ToolSearch
+  "select:DesignSync"), then get_file the named file and its imports,
+  read-only, never its write methods. A brief that says a reference "could not be opened", "is
+  unavailable" or "use only X as scope" describes the planner's access, not
+  yours: try it yourself. If you still cannot read it, name it in "gaps" and
+  build nothing that depends on guessing what it contains.
+- COVER THE REQUEST, THEN SAY WHAT IS MISSING. Before you deliver, walk the
+  request: the source chat's words, every frame, state and rule a reference
+  you read shows or states, the brief and each "done when". Add "gaps" to the
+  delivered JSON object, one entry per item this card was meant to deliver
+  that you did not build ("not built"), built in part ("partly") or did not
+  check against the real thing ("unverified"), and per part of the request
+  that NO card in this run owns ("unowned"), so the person can file it:
+    "gaps": [{ "item": "what is missing", "status": "not built | partly | unverified | unowned", "why": "one sentence" }]
+  "gaps": [] says you walked the request and nothing is missing. Never recast
+  a gap as a decision: a choice you made in place of the request is a gap
+  ("partly") with its reason.
+- A "reproduce", "measure" or "verify" step is done only against the real
+  thing. A mock, timer or fixture you wrote yourself does not satisfy it:
+  list it as "unverified".`;
+
 /**
  * Rule 3, rule 4 and the final JSON a file-handing contract ends with.
  * `ask` is rule 4's body after its number (the decision only a person can
@@ -119,6 +162,8 @@ or, if you are stopping to ask:
 "progress" is REQUIRED on both shapes and REPLACES the previous one whole —
 past tense, plain sentences, no card ids.
 
+${WHOLE_REQUEST}
+
 ${HELP_THEM_DECIDE}`;
 
 /**

package/bin/lib/codexSubagents.mjs

@@ -11,6 +11,7 @@ import { CODEX_CHILD_THREAD_RE } from './conversationIds.mjs';
 import { followJsonl } from './jsonlTail.mjs';
 import { codexCollabUpdates, codexSpawnResult, statusOf } from './codexSubagentEvents.mjs';
 import { NATIVE_AGENT_TOOLS } from './nativeAgentTools.mjs';
+import { isSealedMessage } from './orchestratorNative.mjs';
 import { SUBAGENT_CAP } from './subagentBounds.mjs';
 
 const CODEX = NATIVE_AGENT_TOOLS.codex;
@@ -84,7 +85,7 @@ export function createCodexSubagentReader({ since = Date.now(), env = process.en
       if (!COLLAB_CALLS.includes(name)) return;
       let args;
       try { args = JSON.parse(p.arguments); } catch { return; }
-      calls.set(p.call_id, { name, args });
+      calls.set(p.call_id, { name, args, namespace: p.namespace });
       if (calls.size > 128) calls.delete(calls.keys().next().value);
       const id = targetId(args.target ?? args.id);
       if (id && name !== 'spawn_agent') {
@@ -122,7 +123,10 @@ export function createCodexSubagentReader({ since = Date.now(), env = process.en
       const title = args.task_name ?? args.description ?? output.agent_nickname ?? '';
       if (args.task_name) rememberTarget(args.task_name, id);
       if (typeof path === 'string') rememberTarget(path, id);
-      report({ id, kind: args.agent_type ?? '', title, brief: args.message ?? '', status: 'running', now: '' });
+      // A V2 message is ciphertext (orchestratorNative.mjs `isSealedMessage`):
+      // its words are unknown, so the child carries no brief rather than that.
+      const sealed = isSealedMessage(call.namespace ? `${call.namespace}.${call.name}` : call.name, args.message);
+      report({ id, kind: args.agent_type ?? '', title, ...(sealed ? {} : { brief: args.message ?? '' }), status: 'running', now: '' });
       return;
     }
     if (owner !== root && ev.type === 'response_item' && p.type === 'custom_tool_call') {

package/bin/lib/knowledgeFetch.mjs

@@ -21,17 +21,22 @@ export function knowledgeFetcher({ fleetUrl, token, userAgent, maxBytes = KNOWLE
   // A kept library item (0.97.0) is its sibling, `GET /fleet/library/:id` —
   // the same credential, the same shape, the same caps.
   const libraryBase = fleetEndpoint('library', fleetUrl);
-  return async (id, { library = false, preview = false, fileIndex = null } = {}) => {
+  // THE CAP IS THE FILE'S (2026-10-25): the sync holds a kept model under
+  // models/ or designs/ to 32 MiB (`knowledgeMaxFor`) and hands that cap here;
+  // this default alone turned every 20–32 MiB GLB into the over-cap sentinel,
+  // a failed hash on every poll, so a map the Library kept never reached an
+  // agent.
+  return async (id, { library = false, preview = false, fileIndex = null, maxBytes: cap = maxBytes } = {}) => {
     const suffix = preview ? '/preview' : Number.isSafeInteger(fileIndex) && fileIndex >= 0 ? `/file/${fileIndex}` : '';
     const res = await fetch(`${library ? libraryBase : base}/${encodeURIComponent(id)}${suffix}`, {
       headers: { Authorization: `Bearer ${token}`, 'User-Agent': userAgent },
       signal: AbortSignal.timeout(60_000),
     });
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
-    if (Number(res.headers.get('content-length') ?? '0') > maxBytes) {
+    if (Number(res.headers.get('content-length') ?? '0') > cap) {
       // Returned rather than thrown: over the cap is a REFUSAL, permanent for
       // this rev, not a failure the backoff should keep retrying.
-      return Buffer.alloc(maxBytes + 1);
+      return Buffer.alloc(cap + 1);
     }
     return Buffer.from(await res.arrayBuffer());
   };

package/bin/lib/knowledgeFiles.mjs

@@ -217,7 +217,7 @@ export async function syncKnowledge({ checkoutDir, manifest, fetchFile, maxBytes
       sha256: f.sha256,
       bytes: f.bytes,
       maxBytes: knowledgeMaxFor(f.name, maxBytes),
-      fetch: () => fetchFile(f.id),
+      fetch: () => fetchFile(f.id, { maxBytes: knowledgeMaxFor(f.name, maxBytes) }),
     });
     // Stale or failed clears `ok` and is retried (a stale file is better than
     // a missing one until the retry lands); a refusal is listed as one.
@@ -299,7 +299,7 @@ async function syncLibrary({ dir, items, fetchFile, maxBytes, keep, result }) {
       sha256: it.sha256,
       bytes: it.bytes,
       maxBytes: itemMax,
-      fetch: () => fetchFile(it.id, { library: true }),
+      fetch: () => fetchFile(it.id, { library: true, maxBytes: itemMax }),
       beforeWrite: () => ensureLibraryParents(dir, it.path),
     });
     if (recordSyncState(result, entryState, it.path) === 'refused') {
@@ -317,7 +317,7 @@ async function syncLibrary({ dir, items, fetchFile, maxBytes, keep, result }) {
         sha256: it.preview.sha256,
         maxBytes: 2 * 1024 * 1024,
         oversizeFails: true,
-        fetch: () => fetchFile(it.id, { library: true, preview: true }),
+        fetch: () => fetchFile(it.id, { library: true, preview: true, maxBytes: 2 * 1024 * 1024 }),
         beforeWrite: () => ensureLibraryParents(dir, it.previewPath),
       });
       recordSyncState(result, previewState, it.previewPath);
@@ -335,7 +335,7 @@ async function syncLibrary({ dir, items, fetchFile, maxBytes, keep, result }) {
         sha256: String(f.sha256),
         bytes: f.bytes,
         maxBytes: knowledgeMaxFor(f.path, maxBytes),
-        fetch: () => fetchFile(it.id, { library: true, fileIndex: f.index }),
+        fetch: () => fetchFile(it.id, { library: true, fileIndex: f.index, maxBytes: knowledgeMaxFor(f.path, maxBytes) }),
         beforeWrite: () => ensureLibraryParents(dir, f.path),
       });
       if (recordSyncState(result, fileState, f.path) === 'refused') wanted[sub].delete(rel);

package/bin/lib/orchestrator.mjs

@@ -58,7 +58,9 @@ export async function createOrchestrator({ turnId, runtime, trace, admit, reques
   // wakes never evicts a note input() accepted.
   const inbox = new Map(), wakes = new Map();
   const pending = new Map(), steps = new Map();
-  let closed = false, polling = false, rootSession = null, offerAt = 0;
+  // Whether this run admitted a sealed (Codex V2) spawn or follow-up, whose
+  // child reads its contract at SubagentStart or its first tool instead.
+  let closed = false, polling = false, rootSession = null, offerAt = 0, sealedRun = false;
   const identity = readOnlyRun ? { ...readOnlyRun, instance: DAEMON_INSTANCE } : { scope: 'agent', turnId, instance: DAEMON_INSTANCE };
   const ended = () => closed || signal?.aborted;
   const resolve = id => aliases.get(id) ?? id;
@@ -123,6 +125,19 @@ export async function createOrchestrator({ turnId, runtime, trace, admit, reques
     return held.find(a => a.brief === brief) ?? held.find(a => title && a.title === title) ?? held.find(a => kind && a.kind === kind)
       ?? held[0] ?? open.find(a => a.brief === brief) ?? open.find(a => title && a.title === title);
   };
+  // A child's contract, naming its record by its id (the words ride its
+  // prompt) or, with no id, a sealed Codex V2 child's record by its task
+  // name: the plain `Task name: /root/<name>` header Codex puts on its task
+  // message, which resolves through the spawn's task_name alias (`named`).
+  // The start hook cannot say which spawn a child came from; its name can.
+  const childContract = (id = null) => {
+    const ref = id ?? 'your task name: the "Task name:" line of your task message, such as /root/backend',
+      arg = id ? `agentId=${id}` : 'agentId set to that task name';
+    return (readOnlyRun
+      ? `\n\nRead-only investigation agent record id: ${ref}. FIRST call card_orchestrator.register_agent with ${arg} before work (tool discovery is allowed). Share this checkout and its repository/knowledge read boundary. Write no file, edit nothing, commit nothing, start no work and call no board or staging tool. Return findings, source paths and uncertainties in your final message to the coordinator. Ask questions only through card_orchestrator.agent_question with ${arg}, and read its answer before proceeding. ${readOnlyRun.scope === 'capture' ? 'Call no flowviant tool, including streaming. Only the coordinator dedupes and authors staged outcomes and asks the person through the existing single-question flowviant-ask fence.' : 'Only the coordinator reconciles the complete workload and returns the proposal.'}`
+      : `\n\nCard orchestrator agent record id: ${ref}. FIRST call card_orchestrator.register_agent with ${arg} before doing work (tool discovery is allowed). Share this worktree and preserve others’ edits. Ask questions through card_orchestrator.agent_question with ${arg}; read its answer before proceeding. Only your orchestrator escalates person-only decisions. When you are done, end with your work or findings as your final message: that is how they reach your orchestrator, which owns the card’s final commit and JSON. agent_question is only for a question you cannot settle yourself, never for handing back results.`)
+      + (!readOnlyRun ? assignmentContext() : '') + (access === 'read' && !readOnlyRun ? READ_ONLY_CHILD : '');
+  };
   // Admitted: the offer is spent, and notes that paused this child are being
   // delivered, so its checkpoint lets it work until their route lands.
   const start = (a, now) => {
@@ -146,7 +161,8 @@ export async function createOrchestrator({ turnId, runtime, trace, admit, reques
     if (aliases.size > 256) aliases.delete(aliases.keys().next().value);
     if (calls.size > 128) calls.delete(calls.keys().next().value);
     if (!records.has(id) && records.size >= SUBAGENT_CAP) return { deny: `This run already has ${SUBAGENT_CAP} agent records. Continue the work yourself.` };
-    const a = emit({ id, brief, title: spawn.title ?? '', kind: spawn.kind ?? '', status: 'waiting', now: WAIT });
+    // A sealed message's words are unknown: no brief, never its ciphertext.
+    const a = emit({ id, ...(spawn.sealed ? {} : { brief }), title: spawn.title ?? '', kind: spawn.kind ?? '', status: 'waiting', now: WAIT });
     if (!slot(id)) { a.denied = resumed ? 'resume' : 'spawn'; return { deny: `${WAIT}. Agent id: ${id}. Keep working yourself; you will be told when this spawn can be retried. Do not wait for a child that has not started.` }; }
     // Claude's SendMessage addresses a child by its Agent `name`, Codex V2 by its task name.
     for (const name of spawn.names) if (filled(name) && name.length <= 160) aliases.set(name, id);
@@ -155,11 +171,9 @@ export async function createOrchestrator({ turnId, runtime, trace, admit, reques
     // stream, and the parent is asked to say why in its own update.
     const choice = childChoice(event, spawn, card);
     if (choice) trace.prose('note', `Runs on ${choice}.`, id);
-    const childContract = readOnlyRun
-      ? `\n\nRead-only investigation agent record id: ${id}. FIRST call card_orchestrator.register_agent with agentId=${id} before work (tool discovery is allowed). Share this checkout and its repository/knowledge read boundary. Write no file, edit nothing, commit nothing, start no work and call no board or staging tool. Return findings, source paths and uncertainties in your final message to the coordinator. Ask questions only through card_orchestrator.agent_question with agentId=${id}, and read its answer before proceeding. ${readOnlyRun.scope === 'capture' ? 'Call no flowviant tool, including streaming. Only the coordinator dedupes and authors staged outcomes and asks the person through the existing single-question flowviant-ask fence.' : 'Only the coordinator reconciles the complete workload and returns the proposal.'}`
-      : `\n\nCard orchestrator agent record id: ${id}. FIRST call card_orchestrator.register_agent with agentId=${id} before doing work (tool discovery is allowed). Share this worktree and preserve others’ edits. Ask questions through card_orchestrator.agent_question with agentId=${id}; read its answer before proceeding. Only your orchestrator escalates person-only decisions. When you are done, end with your work or findings as your final message: that is how they reach your orchestrator, which owns the card’s final commit and JSON. agent_question is only for a question you cannot settle yourself, never for handing back results.`;
+    if (spawn.sealed) sealedRun = true;
     return { context: `Agent record id: ${id}. Use it with card_orchestrator for routing and questions.${spawn.relocated ? ' Its isolation and cwd were removed: children share this card’s worktree on this machine.' : ''}${choice ? ` This child runs on ${choice}: name that choice and why in your next update.` : ''}`,
-      updatedInput: withChildContract(event, spawn, childContract + (!readOnlyRun ? assignmentContext() : '') + (access === 'read' && !readOnlyRun ? READ_ONLY_CHILD : ''), chosen.brain) };
+      updatedInput: withChildContract(event, spawn, spawn.sealed ? '' : childContract(id), chosen.brain) };
   }
   // Native readings never revive a settled record or start a waiting spawn
   // or follow-up (Codex records a refused call's start anyway); only an
@@ -205,10 +219,13 @@ export async function createOrchestrator({ turnId, runtime, trace, admit, reques
     steps.delete(native);
     if (aliases.size > 256) aliases.delete(aliases.keys().next().value);
   };
-  // Codex V2 names a child `backend` or `/root/backend` interchangeably.
+  // Codex V2 names a child `backend` or `/root/backend` interchangeably, and
+  // a sealed child registers by the canonical path its task message wears.
   const named = native => {
+    if (typeof native !== 'string') return resolve(native);
     if (aliases.has(native) || records.has(native)) return resolve(native);
-    const hits = new Set([...aliases].filter(([k]) => k.endsWith(`/${native}`) || native.endsWith(`/${k}`)).map(([, v]) => v));
+    const near = k => k.endsWith(`/${native}`) || native.endsWith(`/${k}`);
+    const hits = new Set([...[...aliases].filter(([k]) => near(k)).map(([, v]) => v), ...[...records.keys()].filter(near)]);
     return hits.size === 1 ? [...hits][0] : native;
   };
   function postSpawn(event) {
@@ -219,7 +236,7 @@ export async function createOrchestrator({ turnId, runtime, trace, admit, reques
     if (failed) { release(id); emit({ id, status: 'stopped' }); }
   }
   function preResume(event) {
-    const input = event.tool_input ?? {}, { claude, native } = followupTarget(event);
+    const input = event.tool_input ?? {}, { claude, native, sealed } = followupTarget(event);
     if (native === null) return claude ? null : { deny: 'Name the native agent to resume.' };
     const id = named(native);
     if (!records.has(id)) {
@@ -227,7 +244,7 @@ export async function createOrchestrator({ turnId, runtime, trace, admit, reques
       // SendMessage also reaches "main" and teammates: only a known child is a follow-up.
       if (claude) return null;
       if (records.size >= SUBAGENT_CAP) return { deny: 'Continue the work in this run’s orchestrator.' };
-      emit({ id, kind: '', title: native, brief: typeof input.message === 'string' ? input.message : '', status: 'waiting', now: WAIT, resumable: true });
+      emit({ id, kind: '', title: native, ...(sealed ? {} : { brief: typeof input.message === 'string' ? input.message : '' }), status: 'waiting', now: WAIT, resumable: true });
     }
     if (spawnable(records.get(id))) return { deny: `Agent ${id} has not started. Retry its native spawn instead.` };
     // A refused follow-up retried on its offered slot reaches a finished child.
@@ -236,6 +253,9 @@ export async function createOrchestrator({ turnId, runtime, trace, admit, reques
     start(records.get(id), 'Continuing with the orchestrator’s note');
     records.get(id).queued = running;
     calls.set(event.tool_use_id, id);
+    // A sealed follow-up rides as written; its child registers by task name
+    // if this run has not bound it yet (the refusal at its first tool says how).
+    if (sealed) { sealedRun = true; return {}; }
     return typeof input.message === 'string' ? { updatedInput: { ...input,
       message: input.message + `\n\nCurrent card orchestrator agent record id: ${id}. Before continuing work, call card_orchestrator.register_agent with this id. Return questions to the orchestrator.` } } : {};
   }
@@ -259,6 +279,10 @@ export async function createOrchestrator({ turnId, runtime, trace, admit, reques
     return { deny: 'Your orchestrator has a note for this checkpoint. Stop editing and wait for its follow-up; keep your work so far.' };
   }
   function hook(ev) {
+    // A sealed child's contract, as it starts (measured on codex-cli 0.163
+    // and 0.164: this additionalContext reached the child, and the event
+    // names the child's agent_id but not the spawn that started it).
+    if (ev.hook_event_name === 'SubagentStart') return sealedRun && childOf(ev) ? { context: childContract().trimStart() } : {};
     // A child's next tool round carries a follow-up queued to it; after its
     // stop, its own tool use is the CLI running it again with that follow-up.
     const kid = records.get(resolve(childOf(ev)));
@@ -275,12 +299,14 @@ export async function createOrchestrator({ turnId, runtime, trace, admit, reques
       if (String(ev.tool_name).includes(ORCHESTRATOR_SERVER) && String(ev.tool_name).endsWith('register_agent')) {
         // Binding the root would pause the orchestrator at its children's checkpoints.
         if (!child) return { deny: 'Only a native child registers an agent record. As the orchestrator, use the record id with describe_agent, route_message or answer_agent.' };
-        const id = resolve(ev.tool_input?.agentId);
-        if (!records.has(id)) return { deny: 'Use the agent record id in your prompt.' };
+        const id = named(ev.tool_input?.agentId);
+        if (!records.has(id)) return { deny: sealedRun ? `That names no agent in this run.${childContract()}` : 'Use the agent record id in your prompt.' };
         bind(child, id);
       }
+      // A sealed child that missed (or never got) its start's words reads
+      // them here, whole: an earlier run's follow-up, or a CLI without the hook.
       if (child && !records.has(resolve(child)) && !isDiscoveryTool(ev.tool_name))
-        return { deny: 'Before working, call card_orchestrator.register_agent with the agent record id in your prompt. Tool discovery is allowed.' };
+        return { deny: sealedRun ? `Register with your orchestrator before working.${childContract()}` : 'Before working, call card_orchestrator.register_agent with the agent record id in your prompt. Tool discovery is allowed.' };
       if ((child && access === 'read' || readOnlyRun) && isChildWriteTool(ev.tool_name)) return { deny: readOnlyRun ? 'This attempt only reads: no file writes.' : READ_ONLY_REFUSAL };
       if (rootTools && captureToolName(ev.tool_name)) {
         if (child || !rootSession || ev.session_id !== rootSession) return { deny: 'Only the top-level capture coordinator may call capture tools. Return findings to it.' };
@@ -314,7 +340,7 @@ export async function createOrchestrator({ turnId, runtime, trace, admit, reques
       return held.length ? { ...result, context: [result.context, ...held].filter(Boolean).join('\n\n') } : result;
     }
     if (action === 'route_message') return route(args);
-    const id = resolve(args.agentId);
+    const id = named(args.agentId);
     // A person’s answer starts a new CLI turn. The parent carries the earlier
     // question and native identity in its own conversation; relay that known
     // context instead of inventing a new child or requiring another question.

package/bin/lib/orchestratorHooks.mjs

@@ -24,9 +24,22 @@ export function orchestratorHooks() {
   return { PreToolUse: [{ matcher: '.*', hooks }], PostToolUse: [{ matcher: spawns, hooks }], PostToolUseFailure: [{ matcher: spawns, hooks }], SubagentStop: [{ hooks }] };
 }
 
-export function codexOrchestratorArgs() {
+/**
+ * CODEX'S SubagentStart HANDS A SEALED CHILD ITS CONTRACT (2026-10-24). A V2
+ * spawn's message is ciphertext the gate must not edit (orchestratorNative.mjs
+ * `isSealedMessage`), so the words reach the child as this hook's
+ * additionalContext. Measured on real codex-cli 0.163.0 and 0.164.0 with this
+ * exact `matcher=".*"` row: the hook ran once per child and the child obeyed
+ * its context. Both CLIs start normally with the key (and with an unknown
+ * event's, offline). An older CLI is unmeasured, so it goes without; its
+ * children meet the same words when the gate refuses their first tool.
+ */
+export const CODEX_SUBAGENT_START_MIN = '0.163.0';
+export function codexOrchestratorArgs(codexVersion) {
   // A Codex `-c` value is TOML, quoted by the one quoter (codexToml.mjs).
   const row = `{matcher=".*",hooks=[{type="command",command=${toml(command())},timeout=${ORCHESTRATOR_HOOK_TIMEOUT_S}}]}`;
+  const start = versionAtLeast(String(codexVersion ?? '').replace(/^codex-cli\s+/, ''), CODEX_SUBAGENT_START_MIN);
   return ['--dangerously-bypass-hook-trust', '-c', 'features.hooks=true',
-    '-c', `hooks.PreToolUse=[${row}]`, '-c', `hooks.PostToolUse=[${row}]`, '-c', `hooks.SubagentStop=[${row}]`];
+    '-c', `hooks.PreToolUse=[${row}]`, '-c', `hooks.PostToolUse=[${row}]`, '-c', `hooks.SubagentStop=[${row}]`,
+    ...(start ? ['-c', `hooks.SubagentStart=[${row}]`] : [])];
 }

package/bin/lib/orchestratorNative.mjs

@@ -12,8 +12,27 @@
  */
 import { isBackgroundSpawnTool, isClaudeFollowupTool, isSpawnTool } from './nativeAgentTools.mjs';
 
+/**
+ * A CODEX V2 MESSAGE IS CIPHERTEXT (2026-10-24). Since codex-cli 0.138
+ * (openai/codex PR #26210) the model writes spawn_agent's and followup_task's
+ * `message` encrypted, and the child's first request hands it back to be
+ * decrypted. The gate appended its contract to it, so every V2 child of the
+ * card runs from 10-19 to 10-24 (133 of them) died on that request with
+ * `invalid_encrypted_content` before its first tool. Measured on real 0.164:
+ * no hook and an identity rewrite both ran the child; one appended line failed
+ * it. Sealed, a message is relayed untouched and never read as a brief.
+ * V2 is the `collaboration` namespace (all 209 real messages, every one a
+ * `gAAAAA…` token); the token's shape is checked too, so a sealed message under
+ * another spelling is never edited. Codex V1 and Claude write plain text.
+ */
+const SEALED_TOKEN = /^gAAAAA[A-Za-z0-9_-]{40,}={0,2}$/;
+export const isSealedMessage = (toolName, message) => typeof message === 'string' &&
+  !isBackgroundSpawnTool(toolName) && !isClaudeFollowupTool(toolName) &&
+  (/^collaboration[./]?(?:spawn_agent|followup_task)$/.test(String(toolName ?? '')) || SEALED_TOKEN.test(message));
+
 /** A spawn's prompt and the fields a waiting record is matched and named by,
- * or null when the gate cannot hold it (no call id or no text prompt). */
+ * or null when the gate cannot hold it (no call id or no text prompt). A
+ * sealed message (`isSealedMessage`) gives no brief: its words are unknown. */
 export function readSpawn(event) {
   // A child stays in the card's worktree on this machine, inside the pool.
   const { isolation, cwd, ...input } = event.tool_input ?? {}, callId = event.tool_use_id;
@@ -21,18 +40,20 @@ export function readSpawn(event) {
   const items = Array.isArray(input.items) ? input.items : null;
   const key = ['prompt', 'message'].find(k => typeof input[k] === 'string') ?? (items ? 'items' : null);
   if (!callId || !key) return null;
-  const brief = key === 'items' ? items.filter(i => i?.type === 'text' && typeof i.text === 'string').map(i => i.text).join('\n') : input[key];
-  return { callId, input, items, key, brief, relocated: isolation !== undefined || cwd !== undefined,
+  const sealed = key === 'message' && isSealedMessage(event.tool_name, input.message);
+  const brief = sealed ? null : key === 'items' ? items.filter(i => i?.type === 'text' && typeof i.text === 'string').map(i => i.text).join('\n') : input[key];
+  return { callId, input, items, key, brief, sealed, relocated: isolation !== undefined || cwd !== undefined,
     resume: typeof input.resume === 'string' ? input.resume : null,
     title: input.description ?? input.task_name, kind: input.subagent_type ?? input.agent_type,
     names: [input.name, input.task_name] };
 }
 
 /** The spawn's input as the gate rewrites it: the contract appended to its
- * prompt, a Claude child sent to the background, and the child's model and
- * effort (`brain`, from `childBrain`) where the spawn named none. */
+ * prompt (never to a sealed message, whose child is handed it at its start),
+ * a Claude child sent to the background, and the child's model and effort
+ * (`brain`, from `childBrain`) where the spawn named none. */
 export const withChildContract = (event, spawn, contract, brain = {}) => ({ ...spawn.input, ...brain, ...(isBackgroundSpawnTool(event.tool_name) ? { run_in_background: true } : {}),
-  ...(spawn.key === 'items' ? { items: [...spawn.items, { type: 'text', text: contract.trimStart() }] } : { [spawn.key]: spawn.input[spawn.key] + contract }) });
+  ...(spawn.sealed ? {} : spawn.key === 'items' ? { items: [...spawn.items, { type: 'text', text: contract.trimStart() }] } : { [spawn.key]: spawn.input[spawn.key] + contract }) });
 
 /** Both CLIs' effort ladder, lowest first (Codex stops at xhigh). */
 export const EFFORT_LADDER = Object.freeze(['low', 'medium', 'high', 'xhigh', 'max']);
@@ -178,11 +199,11 @@ export function spawnReceipt(event) {
   return { ids, failed: Boolean(output?.is_error || output?.isError || event.error) };
 }
 
-/** Which child a follow-up addresses (null when it names none in bounds), and
- * whether it is Claude's SendMessage. */
+/** Which child a follow-up addresses (null when it names none in bounds),
+ * whether it is Claude's SendMessage, and whether its message is sealed. */
 export function followupTarget(event) {
   const input = event.tool_input ?? {}, claude = isClaudeFollowupTool(event.tool_name);
   // Measured Claude 2.1.302 PreToolUse SendMessage input: {to, message, recipient, content, …}.
   const native = claude ? input.to ?? input.recipient ?? input.target ?? input.id : input.target ?? input.id;
-  return { claude, native: typeof native === 'string' && native.length <= 160 ? native : null };
+  return { claude, native: typeof native === 'string' && native.length <= 160 ? native : null, sealed: isSealedMessage(event.tool_name, input.message) };
 }

package/bin/lib/prompts.mjs

@@ -24,7 +24,7 @@ import { AGENT_PREREQUISITE_CONTRACT } from './agentPrerequisiteContract.mjs';
 import { agentTaskKindOf } from './agentTaskKinds.mjs';
 // A card's type (0.106.0) likewise: the table holds the words, this file prints them.
 import { AGENT_TASK_TYPES, agentTaskTypeFor, agentTaskTypeOf } from './agentTaskTypes.mjs';
-import { ARTIFACT_CONTRACT_TAIL, HELP_THEM_DECIDE, LOOK_HEADLESS, SYSTEM_AGENT_DECK, SYSTEM_AGENT_IMAGE, SYSTEM_AGENT_MODEL } from './artifactContracts.mjs';
+import { ARTIFACT_CONTRACT_TAIL, HELP_THEM_DECIDE, LOOK_HEADLESS, SYSTEM_AGENT_DECK, SYSTEM_AGENT_IMAGE, SYSTEM_AGENT_MODEL, WHOLE_REQUEST } from './artifactContracts.mjs';
 import { isLibraryReference } from './knowledgeLibrary.mjs';
 import { readCardThread } from './cardThread.mjs';
 import { AGENT_FILE_LINE_MAX, AGENT_FILES_PER_MESSAGE_MAX, CARD_FILES_PER_TURN_MAX } from './agentFiles.mjs';
@@ -581,9 +581,19 @@ with the matching name your CLI exposes.
    ask: each brief names the original ask, the part this card delivers and
    what its sibling cards own, and carries the context its agent needs — the
    design link or kept reference, the expected look and behaviour of its
-   area, the files you found. If you could not open or read a reference, say
-   so in each brief and in \`assumed\`, and cut by what the person described
-   and the current product shows; never invent what it contains. For example,
+   area, the files you found. Copy the person's links, design references and
+   file lists into every brief they shape, word for word. If you could not
+   open or read a reference, say so in each brief and in \`assumed\`, and cut
+   by what the person described and the current product shows; never invent
+   what it contains. AN UNREAD REFERENCE NEVER NARROWS SCOPE: write "UNREAD
+   AT PLANNING: <the link or name>. The agent working this card opens it
+   itself (a Claude Code agent reads a claude.ai/design link with its
+   DesignSync tool), builds this card's share of all of it, and names any part
+   no card owns." Never write that the agent should use only what you could
+   read as its scope, and never state that the reference is unavailable to the
+   agent: your read access is not its. When the person names a design or
+   mockup without a link, look for its link in the repository's docs, decision
+   records and the Library, and carry what you found. For example,
    "remake the settings page from this design", where the design shows a new
    sidebar, a redesigned profile form, a billing tab and inline save
    confirmations, is four cards, each carrying the design link and the
@@ -1268,6 +1278,8 @@ implementation and ask for the person's decision. Unknown generator-source
 identity is not a claim that an embedded GLB image is the original PNG. Opening
 a result handoff never authorizes an automatic asset commit or merge.
 
+${WHOLE_REQUEST}
+
 ${HELP_THEM_DECIDE}`;
 
 /**
@@ -1814,6 +1826,15 @@ HOW TO READ IT:
    asked for that the diff does not show, changes that reach further than the
    card did. Not formatting, not naming preferences, not the rewrite you would
    have preferred.
+6. THE WHOLE REQUEST, AND WHAT THE AGENT SAYS IS MISSING. A card may carry
+   THE PERSON'S OWN WORDS (the chat it was planned in) and the agent's
+   declared gaps. Judge the diff against the words as well as the criteria:
+   a screen, state, rule or linked design file the person asked for that the
+   diff does not show and the gaps do not list is a concern, named in the
+   card's note. A declared gap is the agent being honest, not a concern by
+   itself; put the serious ones in "overall" so the reviewer meets them first.
+   A linked design you cannot open is named in the note as unchecked, never
+   judged from its name.
 
 END YOUR TURN WITH ONE JSON OBJECT AND NOTHING AFTER IT, in a \`\`\`json fence:
 

package/bin/lib/runtimeCodex.mjs

@@ -347,7 +347,7 @@ export const CODEX_RUNTIME = {
     if (a.includes('--ignore-user-config')) a.push(...(personal?.args ?? []));
 
     a.push(...mcp, ...resultSchemaArgs);
-    if (gated) a.push(...codexOrchestratorArgs());
+    if (gated) a.push(...codexOrchestratorArgs(codexVersion));
     a.push(streamInput ? '-' : codexPrompt({ system, prompt, profile }));
     return a;
   },

package/bin/lib/turnGaps.mjs

@@ -0,0 +1,47 @@
+/**
+ * WHAT THE AGENT SAYS IT DID NOT DELIVER (2026-10-25).
+ *
+ * An audit of eighteen merged runs found the same shape in most of them: the
+ * delivery report said what was done and how it was checked, and nothing in
+ * the contract asked what was NOT done against the request — so a dropped
+ * design state came back as a "decision" ("Before Review they keep the old
+ * per-card plates"), a faked measurement as "measured 2500ms", and the pre-review,
+ * grading only the card's own checklist, passed both. The contract's
+ * `WHOLE_REQUEST` now asks for `gaps`; this reads them and says them where the
+ * person reviews (Verification on a code card, the summary on any other).
+ *
+ * THREE STATES, the house rule: no key is unknown and renders NOTHING (an
+ * older prompt, a resumed conversation that never saw it); `[]` is the
+ * agent's claim that it walked the request and nothing is missing; entries are
+ * listed. A malformed entry costs that entry alone.
+ */
+export const GAP_STATUSES = ['not built', 'partly', 'unverified', 'unowned'];
+export const MAX_GAPS = 40;
+export const MAX_GAP_ITEM = 300;
+export const MAX_GAP_WHY = 800;
+
+const cut = (s, n) => (s.length > n ? s.slice(0, n - 1) + '…' : s);
+
+/** The declared gaps, scrubbed then bounded; undefined when none were declared. */
+export function parseGaps(raw, scrub) {
+  if (!Array.isArray(raw)) return undefined;
+  const out = [];
+  for (const g of raw) {
+    if (out.length >= MAX_GAPS) break;
+    if (!g || typeof g !== 'object' || typeof g.item !== 'string' || !g.item.trim()) continue;
+    const status = typeof g.status === 'string' ? g.status.trim().toLowerCase() : '';
+    if (!GAP_STATUSES.includes(status)) continue;
+    const why = typeof g.why === 'string' && g.why.trim() ? cut(scrub(g.why.trim()), MAX_GAP_WHY) : null;
+    out.push({ item: cut(scrub(g.item.trim()), MAX_GAP_ITEM), status, ...(why ? { why } : {}) });
+  }
+  return out;
+}
+
+/** The section the person reads, or null for no declaration. */
+export function gapsMarkdown(gaps) {
+  if (!Array.isArray(gaps)) return null;
+  if (!gaps.length) return '**Gaps against the request:** none reported.';
+  return ['**Gaps against the request**', ...gaps.map((g) => `- **${g.status}** — ${oneLine(g.item)}${g.why ? `: ${oneLine(g.why)}` : ''}`)].join('\n');
+}
+
+const oneLine = (s) => s.replace(/\s*\n\s*/g, ' ');

package/bin/lib/uiReviewContract.mjs

@@ -46,6 +46,6 @@ export function validateReviewPlan(plan) {
 
 export function uiReviewInstructions(argv) {
   return `LOCAL UI SELF-REVIEW — before delivering UI-changing code, use this turn's owned headless runner: ${JSON.stringify([...argv, '<plan.json>'])}.
-Read repository preview scripts and affected acceptance criteria first. Write a JSON plan with command (argv array), basis (repository file/script), cwd (relative directory, optional), port (dedicated port explicitly set in command), readyPath, fixture: { isolated: true, description }, and scenarios: [{ name, path, actions: [{ type, selector, value }] }]. Actions: click, fill, submit, assertText, assertUrl (value is a local path), waitFor. Use only disposable local fixtures; never production data, real email, payments, personal sessions or credentials. The runner starts and measures its own preview and permits only that preview's resources. External dependencies are blocked and reported; use local fixtures instead.
+Read repository preview scripts and affected acceptance criteria first. Write a JSON plan with command (argv array), basis (repository file/script), cwd (relative directory, optional), port (dedicated port explicitly set in command), readyPath, fixture: { isolated: true, description }, and scenarios: [{ name, path, actions: [{ type, selector, value }] }]. Actions: click, fill, submit, assertText, assertUrl (value is a local path), waitFor. Use only disposable local fixtures; never production data, real email, payments, personal sessions or credentials. The runner starts and measures its own preview and permits only that preview's resources. External dependencies are blocked and reported; use local fixtures instead. Shape the fixture from the case the request describes, not from your implementation: the person's screenshot or report (its counts, names and states, such as a 23-card agent or a page with no stored render) or a committed export of real data among the repository's test fixtures when one exists. A fixture shaped only by your own code shows the code renders, not that the request is met: list that as an "unverified" gap.
 Run desktop and mobile scenarios; read the returned report and OPEN EVERY returned screenshot using card_ui_review.inspect_screenshot when that tool is actually mounted (it returns the exact PNG as native image input), or your runtime's actual image-input tool (for example Read or view_image). Record which files you visually inspected and what you observed in delivery verification. A PNG path, capture success, tool listing or a skill is not proof of inspection. If image input is unavailable, report visual inspection skipped with its measured reason. Check console/network findings, expected and observed interaction results. Fix in-scope problems in this same worktree and rerun affected checks. At most ${UI_REVIEW_MAX_RUNS} runs per turn, each at most ${UI_REVIEW_TIMEOUT_MS / 1000}s; at the bound deliver remaining findings honestly. Later source edits invalidate earlier evidence; commit before the final run when possible. Include changed routes, ordered actions/outcomes, viewport sizes, screenshots, changes prompted by review and every unrun/unavailable check with reasons in verification. Missing browser, runnable preview or safe fixtures is unavailable, never passed; do not install tools or weaken isolation. This review never approves or merges work. For non-UI changes, state why browser review is not applicable.`;
 }

package/bin/lib/workAgentPrecheck.mjs

@@ -11,6 +11,7 @@ import { FLEET_URL } from './config.mjs';
 import { gitOrNull } from './git.mjs';
 import { parsePrecheck } from './agentPlan.mjs';
 import { readStash } from './agentCards.mjs';
+import { gapsMarkdown } from './turnGaps.mjs';
 import { c, note } from './ui.mjs';
 import { runTurn as defaultRunTurn } from './runTurn.mjs';
 import { SYSTEM_PRECHECK, AGENT_PRECHECK_KICKOFF } from './prompts.mjs';
@@ -222,7 +223,9 @@ export function createWorkAgentPrecheck({ baseRef, admit, sessionMetaPath, workC
         turnArgs: {
           prompt: AGENT_PRECHECK_KICKOFF({
             agentName,
-            cards: stash.map((s) => s.prompt).join('\n---\n'),
+            // Each spec with the agent's own account of what it did not
+            // deliver; no declaration is said, never read as "nothing missing".
+            cards: stash.map((s) => `${s.prompt}\n\n${gapsMarkdown(s.gaps) ?? "The agent declared no gaps list for this card."}`).join('\n---\n'),
             missingSpecs,
             commits: log.text,
             diffCommand: `git diff ${repository?.baseRef ?? baseRef()}...HEAD`,

package/bin/lib/workAgentTurnExecution.mjs

@@ -2,7 +2,7 @@ import { reportLocalCleanup } from './localCleanupReport.mjs';
 import { createManagedLocalCleanup } from './managedLocalCleanup.mjs';
 import { createCaptureRetention } from './referenceCaptures.mjs';
 import { imageRevisionInstructions } from './artifactIteration.mjs';
-import { agentChildScope } from './agentQueueContext.mjs';
+import { agentChildScope, sourceChatText } from './agentQueueContext.mjs';
 import { measureTestFindings } from './testFindings.mjs';
 import { fetchResultInputs } from './resultInputs.mjs';
 import { agentWork } from './workActivity.mjs';
@@ -33,7 +33,7 @@ import { setRuntimeLimit } from './daemonState.mjs';
 import { gitOrNull } from './git.mjs';
 import { turnCommits } from './turnReceipts.mjs';
 import { addUsage } from './turnUsage.mjs';
-import { stashCard } from './agentCards.mjs';
+import { stashCard, stashGaps } from './agentCards.mjs';
 import { c } from './ui.mjs';
 import { runTurn } from './runTurn.mjs';
 import { liveGroups, processesSupported } from './processes.mjs';
@@ -326,7 +326,7 @@ export function createAgentTurnExecution({
       stashCard(
         sessionMetaPath(wt, 'flowviant-agent-cards', agentId),
         job.task.id,
-        AGENT_TASK_SPEC(job.task, job.cardThread, files.card)
+        AGENT_TASK_SPEC(job.task, job.cardThread, files.card) + sourceChatText(job.queueContext, job.task.id)
       );
     }
 
@@ -845,6 +845,9 @@ export function createAgentTurnExecution({
       modelExports: intermediateDelivery?.modelExports,
     });
     appendUiReviewEvidence(body, uiReviewEvidence);
+    // The agent's own account of what it did not deliver, for the pre-review.
+    if (job.kind === 'task' && job.task && body.outcome === 'delivered' && res?.gaps)
+      stashGaps(sessionMetaPath(wt, 'flowviant-agent-cards', agentId), job.task.id, res.gaps);
     if (body.outcome === 'delivered') intermediateDelivery?.commit();
     // This place's writer lock is still held. Measure the exited children
     // and their groups before releasing any file requirements. Dirty repository files are unrelated to managed scratch eligibility.

package/bin/lib/workAgentTurnOutcome.mjs

@@ -34,6 +34,7 @@ import { usableImageArtifact } from './imageArtifact.mjs';
 import { withoutTurnDeclaration } from './turnDeclaration.mjs';
 import { ANSWER_DELIVERED_USES, researchUseOf, withResearchHeader } from './researchUse.mjs';
 import { measuredModelExports } from './intermediateArtifacts.mjs';
+import { gapsMarkdown } from './turnGaps.mjs';
 
 /** Materialization runs only for a declared delivery; settlement remains the
  * sole parser and the sole authority deciding whether it really delivered. */
@@ -166,6 +167,11 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
     : 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;
+  /* WHAT IT SAYS IT DID NOT DELIVER (turnGaps.mjs), where the person reads
+     the delivery: Verification on a code card, which carries it; the summary
+     on every other kind, which has no Verification lane. */
+  const gaps = res.outcome === 'delivered' && !cannotRequest ? gapsMarkdown(res.gaps) : null;
+  const verification = [res.verification, kind.posture === 'build' ? gaps : null].filter(Boolean).join('\n\n');
   return report(
     {
       turnId,
@@ -173,16 +179,20 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
       outcome: res.outcome,
       answer: cannotRequest ?? envScrub((kind.posture === 'research' && researchUse
         ? withResearchHeader(researchUse, res.answer ?? '') : res.answer ?? '') +
-        (job.task?.taskType === 'tests' && res.raised?.length ? '\n\nAdditional CLI-reported findings (not filed as fixes):\n' + res.raised.map(r => `${r.title}\n${r.brief ?? ''}`).join('\n\n') : '')),
+        (job.task?.taskType === 'tests' && res.raised?.length ? '\n\nAdditional CLI-reported findings (not filed as fixes):\n' + res.raised.map(r => `${r.title}\n${r.brief ?? ''}`).join('\n\n') : '') +
+        (gaps && kind.posture !== 'build' ? `\n\n${gaps}` : '')),
       // CLI-authored evidence travels separately from the short answer and
       // measured commits/checks. Older turns simply send no report.
-      ...(kind.posture === 'build' && res.outcome === 'delivered' && res.verification
-        ? { verification: envScrub(res.verification) } : {}),
+      ...(kind.posture === 'build' && res.outcome === 'delivered' && verification
+        ? { verification: envScrub(verification) } : {}),
       ...(kind.posture === 'build' && res.outcome === 'delivered' && res.handover
         ? { handover: envScrub(res.handover) } : {}),
       ...(kind.posture === 'build' && res.outcome === 'delivered' && res.automation
         ? { automation: envScrub(res.automation) } : {}),
       ...(commits.length ? { commits } : {}),
+      // …and the same gaps as data, so the server can propose the parts no
+      // card owned (`gapFollowUps.ts`). A report: an older server drops it.
+      ...(gaps && res.gaps?.length ? { gaps: res.gaps } : {}),
       // SCRUBBED like the answer beside it: a raised card lands in the
       // project doc every member reads, and a brief quoting the `.env` the
       // agent just read ("value sk_live_… is logged in pay.ts") went out

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.125.21",
+  "version": "0.125.22",
   "description": "Run your own coding CLIs as build agents for Flowviant \u2014 Claude Code, Codex or Antigravity, on your own credentials. Holds your sessions, keeps a worktree per tab, and ships branches on your word.",
   "type": "module",
   "bin": {