mixdog 0.9.148 → 0.9.149

package/package.json

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

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

@@ -13,6 +13,9 @@
   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.

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,38 @@ 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,
+        useResponsesLite: 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);
+    assert.equal('x-openai-internal-codex-responses-lite' 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 and Responses Lite data stay 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,9 +206,14 @@ 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 : {}),
+        ...(context?.useResponsesLite === true
+            ? { ws_request_header_x_openai_internal_codex_responses_lite: 'true' }
+            : {}),
         'x-codex-ws-stream-request-start-ms': String(Date.now()),
     };
     if (entry && typeof entry === 'object') {
@@ -192,10 +226,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

@@ -7,6 +7,23 @@
  * _displayCodexModel for existing importers.
  */
 
+const CODEX_RESPONSES_LITE_CAPABILITY = Object.freeze({
+    'gpt-5.6-sol': true,
+    'gpt-5.6-terra': true,
+    'gpt-5.6-luna': true,
+    'gpt-5.5': false,
+    'gpt-5.4': false,
+    'gpt-5.4-mini': false,
+    'gpt-5.2': false,
+    'codex-auto-review': false,
+});
+
+export function _codexUsesResponsesLite(id, modelInfo = null) {
+    const explicit = modelInfo?.useResponsesLite ?? modelInfo?.use_responses_lite;
+    if (typeof explicit === 'boolean') return explicit;
+    return CODEX_RESPONSES_LITE_CAPABILITY[String(id || '').trim()] === true;
+}
+
 // OAuth catalog returns dated ids (gpt-5.4-mini-2026-03-17). Strip the trailing
 // -YYYY-MM-DD to get the version alias (gpt-5.4-mini). Unknown shapes pass
 // through unchanged.
@@ -82,6 +99,10 @@ 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,
+        useResponsesLite: m?.use_responses_lite === true,
+        supportsReasoningSummaries: m?.supports_reasoning_summaries === true,
         serviceTiers,
         defaultServiceTier: m?.default_service_tier || null,
         additionalSpeedTiers,

package/src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs

@@ -251,6 +251,9 @@ export async function sendViaHttpSse({
     const statelessConversation = opts?.statelessConversation === true
         || _envFlag('MIXDOG_OAI_STATELESS_HTTP', false);
     const headers = _buildOpenAIHttpFallbackHeaders({ auth, cacheKey, statelessConversation });
+    if (auth?.type !== 'openai-direct' && body?.input?.[0]?.type === 'additional_tools') {
+        headers['x-openai-internal-codex-responses-lite'] = 'true';
+    }
     const fetchStartedAt = Date.now();
     const responsesUrl = auth?.type === 'openai-direct'
         ? OPENAI_DIRECT_RESPONSES_URL

package/src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs

@@ -515,6 +515,7 @@ export async function sendViaWebSocket({
     _sendSpanTraceFn = appendAgentTrace,
     _agentTraceFn = appendAgentTrace,
     _carriedWarmup = null,
+    _prewarmedHandle = null,
 }) {
     // One bounded Codex stream retry budget covers transient handshake and
     // pre-output stream failures. Every retry acquires a fresh connection.
@@ -583,6 +584,7 @@ export async function sendViaWebSocket({
         sendOpts,
         model: useModel,
         serviceTier: body?.service_tier || '',
+        useResponsesLite: body?.input?.[0]?.type === 'additional_tools',
     };
     const codexHandshakeHeaders = useCodexWsClientMetadata
         ? _codexWsCompatibilityHeaders({ ...codexMetadataContext, handshake: true })
@@ -650,6 +652,7 @@ export async function sendViaWebSocket({
     // Armed by the rejection safety net below: once a server rejects a
     // replayed reasoning item, every later attempt of THIS send strips them.
     let suppressReasoningReplay = false;
+    let prewarmedHandle = _prewarmedHandle;
 
     for (let attemptIndex = 0; attemptIndex <= MAX_MIDSTREAM_RETRIES; attemptIndex++) {
         const handshakeStart = performance.now();
@@ -659,29 +662,43 @@ export async function sendViaWebSocket({
         sendSpan.acquireAttempts += 1;
         try { onStageChange?.('requesting'); } catch {}
         try {
-            acquired = await _acquireWithRetryFn({
-                auth,
-                poolKey,
-                cacheKey,
-                codexHeaders: codexHandshakeHeaders,
-                // Retry attempt must not reuse a pooled socket — the prior
-                // one is either torn down or in an unknown state.
-                forceFresh: forceFresh || attemptIndex > 0,
-                externalSignal,
-                // No nested connect retry budget: the outer stream loop owns
-                // all retries for this logical request.
-                maxAttempts: 1,
-                retry429,
-                onRetry: (info) => {
-                    handshakeRetries += 1;
-                    sendSpan.handshakeRetries += 1;
-                    if (info?.classifier) handshakeRetryClassifiers.push(info.classifier);
-                    const attempt = Number(info?.attempt) || handshakeRetries;
-                    const max = Number(info?.max) || MAX_MIDSTREAM_RETRIES;
-                    emitReconnectProgress({ attempt, max, classifier: info?.classifier });
-                },
-                onBackoffSlept: (ms) => { sendSpan.retryBackoffMs += ms; },
-            });
+            const reserved = attemptIndex === 0
+                && forceFresh !== true
+                && prewarmedHandle?.entry
+                && prewarmedHandle.poolKey === poolKey
+                && prewarmedHandle.cacheKey === cacheKey;
+            if (reserved) {
+                acquired = {
+                    entry: prewarmedHandle.entry,
+                    reused: true,
+                    prewarmed: true,
+                };
+                prewarmedHandle = null;
+            } else {
+                acquired = await _acquireWithRetryFn({
+                    auth,
+                    poolKey,
+                    cacheKey,
+                    codexHeaders: codexHandshakeHeaders,
+                    // Retry attempt must not reuse a pooled socket — the prior
+                    // one is either torn down or in an unknown state.
+                    forceFresh: forceFresh || attemptIndex > 0,
+                    externalSignal,
+                    // No nested connect retry budget: the outer stream loop owns
+                    // all retries for this logical request.
+                    maxAttempts: 1,
+                    retry429,
+                    onRetry: (info) => {
+                        handshakeRetries += 1;
+                        sendSpan.handshakeRetries += 1;
+                        if (info?.classifier) handshakeRetryClassifiers.push(info.classifier);
+                        const attempt = Number(info?.attempt) || handshakeRetries;
+                        const max = Number(info?.max) || MAX_MIDSTREAM_RETRIES;
+                        emitReconnectProgress({ attempt, max, classifier: info?.classifier });
+                    },
+                    onBackoffSlept: (ms) => { sendSpan.retryBackoffMs += ms; },
+                });
+            }
         } catch (err) {
             _stampWarmup(err);
             sendSpan.poolAcquireMs += performance.now() - handshakeStart;
@@ -780,7 +797,9 @@ export async function sendViaWebSocket({
         }
         const { entry, reused } = acquired;
         sendSpan.poolAcquireMs += performance.now() - handshakeStart;
-        sendSpan.acquireMode = entry?.ephemeral ? 'ephemeral' : (reused ? 'reused' : 'new');
+        sendSpan.acquireMode = acquired.prewarmed
+            ? 'prewarmed'
+            : entry?.ephemeral ? 'ephemeral' : (reused ? 'reused' : 'new');
         // Re-seed the retry attempt's fresh entry with the prior attempt's
         // last successful anchor so _computeDelta sees a non-null
         // lastInputPrefixHash and prev_response_id, keeping the same xAI
@@ -819,6 +838,9 @@ export async function sendViaWebSocket({
         // entry.lastRequestInput always records the post-policy input.
         requestBody = _applyReasoningReplayPolicy(entry, requestBody, { suppress: suppressReasoningReplay });
         let warmupResult = null;
+        const startupWarmupResponseId = typeof entry?.startupWarmupResponseId === 'string'
+            ? entry.startupWarmupResponseId
+            : null;
         // midState is shared between warmup and the main stream so warmup
         // failures (first-byte timeout, send-failure, ws_4000) flow through
         // the SAME mid-stream classifier as the main send. A wedged warmup
@@ -864,7 +886,11 @@ export async function sendViaWebSocket({
                 // cannot accidentally duplicate the transcript. Keep the same
                 // request properties as the real turn; Codex changes only the
                 // input tail and adds generate:false.
-                const parityWarmupBody = { ...warmupBody, input: [], generate: false };
+                const parityWarmupBody = {
+                    ...warmupBody,
+                    input: Array.isArray(warmupBody.input) ? warmupBody.input : [],
+                    generate: false,
+                };
                 const warmupFrame = _buildResponseCreateFrame(parityWarmupBody);
                 const warmupMetadataContext = {
                     ...codexMetadataContext,
@@ -927,6 +953,7 @@ export async function sendViaWebSocket({
                 entry.lastInputPrefixHash = createHash('sha256')
                     .update(JSON.stringify(warmupInputArr))
                     .digest('hex');
+                entry.turnStateFromPrewarm = true;
                 try {
                     const warmupPayload = {
                         provider: traceProvider,
@@ -949,6 +976,36 @@ export async function sendViaWebSocket({
                 } catch {}
             }
 
+            // Codex performs generate:false during session startup, then hands
+            // this live client session to the first real turn. Startup callers
+            // stop here; the pooled entry retains its response id, request
+            // snapshot, socket, and turn-state for the later real send.
+            if (sendOpts?._startupPrewarmOnly === true) {
+                const responseId = warmupResult?.responseId
+                    || startupWarmupResponseId
+                    || entry.lastResponseId
+                    || null;
+                if (responseId) entry.startupWarmupResponseId = responseId;
+                else releaseWebSocket({ entry, poolKey, keep: false });
+                emitSendSpan('ok');
+                return {
+                    content: '',
+                    model: warmupResult?.model || useModel,
+                    toolCalls: [],
+                    usage: warmupResult?.usage || {
+                        inputTokens: 0,
+                        outputTokens: 0,
+                        cachedTokens: 0,
+                        cacheWriteTokens: 0,
+                        promptTokens: 0,
+                    },
+                    startupPrewarm: !!responseId,
+                    startupPrewarmHandle: responseId
+                        ? { entry, poolKey, cacheKey }
+                        : null,
+                };
+            }
+
             // A completed generate:false prewarm is a valid continuation
             // anchor. Compute against its retained empty-input snapshot so the
             // first real request sends previous_response_id plus exactly the
@@ -1393,9 +1450,10 @@ export async function sendViaWebSocket({
                 cacheObservation.actualMiss ? (cacheObservation.missReason || 'miss') : false,
             );
         }
+        const effectiveWarmupResponseId = warmupResult?.responseId || startupWarmupResponseId || null;
         const warmupContinuity = _warmupContinuityTrace({
-            warmupUsed: !!warmupResult,
-            warmupResponseId: warmupResult?.responseId || null,
+            warmupUsed: !!effectiveWarmupResponseId,
+            warmupResponseId: effectiveWarmupResponseId,
             priorEntryResponseId,
             sentPrevResponseId,
             earlyCacheMisses: entry.earlyCacheMisses,
@@ -1454,8 +1512,10 @@ export async function sendViaWebSocket({
                 body_input_items: Array.isArray(requestBody.input) ? requestBody.input.length : null,
                 frame_input_items: Array.isArray(frame.input) ? frame.input.length : null,
                 frame_has_instructions: typeof frame.instructions === 'string' && frame.instructions.length > 0,
-                warmup_used: !!warmupResult,
-                warmup_response_id: warmupResult?.responseId || null,
+                warmup_used: !!effectiveWarmupResponseId,
+                warmup_response_id: effectiveWarmupResponseId,
+                warmup_first_real_cache_hit: !!effectiveWarmupResponseId
+                    && cacheObservation.cachedTokens > 0,
                 ...warmupContinuity,
                 tool_call_count: resultToolCallCount,
                 keep_socket: keepSocket,
@@ -1510,6 +1570,9 @@ export async function sendViaWebSocket({
             }
         } catch {}
 
+        if (startupWarmupResponseId) {
+            try { delete entry.startupWarmupResponseId; } catch {}
+        }
         releaseWebSocket({ entry, poolKey, keep: keepSocket });
         const { responseId: _ignored, responseItems: _responseItemsIgnored, closeSocket: _closeSocketIgnored, ...out } = result;
         if (includeResponseId && result.responseId) out.responseId = result.responseId;