flowviant 0.113.0 → 0.114.1

package/bin/lib/runtimeLimits.mjs

@@ -235,7 +235,25 @@ async function lastRateLimits(file) {
  */
 export async function learnCodexLimits(threadId, { env = process.env, now } = {}) {
   try {
-    if (typeof threadId !== 'string' || !CODEX_THREAD_RE.test(threadId)) return false;
+    const file = await codexRolloutFile(threadId, { env });
+    if (!file) return false;
+    const rl = await lastRateLimits(file);
+    if (!rl) return false;
+    recordCodexRateLimits(rl, now ?? Date.now());
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * WHERE A CODEX THREAD'S ROLLOUT IS, or null — the one lookup (and its cache)
+ * every reader of that file shares: the plan windows above, and the model a
+ * turn ran on (turnModel.mjs, 2026-09-29). Never throws.
+ */
+export async function codexRolloutFile(threadId, { env = process.env } = {}) {
+  try {
+    if (typeof threadId !== 'string' || !CODEX_THREAD_RE.test(threadId)) return null;
     const root = join(env.CODEX_HOME || join(homedir(), '.codex'), 'sessions');
     const key = `${root}\0${threadId}`;
     let file = rolloutPaths.get(key) ?? null;
@@ -249,16 +267,13 @@ export async function learnCodexLimits(threadId, { env = process.env, now } = {}
     }
     if (!file) {
       file = await findRollout(root, threadId);
-      if (!file) return false;
+      if (!file) return null;
       rolloutPaths.set(key, file);
       if (rolloutPaths.size > ROLLOUT_PATHS_MAX) rolloutPaths.delete(rolloutPaths.keys().next().value);
     }
-    const rl = await lastRateLimits(file);
-    if (!rl) return false;
-    recordCodexRateLimits(rl, now ?? Date.now());
-    return true;
+    return file;
   } catch {
-    return false;
+    return null;
   }
 }
 

package/bin/lib/runtimes.mjs

@@ -156,6 +156,9 @@ const PROFILE_NEEDS_MCP = {
   // says rides the final JSON — so neither non-code posture needs one.
   design: false,
   research: false,
+  // …and the image posture's (0.114.0), for the same reason: no MCP on an
+  // agent turn.
+  image: false,
 };
 
 /**

package/bin/lib/startProject.mjs

@@ -33,7 +33,7 @@ async function reexecAfterLogin() {
 
 // TWO ROWS THAT READ ALIKE ARE NOT A CHOICE. `projectRowLabel` adds the id and
 // the connected date to the COLLIDING rows only — production held two projects
-// both called "BRIF AI", both bound to the same checkout, so this picker
+// with one name, both bound to the same checkout, so this picker
 // offered two identical lines and the only way to answer was to guess. See
 // credentials.mjs for why the suffix is not on every row. (That exact case is
 // a refusal now rather than a picker — a directory serves one project — but
@@ -62,7 +62,7 @@ export async function resolveStartProject({ dirGiven }) {
   // binds it, and a headless start with no unambiguous answer refuses in words
   // that name every stored project and every way out. The one thing this block
   // must never do is serve a project the resolution did not name — "it said
-  // skadooble in my calendar repo" is the confusion this exists to end.
+  // contoso in my calendar repo" is the confusion this exists to end.
   // A RESTART IS NOT A PERSON. `reexec` (update.mjs) inherits stdio, so an
   // auto-updated daemon's child sees two TTYs; without this it would stop on the
   // binding confirm below and the machine would stay dark until somebody typed a
@@ -122,7 +122,7 @@ export async function resolveStartProject({ dirGiven }) {
 
       const loginLabel = `connect ${repoRoot ? 'this repo' : 'a repo'} to a different project (${terminalCommand('login')})`;
       // WHICH ONE LOOKS RIGHT — a pre-selection, never an auto-serve. The resolver
-      // refuses to serve a project the repo PATH did not name (the skadooble law);
+      // refuses to serve a project the repo PATH did not name (the contoso law);
       // this only decides which row the cursor starts on, using the repo's folder
       // name and its github repo-name against the stored project names. A unique
       // match becomes ONE keypress; a wrong guess costs nothing, because the human
@@ -136,7 +136,7 @@ export async function resolveStartProject({ dirGiven }) {
 
       // Bounded like the confirm below, and for the same reason — but silence
       // means something DIFFERENT here and the difference is load-bearing. There
-      // is a real ambiguity to resolve; serving a guess is the skadooble bug.
+      // is a real ambiguity to resolve; serving a guess is the contoso bug.
       // So no answer REFUSES, which is exactly what this branch already does
       // headless, and the message says how to answer without being present.
       let chosen = null; // 0-based into [...choices, login]
@@ -220,7 +220,7 @@ export async function resolveStartProject({ dirGiven }) {
   } else if (!externalToken && CREDENTIAL.needsConfirm && interactive) {
     // ONE stored project, never tied to a repo — the pre-0.55.0 world. Ask once;
     // yes binds and every later start is silent. This is the exact question
-    // whose absence had a calendar checkout serving skadooble.
+    // whose absence had a calendar checkout serving contoso.
     //
     // AND IT TIMES OUT, because a prompt on a start path is a way for a machine
     // to go dark. `FLOWVIANT_REEXEC` above covers the restart THIS version
@@ -240,7 +240,7 @@ export async function resolveStartProject({ dirGiven }) {
     //    not, which is the whole reason this product has exactly one refusal.
     //  · DO NOT BIND, because binding is the thing the question was FOR. Nobody
     //    answered, so nothing is cemented; the next human start asks again. That
-    //    keeps the skadooble case fixed for the person who is actually looking,
+    //    keeps the contoso case fixed for the person who is actually looking,
     //    which is the only person it could ever have been fixed for.
     const creds = await import('./credentials.mjs');
     const label = creds.projectLabel(CREDENTIAL.entry);

package/bin/lib/turnModel.mjs

@@ -0,0 +1,120 @@
+/**
+ * WHICH MODEL A TURN ACTUALLY RAN ON, IN THE CLI'S OWN WORDS (2026-09-29).
+ *
+ * The owner: "how do users know which model of opus are they using on
+ * flowviant? like opus 5, or opus 5.5". A pin reads as typed ("opus") or as
+ * the machine default, and `opus` is an alias the CLI resolves on its own
+ * cadence — so the only true answer is the one the CLI gives about the turn it
+ * just ran. This file reads it; the settle bodies carry it as `model`; the app
+ * shows it by name. A RELAY: nothing here maps an alias to a model or guesses.
+ *
+ * TWO SOURCES, ONE SHAPE:
+ *
+ *  · CLAUDE CODE says it on the stream. MEASURED on Claude Code 2.1.284,
+ *    2026-09-29 (`claude -p "say hi" --model haiku --output-format
+ *    stream-json --verbose`): the `system`/`init` event carries
+ *    `model: "claude-haiku-4-5-20251001"`, and every top-level `assistant`
+ *    event carries the same id as `message.model`. claudeStream.mjs hands both
+ *    over; runTurn.mjs keeps the first valid one per spawn, so the init wins
+ *    and the first reply is the fallback. A subagent's messages
+ *    (`parent_tool_use_id` set) are not the turn's model and are not read; a
+ *    synthetic error message says `<synthetic>`, which the shape refuses.
+ *  · CODEX says it in a file. `codex exec --json` (0.156.1) puts no model on
+ *    stdout — its ThreadEvent vocabulary is thread/turn/item lifecycle and
+ *    token usage only — but the thread's rollout writes one `turn_context`
+ *    line per turn whose `payload.model` is the model that turn resolved
+ *    (`"model":"gpt-6-sol"`, beside `collaboration_mode.settings.model` and
+ *    `effort`). After the child closes, runTurn.mjs asks
+ *    `codexTurnModel` for the NEWEST `turn_context` — and only one written
+ *    since the spawn, so a resumed thread whose turn died before its context
+ *    was written never reports the previous turn's model as this one's.
+ *
+ * THREE STATES: a valid id is a measurement; null is "not measured" and the
+ * settle carries no key at all. There is no empty value.
+ *
+ * THE SHAPE is the app's (`packages/shared/src/schemas/turnModel.ts` exports
+ * `TURN_MODEL_MAX` and `TURN_MODEL_RE`; `scripts/check-app-parity.mjs` holds
+ * them equal): the server re-applies it, so a looser copy here would only
+ * have a model dropped at the boundary.
+ */
+
+import { open } from 'node:fs/promises';
+import { codexRolloutFile } from './runtimeLimits.mjs';
+
+/** The longest model id a settle carries. */
+export const TURN_MODEL_MAX = 80;
+/** One model id — the CLIs' own alphabet (`claude-opus-5-5`, `gpt-6-sol`,
+ *  `us.anthropic.claude-…:0`, `org/model`). Anything else is not relayed. */
+export const TURN_MODEL_RE = /^[A-Za-z0-9._:\-/]{1,80}$/;
+
+/** A model id this daemon will relay, or null. */
+export function turnModelOf(v) {
+  return typeof v === 'string' && TURN_MODEL_RE.test(v) ? v : null;
+}
+
+/** Read backwards this much at a time… */
+const ROLLOUT_CHUNK_BYTES = 256 * 1024;
+/** …and no further than this: a turn's own lines past it are not searched. */
+const ROLLOUT_MODEL_SCAN_MAX = 32 * 1024 * 1024;
+/** A rollout stamp a little before the spawn still counts (clock rounding). */
+const SINCE_SLACK_MS = 2_000;
+
+/**
+ * THE MODEL OF THE NEWEST `turn_context` IN A CODEX THREAD'S ROLLOUT, when it
+ * was written at or after `since` (epoch ms); else null.
+ *
+ * Read BACKWARDS from the end in chunks, because the line sits at the START
+ * of its turn and a single turn's rollout runs to megabytes (2.8 MB measured
+ * for one agent turn). Only lines naming `"turn_context"` are parsed.
+ * Best-effort from end to end: it never throws.
+ */
+export async function codexTurnModel(threadId, { since = 0, env = process.env } = {}) {
+  let fh = null;
+  try {
+    const file = await codexRolloutFile(threadId, { env });
+    if (!file) return null;
+    fh = await open(file, 'r');
+    const { size } = await fh.stat();
+    let pos = size;
+    // The bytes of a line whose start is in a chunk not read yet.
+    let rest = Buffer.alloc(0);
+    while (pos > 0 && size - pos < ROLLOUT_MODEL_SCAN_MAX) {
+      const len = Math.min(ROLLOUT_CHUNK_BYTES, pos);
+      pos -= len;
+      const chunk = Buffer.alloc(len);
+      await fh.read(chunk, 0, len, pos);
+      let data = Buffer.concat([chunk, rest]);
+      if (pos > 0) {
+        const nl = data.indexOf(0x0a);
+        if (nl < 0) {
+          rest = data;
+          continue;
+        }
+        rest = data.subarray(0, nl);
+        data = data.subarray(nl + 1);
+      }
+      if (!data.includes('"turn_context"')) continue;
+      const lines = data.toString('utf8').split('\n');
+      for (let i = lines.length - 1; i >= 0; i--) {
+        if (!lines[i].includes('"turn_context"')) continue;
+        let ev;
+        try {
+          ev = JSON.parse(lines[i]);
+        } catch {
+          continue;
+        }
+        if (ev?.type !== 'turn_context') continue;
+        // The NEWEST context decides, whatever it says: an older one is a
+        // previous turn's.
+        const at = Date.parse(ev.timestamp ?? '');
+        if (!Number.isFinite(at) || at < since - SINCE_SLACK_MS) return null;
+        return turnModelOf(ev.payload?.model);
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    await fh?.close().catch(() => {});
+  }
+}

package/bin/lib/turnProfile.mjs

@@ -19,15 +19,29 @@
  *  - plan-mode — a Workbench plan turn: Claude Code's own
  *                `--permission-mode plan`, REPLACING the build posture, no MCP.
  *                Claude only. The adapter sees `build` (argv is `perm`);
- *  - design / research — a non-code card's posture (agentTaskKinds.mjs),
- *                refused on any runtime that does not DECLARE it, because every
- *                other adapter's fallback is its build branch.
+ *  - design / research / image — a non-code card's posture
+ *                (agentTaskKinds.mjs), refused on any runtime that does not
+ *                DECLARE it, because every other adapter's fallback is its
+ *                build branch. design and research are Claude Code's; image
+ *                (0.114.0) is Codex's.
  *
  * Claude's permission list for each name lives beside the lists themselves
  * (`claudePermFor`, claudePosture.mjs); this module owns the vocabulary and the
- * refusals, and imports only the card-kind table.
+ * refusals, and imports the card-kind table and the runtime registry (whose
+ * declared `profiles` say which CLI a kind posture runs on).
  */
 import { KIND_POSTURES } from './agentTaskKinds.mjs';
+import { RUNTIMES } from './runtimes.mjs';
+
+/** The CLIs that DECLARE a posture, by label — "Claude Code", "Codex". Read
+ *  from the registry, so the refusal names whoever can run it, never a CLI
+ *  written into the sentence by hand. */
+const declaredBy = (name) =>
+  Object.values(RUNTIMES)
+    .filter((rt) => (rt.profiles ?? []).includes(name))
+    .map((rt) => rt.label)
+    .join(' or ') || 'no CLI this daemon knows';
+const article = (word) => (/^[aeiou]/i.test(word) ? 'an' : 'a');
 
 const plain = (adapterProfile) => Object.freeze({ adapterProfile, onlyOn: null, strictMcp: false });
 
@@ -46,12 +60,17 @@ export const TURN_PROFILES = Object.freeze({
   }),
   // The kind postures: fenced to "write only the artifacts directory", and a
   // runtime that does not declare one would run its build branch instead.
+  // The sentence names the CLI(s) that do declare it: "a design card runs on
+  // Claude Code only", "an image card runs on Codex only".
   ...Object.fromEntries(
     KIND_POSTURES.map((name) => [
       name,
       Object.freeze({
         adapterProfile: name,
-        onlyOn: (rt) => ((rt.profiles ?? []).includes(name) ? null : `a ${name} card runs on Claude Code only — not '${rt.label}'`),
+        onlyOn: (rt) =>
+          (rt.profiles ?? []).includes(name)
+            ? null
+            : `${article(name)} ${name} card runs on ${declaredBy(name)} only — not '${rt.label}'`,
         strictMcp: false,
       }),
     ])

package/bin/lib/work.mjs

@@ -330,6 +330,8 @@ export function createWorkManager({
     postBestEffort,
     workChildren,
     groupKillChildren,
+    // Only to find the agent's browser profile (noWindowEnv.mjs).
+    sessionMetaPath,
   });
   const { runPrecheck } = createWorkAgentPrecheck({
     baseRef,

package/bin/lib/workAgentCheck.mjs

@@ -17,6 +17,7 @@ import { warn } from './ui.mjs';
 import { ARTIFACT_DIR, artifactTypeFor } from './artifacts.mjs';
 import { scrub as envScrub } from './uplinkScrub.mjs';
 import { withoutMachineCredentials } from './machineEnv.mjs';
+import { agentBrowserHome, openBrowserHome, withoutWindows } from './noWindowEnv.mjs';
 import { fleetEndpoint } from './fleetWire.mjs';
 import { workLanesStopped } from './standDownGate.mjs';
 
@@ -85,11 +86,14 @@ export function clearNonArtifacts(wt) {
  * authenticates with; everything else is what the agent's own turn saw when it
  * ran the same tests.
  */
-export function checkEnv(env = process.env) {
-  return withoutMachineCredentials(env);
+export function checkEnv(env = process.env, browserHome = null) {
+  // …and, like that turn since 2026-09-29, no way to a window: a test run
+  // nobody is watching that opens a headed browser or an HTML report opens it
+  // on nobody's behalf (noWindowEnv.mjs). The agent's own browser profile.
+  return withoutWindows(withoutMachineCredentials(env), browserHome);
 }
 
-export function createWorkAgentCheck({ repoRoot, postBestEffort, workChildren, groupKillChildren }) {
+export function createWorkAgentCheck({ repoRoot, postBestEffort, workChildren, groupKillChildren, sessionMetaPath }) {
   const AGENT_CHECK_DONE_URL = fleetEndpoint('agent-check-done', FLEET_URL);
 
   // ── THE PROJECT'S OWN CHECK, and the MERGE ─────────────────────────────────
@@ -142,6 +146,7 @@ export function createWorkAgentCheck({ repoRoot, postBestEffort, workChildren, g
       warn(
         `agent ${agentId}: removed ${cleared.length} non-artifact file(s) from ${ARTIFACT_DIR} before the check — ${cleared.slice(0, 5).join(', ')}`
       );
+    const browser = openBrowserHome(agentBrowserHome(sessionMetaPath, wt, agentId));
     const out = await new Promise((resolve) => {
       let text = '';
       let done = false;
@@ -178,7 +183,7 @@ export function createWorkAgentCheck({ repoRoot, postBestEffort, workChildren, g
           shell: true,
           detached: true,
           stdio: ['ignore', 'pipe', 'pipe'],
-          env: checkEnv(),
+          env: checkEnv(process.env, browser.dir),
         });
         /**
          * …AND IT IS TRACKED, so a stop or a takeover takes it with them.
@@ -266,6 +271,7 @@ export function createWorkAgentCheck({ repoRoot, postBestEffort, workChildren, g
         finish(code === 0 ? 'passed' : 'failed');
       });
     });
+    browser.cleanup();
     await postCheck({
       agentId,
       status: out.status,

package/bin/lib/workAgentPrecheck.mjs

@@ -20,6 +20,7 @@ import { removeProbeTranscript } from './runtimeCapabilities.mjs';
 import { taskIdsFromMessage } from './worktreeDiff.mjs';
 import { limitLine } from './cliLimit.mjs';
 import { fleetEndpoint } from './fleetWire.mjs';
+import { agentBrowserHome } from './noWindowEnv.mjs';
 
 export function createWorkAgentPrecheck({ baseRef, admit, sessionMetaPath, workChildren }) {
   const AGENT_PRECHECK_URL = fleetEndpoint('agent-precheck', FLEET_URL);
@@ -257,6 +258,9 @@ export function createWorkAgentPrecheck({ baseRef, admit, sessionMetaPath, workC
         profile: 'consult',
         cwd: wt,
         runtime: rt,
+        // The agent's own browser profile, in the worktree this reader stands
+        // in; no display either way (noWindowEnv.mjs, 2026-09-29).
+        browserHome: agentBrowserHome(sessionMetaPath, wt, agentId),
         // NO `resume`, AND THAT IS THE FEATURE. A resumed turn would be the
         // agent grading its own homework out of its own context; this is a
         // stranger reading a diff.

package/bin/lib/workAgentTurnExecution.mjs

@@ -37,6 +37,8 @@ import { CODEX_THREAD_RE } from './workSessionRuntime.mjs';
 import { brainFor } from './workBrain.mjs';
 import { begunTurnRefusal } from './workAgentTurnBegun.mjs';
 import { agentTurnSettlement } from './workAgentTurnOutcome.mjs';
+import { ensureArtifactDir } from './artifacts.mjs';
+import { agentBrowserHome } from './noWindowEnv.mjs';
 
 export function createAgentTurnExecution({
   baseRef,
@@ -227,6 +229,25 @@ export function createAgentTurnExecution({
       });
       return;
     }
+    /**
+     * A NON-CODE CARD WRITES ONE DIRECTORY, SO IT STANDS FIRST (0.114.0).
+     * Codex's image fence makes `.flowviant/artifacts` its only writable root
+     * and cannot create it from inside; every kind posture writes nowhere
+     * else. Made only as a real directory under a real `.flowviant`
+     * (`ensureArtifactDir`): a committed `.flowviant` symlink would otherwise
+     * point the fence's one write grant at somewhere outside the worktree. A
+     * worktree where it cannot stand is settled in words, before any CLI runs.
+     */
+    if (kind.artifact && !ensureArtifactDir(wt)) {
+      await postAgentTurn({
+        turnId,
+        outcome: 'nothing',
+        answer: "this worktree's .flowviant/artifacts is not a real directory, so there is nowhere to write what the card hands back",
+        branch,
+        worktree: wt,
+      });
+      return;
+    }
 
     // ONE AGENT IS ONE DIRECTORY, so the CLI's own cwd-keyed resume is exactly
     // right here — the ambiguity that forced per-tab session pinning in the
@@ -266,6 +287,23 @@ export function createAgentTurnExecution({
       rt === 'codex'
         ? Boolean(codexResumeId)
         : rt === 'claude' && Boolean(ranMarker && existsSync(ranMarker));
+    /**
+     * …AND THE HOME THAT THREAD IS FILED UNDER, KEPT PER AGENT (2026-09-29).
+     *
+     * Codex's thread index records each rollout under the CODEX_HOME the turn
+     * ran with, as that path — not the personal store the link leads to — so
+     * the per-turn home in /tmp every turn used to get died with its turn and
+     * took the pinned thread with it: the next card's `resume` failed "no
+     * rollout found" and the agent went to Stuck. Beside the thread marker,
+     * in the worktree's private git dir: outside the working tree (never
+     * committed, never seen by `git add -A`), refreshed by every turn and
+     * removed only with the worktree, when the agent retires and its threads
+     * stop mattering. One agent runs one turn at a time (its place's writer
+     * lock), so no two turns refresh it at once. Null (no git dir to hold it)
+     * is the per-turn home again, and a lost resume then runs once fresh.
+     */
+    const codexAgentHome =
+      rt === 'codex' ? sessionMetaPath(wt, 'flowviant-agent-codex-home', agentId) : null;
 
     /**
      * THE TURN'S FILES, ON DISK BEFORE THE PROMPT NAMES THEM (0.112.0) — the
@@ -356,6 +394,15 @@ export function createAgentTurnExecution({
 
     let out = '';
     let child = null;
+    /**
+     * EVERY CHILD THIS TURN SPAWNED, not only the last (2026-09-29). A lost
+     * resume runs once more fresh (runTurnResumingOnce), so a turn can own two
+     * CLIs, and `child` names only the second: the first stayed in
+     * `workChildren` for the life of the daemon — one phantom live turn per
+     * retry, held against the machine's ceiling, and `workBusy()` true for
+     * ever, which holds the self-update and the tray's install for ever.
+     */
+    const spawnedChildren = new Set();
     /**
      * WHAT THIS TURN SPENT, AS THE CLI COUNTED IT (2026-09-19).
      *
@@ -371,6 +418,9 @@ export function createAgentTurnExecution({
      * what makes `...(usage ? … : {})` the whole guard.
      */
     let usage = null;
+    /** 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;
     /**
      * THE AGENT'S LAST MESSAGE, ALONE — where the final JSON object lives.
      * Codex's `out` is every message plus stderr plus error text, and
@@ -386,7 +436,7 @@ export function createAgentTurnExecution({
     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);
+      projectTools = prepareAgentTools(readBaseTools(repoRoot, baseRef()), rt, process.env, wt, { codexHome: codexAgentHome });
       const agentTurnArgs = {
         prompt:
           job.kind === 'task' && job.task
@@ -427,6 +477,11 @@ export function createAgentTurnExecution({
         }) + (projectTools.instructions ? `\n\n${projectTools.instructions}` : ''),
         agentTools: projectTools,
         ...(projectTools.codexHome ? { mcpEnv: { CODEX_HOME: projectTools.codexHome } } : {}),
+        // 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'
@@ -493,6 +548,9 @@ export function createAgentTurnExecution({
         onUsage: (u) => {
           usage = { ...u, runtime: rt };
         },
+        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
@@ -505,6 +563,7 @@ export function createAgentTurnExecution({
         },
         onSpawn: (ch) => {
           child = ch;
+          spawnedChildren.add(ch);
           // The AGENT it serves — what the machine snapshot charges this
           // child's memory to.
           workChildren.set(ch, agentId);
@@ -539,11 +598,13 @@ export function createAgentTurnExecution({
         beforeFresh: () => {
           seenThreadId = null;
           lastAnswer = null;
+          model = null;
         },
       });
     } finally {
       // 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
@@ -557,7 +618,7 @@ export function createAgentTurnExecution({
        */
       trace.stop();
       await trace.flush(TRACE_FINAL_FLUSH_MS);
-      if (child) workChildren.delete(child);
+      for (const ch of spawnedChildren) workChildren.delete(ch);
       if (agentChildren.get(place) === child) agentChildren.delete(place);
       if (ranMarker && rt === 'claude') {
         try {
@@ -610,6 +671,7 @@ export function createAgentTurnExecution({
       out,
       lastAnswer,
       usage,
+      model,
       commits,
       artifactsBefore,
       branch,

package/bin/lib/workAgentTurnOutcome.mjs

@@ -26,7 +26,7 @@ import { parseTurnResult } from './agentPlan.mjs';
 import { changedArtifacts, scanArtifacts } from './artifacts.mjs';
 import { scrub as envScrub } from './uplinkScrub.mjs';
 
-export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage, commits, artifactsBefore, branch, wt }) {
+export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage, model = null, commits, artifactsBefore, branch, wt }) {
   const res = (lastAnswer && parseTurnResult(lastAnswer)) || parseTurnResult(out);
   /**
    * A LIMIT IS ONLY A LIMIT WHEN THE TURN PRODUCED NOTHING.
@@ -40,8 +40,10 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
    */
   const limit = res ? null : limitLine(out);
   /** 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). */
-  const report = (body, final = false) => ({ res, limit, body, final });
+   *  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
+   *  (turnModel.mjs) — a turn that stopped still ran on something. */
+  const report = (body, final = false) => ({ res, limit, body: model ? { ...body, model } : body, final });
   if (limit) {
     // The turn itself is reported as `nothing` — it did not deliver and it
     // did not ask. The park that goes with it is the caller's side effect
@@ -193,7 +195,7 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
  * never lies by omission), the spend if the CLI counted one, and the branch
  * and worktree when a worktree existed. Nothing measured, nothing claimed.
  */
-export function failedTurnSettlement({ turnId, error, commits = [], usage = null, branch = null, wt = null }) {
+export function failedTurnSettlement({ turnId, error, commits = [], usage = null, model = null, branch = null, wt = null }) {
   // An Error's message, or a thrown string; anything else says nothing rather
   // than "[object Object]".
   const why = (typeof error === 'string' ? error : typeof error?.message === 'string' ? error.message : '').trim();
@@ -205,6 +207,7 @@ export function failedTurnSettlement({ turnId, error, commits = [], usage = null
     ).slice(0, 1500),
     ...(commits.length ? { commits } : {}),
     ...(usage ? { usage } : {}),
+    ...(model ? { model } : {}),
     ...(wt ? { branch, worktree: wt } : {}),
   };
 }

package/bin/lib/workAgentTurns.mjs

@@ -162,7 +162,7 @@ export function createWorkAgentTurns({
      * wire, so a failed POST is re-sent on the next offer and the CLI is not
      * run again.
      */
-    const measured = { wt: null, before: null, branch: null, usage: null };
+    const measured = { wt: null, before: null, branch: null, usage: null, model: null };
     let settled = false;
     const settleOnce = (body) => {
       settled = true;
@@ -184,6 +184,7 @@ export function createWorkAgentTurns({
             error,
             commits,
             usage: measured.usage,
+            model: measured.model,
             branch: measured.branch,
             wt: measured.wt,
           })

package/bin/lib/workSessionTurns.mjs

@@ -174,6 +174,10 @@ export function createWorkSessionTurns({
          * sits in the retry queue and is posted again adds nothing.
          */
         let usage = null;
+        /** THE MODEL THE TURN RAN ON, as its CLI named it (turnModel.mjs) —
+         *  out here beside `usage`, and spread wherever it is. Last write wins
+         *  across a fresh retry: that spawn is the one that answered. */
+        let model = null;
         try {
           const tries = workAttempts.get(job.id) ?? 0;
           if (tries >= MAX_WORK_TRIES) {
@@ -666,6 +670,9 @@ export function createWorkSessionTurns({
               onUsage: (u) => {
                 usage = addUsage(usage, { ...u, runtime: rt.id });
               },
+              onModel: (m) => {
+                model = m;
+              },
               // What this CLI says it can be asked for by name. Harvested off
               // the init event the stream already carries — no probe, no scan,
               // no extra spawn — and reported on the next roster poll so the
@@ -687,6 +694,11 @@ export function createWorkSessionTurns({
               cwd: dir.wt,
               mcpArgs: mcp.args,
               mcpEnv: mcp.env,
+              // A PERSON AT THE KEYBOARD MAY ASK FOR A WINDOW (2026-09-29): a
+              // Terminal tab keeps its environment's display. The capture chat
+              // does not — it only reads and stages cards, and the person
+              // talking to it may be on a phone (noWindowEnv.mjs).
+              display: !captureTab,
               runtime: rt.id,
               label: c.cyan('[tab]'),
               // Only codex announces one (thread.started); held here so the id
@@ -827,6 +839,7 @@ export function createWorkSessionTurns({
               ...(toolLog.ev.length > 0 ? { tools: toolLog } : {}),
               // …and an empty fork still spent what it spent.
               ...(usage ? { usage } : {}),
+              ...(model ? { model } : {}),
             });
             warn('adopt turn produced no output — settled as failed');
             return;
@@ -865,6 +878,7 @@ export function createWorkSessionTurns({
             // at settle). Already scrubbed at collection.
             ...(toolLog.ev.length > 0 ? { tools: toolLog } : {}),
             ...(usage ? { usage } : {}),
+            ...(model ? { model } : {}),
           });
           if (answer.length > 0) ok(`${c.cyan('tab')} ${c.dim('— replied in the session')}`);
           else warn('session turn produced no output — settled as failed');
@@ -880,6 +894,7 @@ export function createWorkSessionTurns({
             ...(toolLog?.ev.length > 0 ? { tools: toolLog } : {}),
             // A turn that threw after its CLI ran still spent what it spent.
             ...(usage ? { usage } : {}),
+            ...(model ? { model } : {}),
           });
           warn(`session turn failed: ${e?.message ?? e}`);
         } finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.113.0",
+  "version": "0.114.1",
   "description": "Run your own coding CLIs as build agents for Flowviant — 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": {