mixdog 0.9.148 → 0.9.150

package/README.md

@@ -152,14 +152,13 @@ npm run dev
 
 Controlled single-model runs on the same 89 tasks produced:
 
-- **78/89** with Claude Opus 5 vs Claude Code's **77/89**
-- **75/89** with GPT-5.6 Sol xhigh, matching Codex CLI
-- **1.43×** faster vs Claude Code and **1.27×** faster vs Codex CLI
-- **40–47%** smaller median final context
-- **29%** lower priced cost vs Claude Code and at least **39.7%** lower vs
-  Codex CLI
-
-These are self-reported single runs (`k=1`, 2026-08), not leaderboard
+- **82/89** with Claude Opus 5 vs Claude Code's **77/89**
+- **79/89** with GPT-5.6 Sol xhigh vs Codex CLI's **75/89**
+- **1.21×** faster vs Claude Code and **1.15×** faster vs Codex CLI
+- **31–47%** smaller median final context
+- **16%** lower priced cost vs Claude Code and **41%** lower vs Codex CLI
+
+These are self-reported single runs (`k=1`, 2026-08-23), not leaderboard
 submissions. Raw artifacts, commands, comparison charts, and metric scripts
 live under [`benchmarks/terminal-bench-2.1/`](benchmarks/terminal-bench-2.1/).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.148",
+  "version": "0.9.150",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/src/headless-exec.mjs

@@ -672,7 +672,10 @@ export async function runHeadlessExec({
       approvalMode: 'implicit',
       disallowDelegation: true,
       autoWakeCompletions: false,
-      initialConfig: boundary.loadConfig(),
+      initialConfig: {
+        ...boundary.loadConfig(),
+        workflow: { active: 'headless' },
+      },
     });
     if (lifecycle && !clean(runtime?.id) && typeof runtime?.reserveSessionId === 'function') {
       runtime.reserveSessionId(lifecycle.threadId);
@@ -689,6 +692,25 @@ export async function runHeadlessExec({
         },
       );
     }
+    // Rewrite the usage snapshot after every model response, not only on the
+    // way out. A session killed mid-run — agent timeout, SIGKILL — never
+    // reaches the exit path, and used to leave no usage document at all while
+    // its token spend was already real. The file is a few hundred bytes and
+    // the write is atomic, so the cost is negligible and a live run stays
+    // readable from outside.
+    const flushUsageDocument = () => {
+      try {
+        writeUsageDocument(
+          usageLogPath,
+          stats,
+          runtime,
+          lifecycle?.toolCallCount || 0,
+          observedModels,
+        );
+      } catch {
+        // Telemetry must never break the session; the exit path reports.
+      }
+    };
     const askOptions = {
       onTextReset: () => true,
       onUsageDelta: (delta) => {
@@ -696,6 +718,7 @@ export async function runHeadlessExec({
         if (observedModel) observedModels.add(observedModel);
         applyUsageDelta(stats, delta);
         lifecycle?.onUsageDelta(delta);
+        flushUsageDocument();
       },
       ...(lifecycle ? {
         onProviderSendStarted: () => lifecycle.onProviderSendStarted(),

package/src/headless-exec.test.mjs

@@ -119,6 +119,7 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
     assert.deepEqual(errors, []);
     assert.equal(runtimeOptions[0].approvalMode, 'implicit');
     assert.equal(runtimeOptions[0].disallowDelegation, true);
+    assert.deepEqual(runtimeOptions[0].initialConfig.workflow, { active: 'headless' });
     assert.equal(runtimeOptions[0].autoWakeCompletions, false);
     assert.equal(runtimeOptions[0].toolMode, 'full');
     assert.deepEqual(activeScopes[0], {
@@ -142,6 +143,65 @@ test('headless exec runs one implicit-approval session and waits for tracked tas
   }
 });
 
+test('headless exec flushes the usage snapshot mid-session, before any exit path', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-headless-usage-flush-test-'));
+  const usageLogPath = join(root, 'usage.json');
+  // What a killed run would have left behind: read the file while `ask` is
+  // still running. Before the per-response flush this was always absent, so
+  // an agent-timeout trial reported no token spend at all.
+  let midSession = null;
+  try {
+    const code = await runHeadlessExec({
+      message: 'fix it',
+      provider: 'openai-oauth',
+      model: 'gpt-test',
+      effort: 'high',
+      fast: true,
+      usageLogPath,
+      idlePollMs: 1,
+      write: () => {},
+      writeErr: () => {},
+      boundaryFactory: () => ({
+        loadConfig: () => ({ providers: { 'openai-oauth': { enabled: true } } }),
+        cleanup: () => {},
+      }),
+      runtimeFactory: async () => ({
+        id: 'sess_flush_test',
+        model: 'gpt-test',
+        clientHostPid: 123,
+        ask: async (_prompt, options) => {
+          options.onUsageDelta({
+            deltaInput: 9,
+            deltaCachedRead: 4,
+            deltaCacheWrite: 2,
+            deltaOutput: 6,
+          });
+          try {
+            midSession = JSON.parse(readFileSync(usageLogPath, 'utf8'));
+          } catch (error) {
+            midSession = { error: error?.message ?? String(error) };
+          }
+          return { result: { content: 'done' } };
+        },
+        close: async () => {},
+      }),
+      hasActiveTasks: () => false,
+      installSignalCleanupFn: () => ({ uninstall() {} }),
+    });
+
+    assert.equal(code, 0);
+    assert.deepEqual(midSession?.totals, {
+      inputTokens: 9,
+      cacheTokens: 4,
+      cacheWriteTokens: 2,
+      outputTokens: 6,
+      toolCallCountApprox: 0,
+    });
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('headless exec answers an arrived completion and exits without waiting on live work', async () => {
   const output = [];
   const errors = [];
@@ -427,3 +487,15 @@ test('--json is accepted for exec and rejected for the interactive command', ()
   assert.equal(interactive.kind, 'error');
   assert.equal(interactive.error, 'option --json is only supported for mixdog exec');
 });
+
+test('headless exec rejects workflow selection', () => {
+  const invocation = classifyCliInvocation([
+    'exec',
+    '--provider', 'openai-oauth',
+    '--model', 'gpt-test',
+    '--workflow', 'solo',
+    'fix it',
+  ]);
+  assert.equal(invocation.kind, 'error');
+  assert.equal(invocation.error, 'option --workflow is not supported for mixdog exec');
+});

package/src/rules/lead/01-general.md

@@ -10,8 +10,9 @@
   recoverability.
 - Mid-task: replacement supersedes; addition folds in; status gets a brief
   answer while work continues. After compaction, resume the summary.
-- Periodic task reports stay in-turn: after each update, call `task wait` for
-  the requested interval again until the task settles or the request changes.
+- Periodic task reports stay in-turn: when `task wait` returns still-running,
+  write the user-facing report first, then call `task wait` for the next
+  interval; repeat until the task settles or the request changes.
 - Auto-compact owns context management: never propose stopping work to the
   user and never stop on your own judgment; resume and continue the work
   after every compaction.

package/src/rules/shared/00-general.md

@@ -2,3 +2,4 @@
 
 - When an internal Mixdog rule conflicts with the user's latest explicit
   request, follow the user's request.
+- Drive the user's request yourself.

package/src/rules/shared/10-tool-workflow.md

@@ -1,16 +1,16 @@
 # Tool Workflow
 
-- Determine the required outcome and its gaps — requirements are not evidence —
-  gather only what is missing, act, then verify the affected facets.
-- Investigate, build, and verify only what the requested outcome requires, at
-  the level it requires; internal and framework guarantees are trusted.
-- Minimize tool turns through maximal useful parallelism. Cost is counted in
-  rounds, not calls: a batch is one round, so a call-count saving never
-  justifies a worse-routed call.
-- In each round, issue every necessary non-overlapping call whose inputs are
-  already known; defer a call only when its target or arguments require an
-  earlier result. Respect tool/schema limits, never omit required fanout, and
-  apply one analysis to many targets as one parameterized call when supported.
+- Determine the required outcome and missing evidence; requirements are not
+  evidence. Trust internal and framework guarantees.
+- Before exploration or implementation, consult prior work, current external
+  information, or repository state only when needed to choose the next action.
+  Start with the source most likely to decide it; consult another only if the
+  result leaves the decision unresolved.
+- Minimize tool turns by batching only calls that are independently necessary
+  before the batch begins. A call whose necessity or scope can change after
+  another result waits for that result.
+- Respect tool/schema limits, never omit required fanout, and apply one analysis
+  to many targets as one parameterized call when supported.
 - Route each evidence facet once to its primary owner, preferring the operation
   that directly returns the evidence needed for the next decision. A summary,
   overview, or enumeration is not a prerequisite to an operation whose complete
@@ -26,7 +26,6 @@
 - Mine each returned result fully before opening the next round; a follow-up is
   valid only for evidence a result omitted, invalidated, or newly made
   necessary.
-- Evidence that determines the answer, edit, or deliverable ends retrieval.
 - Treat failure as new evidence and re-enter that loop only for the affected
   facets. Do not abandon a viable approach after one failure or leave the
   required deliverable half-finished. Report a blocker when no deterministic

package/src/rules/shared/30-exploration.md

@@ -2,6 +2,8 @@
 
 - Use read-only means for inspection; never mutate to clear an obstacle or
   unexpected state. Preserve evidence before a required mutation can destroy it.
+- Stop exploring once sufficient evidence determines the next action required
+  by the request.
 - Ownership is exclusive: each evidence type has one owner;
   a successful owner result closes that facet.
 - Route the missing evidence to its primary owner:
@@ -13,18 +15,19 @@
   wildcard or recursive file paths→`glob`;
   known directory's immediate entries→`list`;
   unknown file or directory location→`find`.
+- For `code_graph`, location-only lookup uses `body:false`; use `body:true`
+  only for the smallest exact implementation symbol needed, and never use
+  `overview` and `symbols` for the same evidence.
 - Use a path locator only when the owner's required target is unknown. Paths
   reachable by expanding an environment variable or the home directory are
   resolved locations, not unknowns.
-- Enumerate sibling directories or same-kind files with one wildcard call
-  (`glob`, or `read` with a glob for content sampling), never a
-  directory-by-directory `list` walk or one `read` per file.
+- Enumerate sibling directories or same-kind files with one `glob` call, never
+  a directory-by-directory `list` walk or one `read` per file.
 - Treat supplied target locations as resolved; access them directly without
   locator searches. Within the current project, pass project-relative paths and
   omit optional scopes equal to its root; explicit paths may be outside cwd
   only for targets outside the project.
-- Before deciding how to parse, count, transform, or summarize files whose
-  format has not been inspected, inspect the original content itself.
+- Inspect source content only when its format is required and unknown.
 - Returned declarations, bodies, usages, relations, and contextual spans from
   any tool — not only `read` — are source context; `read` covers only omitted
   lines or missing anchored ranges.

package/src/rules/shared/60-verification.md

@@ -1,9 +1,10 @@
 # Verification
 
 - Enter Verification only after all planned work is complete.
-- Run only checks that directly cover the changed behavior or essential
-  invariants; use an umbrella suite only when the user explicitly requests it
-  or a documented project or release process requires it.
+- Verify the essential behaviors and invariants required to complete the
+  requested work.
+- Use an umbrella suite only when explicitly requested or required by the
+  documented project or release process.
 - Blocking checks cover only essential integrity, security, compatibility, and
   buildability invariants. Treat mutable behavior, UX, exact text, snapshots,
   and implementation shape as advisory specifications; update them when the

package/src/runtime/agent/orchestrator/providers/openai-codex-identity.test.mjs

@@ -8,7 +8,10 @@ import {
     mintUuidV7,
 } from '../session/manager/session-id.mjs';
 import { buildStableProviderPromptCacheKey } from '../agent-runtime/cache-strategy.mjs';
-import { _withCodexWsClientMetadata } from './openai-codex-metadata.mjs';
+import {
+    _codexWsCompatibilityHeaders,
+    _withCodexWsClientMetadata,
+} from './openai-codex-metadata.mjs';
 import { codexOriginator, codexUserAgent } from './codex-client-meta.mjs';
 
 test('Codex wire identity is a real time-based UUIDv7 and remains session-stable', () => {
@@ -26,14 +29,7 @@ test('Codex wire identity is a real time-based UUIDv7 and remains session-stable
     assert.equal(ensureCodexWireSessionId(session), sessionId);
 });
 
-test('Codex cache key and every wire session identity use the same UUIDv7', (t) => {
-    const previousParity = process.env.MIXDOG_OAI_CODEX_WIRE_PARITY;
-    process.env.MIXDOG_OAI_CODEX_WIRE_PARITY = '1';
-    t.after(() => {
-        if (previousParity == null) delete process.env.MIXDOG_OAI_CODEX_WIRE_PARITY;
-        else process.env.MIXDOG_OAI_CODEX_WIRE_PARITY = previousParity;
-    });
-
+test('Codex cache key and every wire session identity use the same UUIDv7', () => {
     const sessionId = mintUuidV7();
     const turnStartedAtUnixMs = Date.now();
     const turnId = mintUuidV7(turnStartedAtUnixMs);
@@ -80,11 +76,36 @@ test('Codex cache key and every wire session identity use the same UUIDv7', (t)
     assert.equal(turnMetadata.session_id, sessionId);
     assert.equal(turnMetadata.thread_id, sessionId);
     assert.equal(turnMetadata.turn_id, turnId);
+    assert.match(turnMetadata.installation_id, /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
     assert.equal(turnMetadata.agent_name, '/root');
     assert.equal(turnMetadata.sandbox, 'none');
     assert.equal(turnMetadata.sandbox_mode, 'danger-full-access');
     assert.equal(turnMetadata.auto_review_enabled, false);
+    assert.equal(turnMetadata.node_repl_auto_review_required, false);
+    assert.equal(turnMetadata.node_repl_disabled, false);
     assert.equal(turnMetadata.turn_started_at_unix_ms, turnStartedAtUnixMs);
+
+    const prewarmHeaders = _codexWsCompatibilityHeaders({
+        cacheKey: promptCacheKey,
+        poolKey: session.id,
+        model: 'gpt-5.6-sol',
+        handshake: true,
+        sendOpts: {
+            codexSessionId: sessionId,
+            codexThreadId: sessionId,
+            requestKind: 'prewarm',
+            session,
+        },
+    });
+    assert.equal(prewarmHeaders['session-id'], sessionId);
+    assert.equal(prewarmHeaders['thread-id'], sessionId);
+    assert.equal(prewarmHeaders['x-client-request-id'], sessionId);
+    assert.equal('x-codex-installation-id' in prewarmHeaders, false);
+    const prewarmMetadata = JSON.parse(prewarmHeaders['x-codex-turn-metadata']);
+    assert.equal(prewarmMetadata.request_kind, 'prewarm');
+    assert.equal(prewarmMetadata.turn_id, '');
+    assert.equal(prewarmMetadata.installation_id, turnMetadata.installation_id);
+    assert.equal('turn_started_at_unix_ms' in prewarmMetadata, false);
 });
 
 // A compaction summary is a request of the same session: same thread identity,

package/src/runtime/agent/orchestrator/providers/openai-codex-metadata.mjs

@@ -2,7 +2,13 @@
 // installation/session/thread/turn identity block that rides every frame, its
 // handshake-header projection, and the per-turn x-codex-turn-state guard.
 // Extracted from openai-oauth-ws.mjs, which now owns transport flow only.
-import { createHash } from 'crypto';
+import { createHash, randomUUID } from 'crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { getPluginData } from '../config.mjs';
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+let _installationId = null;
 
 function _cleanMetaString(value) {
     return typeof value === 'string' ? value.trim() : '';
@@ -49,8 +55,38 @@ function _codexRequestKind(sendOpts, sessionId) {
 }
 
 function _codexInstallationId(sendOpts) {
-    return _cleanMetaString(sendOpts?.installationId || sendOpts?.codexInstallationId || process.env.MIXDOG_CODEX_INSTALLATION_ID)
-        || `mixdog-${_hashText(`${process.env.USERPROFILE || process.env.HOME || ''}:${process.cwd()}`, 32)}`;
+    const explicit = _cleanMetaString(
+        sendOpts?.installationId
+        || sendOpts?.codexInstallationId
+        || process.env.MIXDOG_CODEX_INSTALLATION_ID,
+    ).toLowerCase();
+    if (UUID_RE.test(explicit)) return explicit;
+    if (_installationId) return _installationId;
+    const dir = getPluginData();
+    const file = join(dir, 'installation_id');
+    try {
+        const existing = existsSync(file) ? readFileSync(file, 'utf8').trim().toLowerCase() : '';
+        if (UUID_RE.test(existing)) {
+            _installationId = existing;
+            return _installationId;
+        }
+    } catch {}
+    const generated = randomUUID();
+    try {
+        if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+        try {
+            writeFileSync(file, generated, { encoding: 'utf8', flag: 'wx', mode: 0o644 });
+        } catch {
+            const winner = readFileSync(file, 'utf8').trim().toLowerCase();
+            if (UUID_RE.test(winner)) {
+                _installationId = winner;
+                return _installationId;
+            }
+            writeFileSync(file, generated, { encoding: 'utf8', mode: 0o644 });
+        }
+    } catch {}
+    _installationId = generated;
+    return _installationId;
 }
 
 // The identity block is rebuilt per request: never cached on the pooled
@@ -75,51 +111,42 @@ function _codexMetadataBase(entry, { poolKey, cacheKey, sendOpts, handshake = fa
     )
         || rawSessionId;
     const rawInstallationId = _codexInstallationId(sendOpts);
-    const wireParity = process.env.MIXDOG_OAI_CODEX_WIRE_PARITY === '1';
-    const sessionId = wireParity ? _codexUuidV7(rawSessionId) : rawSessionId;
-    const threadId = wireParity ? _codexUuidV7(rawThreadId) : rawThreadId;
-    const installationId = wireParity ? _codexUuidV7(rawInstallationId) : rawInstallationId;
+    const sessionId = _codexUuidV7(rawSessionId);
+    const threadId = _codexUuidV7(rawThreadId);
+    const installationId = rawInstallationId;
     const startedAt = Number.isFinite(Number(sendOpts?.turnStartedAtUnixMs))
         ? Math.floor(Number(sendOpts.turnStartedAtUnixMs))
         : _sessionStartedAtUnixMs(rawSessionId);
     const requestKind = _codexRequestKind(sendOpts, rawSessionId);
     // The reference client opens the WS with a prewarm (empty turn_id) BEFORE
-    // the real turn. Under wire parity the handshake IS that prewarm, so its
-    // turn_id empties and its request_kind becomes 'prewarm' instead of
-    // presenting the handshake as a live turn. Parity off is unchanged.
+    // the real turn, so the handshake is always identified as a prewarm rather
+    // than as a live turn.
     const isPrewarm = requestKind === 'prewarm' || handshake === true;
     const rawExplicitTurnId = _cleanMetaString(sendOpts?.turnId || sendOpts?.codexTurnId || sendOpts?.session?.turnId);
     const explicitWindowId = _cleanMetaString(sendOpts?.windowId || sendOpts?.codexWindowId || sendOpts?.session?.windowId);
-    const turnId = wireParity && isPrewarm
+    const turnId = isPrewarm
         ? ''
-        : wireParity
-            ? _codexUuidV7(rawExplicitTurnId || `${rawSessionId}:turn`)
-            : (rawExplicitTurnId || sessionId);
-    const effectiveRequestKind = wireParity && isPrewarm ? 'prewarm' : requestKind;
+        : _codexUuidV7(rawExplicitTurnId || `${rawSessionId}:turn`);
+    const effectiveRequestKind = isPrewarm ? 'prewarm' : requestKind;
     // Window id is `<thread-id>:<auto-compact window number>`, and that counter
     // starts at 0: a thread that never auto-compacted reports generation 0 and
-    // only advances when a new context window opens. The legacy non-parity
-    // wire kept :1 and is left alone so measured default behavior is unchanged.
-    const windowId = explicitWindowId || `${threadId}:${wireParity ? 0 : 1}`;
+    // only advances when a new context window opens.
+    const windowId = explicitWindowId || `${threadId}:0`;
     const turnMetadata = {
         installation_id: installationId,
         session_id: sessionId,
         thread_id: threadId,
+        agent_name: '/root',
         turn_id: turnId,
         window_id: windowId,
         request_kind: effectiveRequestKind,
-        // Turn-metadata fields the reference client fills on every request.
-        // They were behind a probe knob after a 2026-07-04 A/B showed no
-        // isolated effect; they are unconditional now because a partial blob is
-        // a shape no real client sends. Absolute agent path, not a bare name;
-        // the sandbox pair reports this runtime honestly (tools run with full
-        // host access, so there is no sandbox to declare).
-        agent_name: '/root',
         thread_source: 'user',
         sandbox: 'none',
         sandbox_mode: 'danger-full-access',
         auto_review_enabled: false,
-        turn_started_at_unix_ms: startedAt,
+        node_repl_auto_review_required: false,
+        node_repl_disabled: false,
+        ...(!isPrewarm ? { turn_started_at_unix_ms: startedAt } : {}),
     };
     return {
         'x-codex-installation-id': installationId,
@@ -144,16 +171,18 @@ export function _metadataTrace(metadata) {
     };
 }
 
-// Handshake projection of the same identity: window id, the turn-metadata
-// blob, the installation id, and the routing hint. The reference client sends
-// all of them on every request, and a 2026-07-04 A/B measured the blob alone
-// lifting prefix-cache hits.
+// The WebSocket handshake carries compatibility identity and routing fields.
+// Installation data stays in per-request client_metadata.
 export function _codexWsCompatibilityHeaders(context = {}) {
     const metadata = _codexMetadataBase(null, context);
     const headers = {};
+    if (metadata.session_id) headers['session-id'] = metadata.session_id;
+    if (metadata.thread_id) {
+        headers['thread-id'] = metadata.thread_id;
+        headers['x-client-request-id'] = metadata.thread_id;
+    }
     if (metadata['x-codex-window-id']) headers['x-codex-window-id'] = metadata['x-codex-window-id'];
     if (metadata['x-codex-turn-metadata']) headers['x-codex-turn-metadata'] = metadata['x-codex-turn-metadata'];
-    if (metadata['x-codex-installation-id']) headers['x-codex-installation-id'] = metadata['x-codex-installation-id'];
     // Routing hint. The reference client attaches this to EVERY request whose
     // auth is the ChatGPT backend — no flag, no mode, and with `model=` alone
     // when no service tier is selected. It is how the backend lands the request
@@ -177,6 +206,8 @@ export function _codexWsCompatibilityHeaders(context = {}) {
 export function _withCodexWsClientMetadata(frame, entry, enabled, context = {}) {
     if (!enabled || !frame || typeof frame !== 'object') return frame;
     const base = _codexMetadataBase(entry, context);
+    const requestKind = _codexRequestKind(context?.sendOpts, context?.poolKey || '');
+    const isPrewarmRequest = requestKind === 'prewarm';
     const metadata = {
         ...base,
         ...(frame.client_metadata && typeof frame.client_metadata === 'object' ? frame.client_metadata : {}),
@@ -192,10 +223,21 @@ export function _withCodexWsClientMetadata(frame, entry, enabled, context = {})
             if (entry.turnStateTurnId == null) {
                 entry.turnStateTurnId = base.turn_id;
             } else if (entry.turnStateTurnId !== base.turn_id) {
-                entry.turnState = null;
-                entry.turnStateTurnId = null;
+                // Codex startup prewarm owns the handshake turn-state until
+                // the first real turn consumes that prewarmed client session.
+                // Adopt it once across prewarm→turn; ordinary turn changes
+                // still retire the old token.
+                if (entry.turnStateFromPrewarm === true && !isPrewarmRequest) {
+                    entry.turnStateTurnId = base.turn_id;
+                } else {
+                    entry.turnState = null;
+                    entry.turnStateTurnId = null;
+                }
             }
         }
+        if (!isPrewarmRequest && entry.turnStateFromPrewarm === true) {
+            entry.turnStateFromPrewarm = false;
+        }
         entry.currentTurnId = base.turn_id;
     }
     if (entry?.turnState) metadata['x-codex-turn-state'] = String(entry.turnState);

package/src/runtime/agent/orchestrator/providers/openai-codex-model.mjs

@@ -82,6 +82,9 @@ export function _normalizeCodexModel(m) {
         latest: false,
         description: m?.description || '',
         reasoningLevels: (m?.supported_reasoning_levels || []).map(r => r.effort),
+        supportVerbosity: m?.support_verbosity === true,
+        defaultVerbosity: m?.default_verbosity || null,
+        supportsReasoningSummaries: m?.supports_reasoning_summaries === true,
         serviceTiers,
         defaultServiceTier: m?.default_service_tier || null,
         additionalSpeedTiers,