mixdog 0.9.68 → 0.9.69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.68",
+  "version": "0.9.69",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -79,11 +79,12 @@
     "test:tui-streaming-window": "node --test scripts/streaming-tail-window-test.mjs",
     "test:tui-ambiguous-width": "node --test scripts/tui-ambiguous-width-test.mjs",
     "test:release-assets": "node --check scripts/verify-release-assets.mjs && node --check scripts/verify-release-assets-test.mjs && node --test scripts/verify-release-assets-test.mjs",
-    "test:release-focused": "npm run test:release-assets && npm run test:tool-contracts && npm run test:placeholder && npm run smoke:patch && npm run test:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && node --test scripts/code-graph-root-federation-test.mjs scripts/code-graph-aggregate-cwd-test.mjs && npm run test:code-graph-dispatch && node --test scripts/code-graph-disk-hit-test.mjs && npm run test:shellhardening && node --test scripts/windows-hide-spawn-options-test.mjs && npm run test:session && node --test scripts/tui-transcript-perf-test.mjs",
+    "test:release-focused": "npm run test:release-assets && npm run test:tool-contracts && npm run test:placeholder && npm run smoke:patch && npm run test:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && node --test scripts/code-graph-root-federation-test.mjs scripts/code-graph-aggregate-cwd-test.mjs && npm run test:code-graph-dispatch && node --test scripts/code-graph-disk-hit-test.mjs && npm run test:shellhardening && node --test scripts/windows-hide-spawn-options-test.mjs && npm run test:session && npm run test:workflow-editor && node --test scripts/tui-transcript-perf-test.mjs",
     "test:native-edit-wire": "node --test scripts/native-edit-wire-test.mjs",
     "test:patch-binary-cache": "node --test scripts/patch-binary-cache-test.mjs",
-    "test:session": "node --test scripts/session-orphan-sweep-test.mjs scripts/interrupted-turn-history-test.mjs scripts/session-heartbeat-lifecycle-test.mjs",
+    "test:session": "node --test scripts/session-orphan-sweep-test.mjs scripts/interrupted-turn-history-test.mjs scripts/session-heartbeat-lifecycle-test.mjs scripts/remote-transition-order-test.mjs",
     "test:rebindtail": "node --test scripts/forwarder-rebind-tail-test.mjs",
+    "test:workflow-editor": "node --test scripts/workflow-id-test.mjs scripts/workflow-pack-editor-test.mjs",
     "failures": "node scripts/tool-failures.mjs",
     "trace:llm": "node scripts/llm-trace-summary.mjs",
     "diag:sessions": "node scripts/session-diag.mjs",
@@ -140,7 +141,8 @@
     },
     "onnxruntime-node": {
       "global-agent": "^4.1.3"
-    }
+    },
+    "sharp": "^0.35.3"
   },
   "devDependencies": {
     "acorn": "^8.17.0",

package/src/runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs

@@ -72,15 +72,10 @@ function agentCompactEventLabel(event = {}) {
     return reactive ? 'Compact complete (overflow recovery)' : 'Compact complete';
 }
 
-function agentCompactEventDetail(event = {}) {
+export function agentCompactEventDetail(event = {}) {
     const parts = [];
     const elapsed = formatCompactElapsedSeconds(Number(event.durationMs ?? event.elapsedMs ?? 0));
     if (elapsed) parts.push(elapsed);
-    const type = String(event.compactType || event.type || '').trim();
-    if (type && type !== 'semantic') parts.push(type);
-    const trigger = String(event.trigger || '').toLowerCase();
-    if (trigger === 'reactive') parts.push('reactive');
-    else if (trigger === 'manual') parts.push('manual');
     const before = Number(event.beforeTokens ?? event.pressureTokens ?? 0);
     const after = Number(event.afterTokens ?? 0);
     const fmtTok = (n) => {

package/src/runtime/agent/orchestrator/context/collect.mjs

@@ -596,10 +596,22 @@ function loadHiddenAgentSnippets(pluginRoot) {
     }
 }
 
+// Role-markdown roots, in precedence order (later wins on the same name):
+// the shipped agents/ tree, then the user data dir. User-authored roles and
+// built-in overrides written by the Workflows editor live in the data dir —
+// reading only the install root left a custom agent with an EMPTY role
+// catalog while Lead already saw the edited AGENT.md.
+function agentSectionDirs(pluginRoot) {
+    const dirs = [];
+    if (pluginRoot) dirs.push(join(pluginRoot, 'agents'));
+    try {
+        const userDir = mixdogGlobalDir('agents');
+        if (userDir && !dirs.includes(userDir)) dirs.push(userDir);
+    } catch { /* unresolvable data dir — built-in roles still load */ }
+    return dirs;
+}
+
 function loadAgentSections(pluginRoot) {
-    const agentsDir = join(pluginRoot, 'agents');
-    const agentSections = [];
-    if (!existsSync(agentsDir)) return agentSections;
     // agents/ holds two layouts that must BOTH be loaded:
     //   - flat:    agents/<agent>.md                (legacy: scheduler-task, webhook-handler)
     //   - nested:  agents/<agent>/AGENT.md          (current: worker, heavy-worker, reviewer, …)
@@ -607,31 +619,34 @@ function loadAgentSections(pluginRoot) {
     // public agent like heavy-worker produced an EMPTY scoped instruction block
     // (BP2) — the model lost its agent contract and the tool smoke's
     // "heavy-worker AGENT.md must be included" assertion failed. Walk both.
-    let entries;
-    try {
-        entries = readdirSync(agentsDir, { withFileTypes: true });
-    } catch {
-        return agentSections;
-    }
-    const sections = [];
-    for (const entry of entries) {
-        let name = '';
-        let raw = null;
-        if (entry.isDirectory()) {
-            name = entry.name;
-            raw = readSafe(join(agentsDir, entry.name, 'AGENT.md'));
-        } else if (entry.isFile() && entry.name.endsWith('.md')) {
-            name = entry.name.replace(/\.md$/, '');
-            raw = readSafe(join(agentsDir, entry.name));
+    const byName = new Map();
+    for (const agentsDir of agentSectionDirs(pluginRoot)) {
+        if (!existsSync(agentsDir)) continue;
+        let entries;
+        try {
+            entries = readdirSync(agentsDir, { withFileTypes: true });
+        } catch {
+            continue;
+        }
+        for (const entry of entries) {
+            let name = '';
+            let raw = null;
+            if (entry.isDirectory()) {
+                name = entry.name;
+                raw = readSafe(join(agentsDir, entry.name, 'AGENT.md'));
+            } else if (entry.isFile() && entry.name.endsWith('.md')) {
+                name = entry.name.replace(/\.md$/, '');
+                raw = readSafe(join(agentsDir, entry.name));
+            }
+            if (!name || !raw) continue;
+            const { body } = readMarkdownDocument(raw);
+            if (!body) continue;
+            byName.set(name, `## ${name}\n\n${body}`);
         }
-        if (!name || !raw) continue;
-        const { body } = readMarkdownDocument(raw);
-        if (!body) continue;
-        sections.push({ name, text: `## ${name}\n\n${body}` });
     }
-    sections.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
-    for (const s of sections) agentSections.push(s.text);
-    return agentSections;
+    return [...byName.entries()]
+        .sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+        .map(([, text]) => text);
 }
 
 // Empty by design: scoped agent markdown already rides BP2 for every provider.
@@ -664,7 +679,7 @@ export function loadScopedRoleInstructions(agent, provider = null) {
             mtime = mtimeCached.mtime;
         } else {
             mtime = maxMtimeRecursive([
-                join(pluginRoot, 'agents'),
+                ...agentSectionDirs(pluginRoot),
                 join(pluginRoot, 'rules', 'agent'),
                 join(pluginRoot, 'defaults', 'agents.json'),
             ]);

package/src/runtime/agent/orchestrator/providers/gemini-stream.mjs

@@ -22,7 +22,7 @@ import {
     emitGeminiToolCalls,
     collectGeminiGroundingSources,
     parseGeminiTextPartMetadata,
-} from './gemini.mjs';
+} from './gemini-schema.mjs';
 
 export const GEMINI_FIRST_BYTE_TIMEOUT_MS = resolveTimeoutMs(
     'MIXDOG_GEMINI_FIRST_BYTE_TIMEOUT_MS',

package/src/runtime/agent/orchestrator/providers/gemini.mjs

@@ -62,12 +62,6 @@ import {
     fetchAndCacheGeminiModels,
 } from './lib/gemini-model-catalog.mjs';
 
-// Legacy import path: tests + gemini-stream import these from gemini.mjs.
-// Re-export the extracted symbols so existing importers resolve unchanged.
-export { createGeminiTextLeakGuard };
-export { parseToolCalls, emitGeminiToolCalls, collectGeminiGroundingSources, parseGeminiTextPartMetadata };
-export { fetchGeminiModelPages, resolveLatestGeminiModel, ensureLatestGeminiModel };
-
 // De-dupes concurrent force-refreshes so they share one HTTP round-trip,
 // mirroring anthropic-oauth's _modelRefreshInFlight.
 let _modelRefreshInFlight = null;

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

@@ -0,0 +1,161 @@
+// Codex client-metadata for the openai-oauth WebSocket transport: the
+// 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';
+
+export function _cleanMetaString(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+
+export function _hashText(value, chars = 24) {
+    return createHash('sha256').update(String(value || '')).digest('hex').slice(0, chars);
+}
+
+// Session ids embed their creation stamp; fall back to now for foreign shapes.
+function _sessionStartedAtUnixMs(sessionId) {
+    const parts = String(sessionId || '').split('_');
+    for (const part of parts) {
+        if (/^\d{12,}$/.test(part)) {
+            const n = Number(part);
+            if (Number.isFinite(n) && n > 0) return Math.floor(n);
+        }
+    }
+    return Date.now();
+}
+
+function _codexRequestKind(sendOpts, sessionId) {
+    const explicit = _cleanMetaString(sendOpts?.requestKind || sendOpts?.codexRequestKind);
+    if (explicit) return explicit;
+    return String(sessionId || '').includes(':compact') ? 'compaction' : 'turn';
+}
+
+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)}`;
+}
+
+// The identity block codex rebuilds per request (responses_metadata.rs
+// client_metadata()): never cached on the pooled socket, or a later turn would
+// replay the first turn's identity.
+export function _codexMetadataBase(entry, { poolKey, cacheKey, sendOpts, handshake = false } = {}) {
+    const sessionId = _cleanMetaString(sendOpts?.codexSessionId || sendOpts?.session?.codexSessionId || poolKey || cacheKey)
+        || 'mixdog-session';
+    const threadId = _cleanMetaString(sendOpts?.threadId || sendOpts?.codexThreadId || sendOpts?.session?.threadId || cacheKey || sessionId)
+        || sessionId;
+    const installationId = _codexInstallationId(sendOpts);
+    const startedAt = Number.isFinite(Number(sendOpts?.turnStartedAtUnixMs))
+        ? Math.floor(Number(sendOpts.turnStartedAtUnixMs))
+        : _sessionStartedAtUnixMs(sessionId);
+    const requestKind = _codexRequestKind(sendOpts, sessionId);
+    const wireParity = process.env.MIXDOG_OAI_CODEX_WIRE_PARITY === '1';
+    // codex opens the WS with a prewarm (empty turn_id) BEFORE the real turn
+    // (client.rs). 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.
+    const isPrewarm = requestKind === 'prewarm' || handshake === true;
+    const explicitTurnId = _cleanMetaString(sendOpts?.turnId || sendOpts?.codexTurnId || sendOpts?.session?.turnId);
+    const explicitWindowId = _cleanMetaString(sendOpts?.windowId || sendOpts?.codexWindowId || sendOpts?.session?.windowId);
+    const turnId = wireParity && isPrewarm ? '' : (explicitTurnId || sessionId);
+    const effectiveRequestKind = wireParity && isPrewarm ? 'prewarm' : requestKind;
+    const windowId = explicitWindowId || `${threadId}:${wireParity ? 0 : 1}`;
+    const turnMetadata = {
+        installation_id: installationId,
+        session_id: sessionId,
+        thread_id: threadId,
+        turn_id: turnId,
+        window_id: windowId,
+        request_kind: effectiveRequestKind,
+        // Richer codex turn-metadata (responses_metadata.rs:264-280). A/B
+        // 2026-07-04 showed no effect, so it stays behind a knob for future
+        // probes; wire parity implies it.
+        ...((process.env.MIXDOG_OAI_TURN_METADATA_RICH === '1' || wireParity) ? {
+            thread_source: 'user',
+            sandbox: 'read-only',
+        } : {}),
+        turn_started_at_unix_ms: startedAt,
+    };
+    return {
+        'x-codex-installation-id': installationId,
+        session_id: sessionId,
+        thread_id: threadId,
+        turn_id: turnId,
+        'x-codex-window-id': windowId,
+        'x-codex-turn-metadata': JSON.stringify(turnMetadata),
+    };
+}
+
+export function _metadataTrace(metadata) {
+    if (!metadata || typeof metadata !== 'object') {
+        return { count: 0, hash: null, hasTurnMetadata: false, hasThreadId: false };
+    }
+    const keys = Object.keys(metadata).sort();
+    return {
+        count: keys.length,
+        hash: _hashText(keys.map((key) => `${key}=${metadata[key]}`).join('\n'), 12),
+        hasTurnMetadata: typeof metadata['x-codex-turn-metadata'] === 'string' && metadata['x-codex-turn-metadata'].length > 0,
+        hasThreadId: typeof metadata.thread_id === 'string' && metadata.thread_id.length > 0,
+    };
+}
+
+// Handshake projection of the same identity. codex attaches these on every
+// request (client.rs:582-584, responses_metadata.rs:227-252); A/B 2026-07-04
+// showed the turn-metadata blob alone lifts prefix-cache hits, so it is ON by
+// default. MIXDOG_OAI_TURN_METADATA overrides:
+//   unset|1|turn-metadata : window-id + turn-metadata + installation-id
+//   parent                : + x-codex-parent-thread-id
+//   window                : window-id only (drop the blob)
+//   0|off|false|no        : pre-2026-07-04 baseline (drop the blob)
+export function _codexWsCompatibilityHeaders(context = {}) {
+    const metadata = _codexMetadataBase(null, context);
+    const headers = {};
+    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'];
+    const parentThreadId = () => _cleanMetaString(context?.sendOpts?.parentThreadId
+        || context?.sendOpts?.codexParentThreadId
+        || metadata.thread_id);
+    const probe = String(process.env.MIXDOG_OAI_TURN_METADATA || '').trim().toLowerCase();
+    if (probe === '0' || probe === 'off' || probe === 'false' || probe === 'no' || probe === 'window') {
+        delete headers['x-codex-turn-metadata'];
+    } else if (probe === 'parent') {
+        const parent = parentThreadId();
+        if (parent) headers['x-codex-parent-thread-id'] = parent;
+    }
+    // Turn-state gate probe: attach the parent header independent of the knob
+    // above (hypothesis: x-codex-turn-state issuance wants it). Default OFF.
+    const gate = String(process.env.MIXDOG_OAI_CODEX_TURN_STATE_GATE || '').trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(gate) && !headers['x-codex-parent-thread-id']) {
+        const parent = parentThreadId();
+        if (parent) headers['x-codex-parent-thread-id'] = parent;
+    }
+    return headers;
+}
+
+export function _withCodexWsClientMetadata(frame, entry, enabled, context = {}) {
+    if (!enabled || !frame || typeof frame !== 'object') return frame;
+    const base = _codexMetadataBase(entry, context);
+    const metadata = {
+        ...base,
+        ...(frame.client_metadata && typeof frame.client_metadata === 'object' ? frame.client_metadata : {}),
+        'x-codex-ws-stream-request-start-ms': String(Date.now()),
+    };
+    if (entry && typeof entry === 'object') {
+        // codex scopes x-codex-turn-state to ONE turn (client.rs:263-279) while
+        // pooled sockets span turns: attribute a captured token to the FIRST
+        // turn that observes it, then drop it once turn_id moves on. An empty
+        // turn_id (parity prewarm) is a valid owner, so the check is against
+        // null rather than falsiness.
+        if (entry.turnState) {
+            if (entry.turnStateTurnId == null) {
+                entry.turnStateTurnId = base.turn_id;
+            } else if (entry.turnStateTurnId !== base.turn_id) {
+                entry.turnState = null;
+                entry.turnStateTurnId = null;
+            }
+        }
+        entry.currentTurnId = base.turn_id;
+    }
+    if (entry?.turnState) metadata['x-codex-turn-state'] = String(entry.turnState);
+    return { ...frame, client_metadata: metadata };
+}

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

@@ -190,210 +190,14 @@ function _envRatio(name, fallback) {
     return Number.isFinite(n) && n >= 0 && n <= 1 ? n : fallback;
 }
 
-function _cleanMetaString(value) {
-    return typeof value === 'string' ? value.trim() : '';
-}
-
-function _hashText(value, chars = 24) {
-    return createHash('sha256').update(String(value || '')).digest('hex').slice(0, chars);
-}
-
-function _sessionStartedAtUnixMs(sessionId) {
-    const parts = String(sessionId || '').split('_');
-    for (const part of parts) {
-        if (/^\d{12,}$/.test(part)) {
-            const n = Number(part);
-            if (Number.isFinite(n) && n > 0) return Math.floor(n);
-        }
-    }
-    return Date.now();
-}
-
-function _codexRequestKind(sendOpts, sessionId) {
-    const explicit = _cleanMetaString(sendOpts?.requestKind || sendOpts?.codexRequestKind);
-    if (explicit) return explicit;
-    return String(sessionId || '').includes(':compact') ? 'compaction' : 'turn';
-}
-
-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)}`;
-}
-
-function _codexMetadataBase(entry, { poolKey, cacheKey, sendOpts, handshake = false } = {}) {
-    const sessionId = _cleanMetaString(sendOpts?.codexSessionId || sendOpts?.session?.codexSessionId || poolKey || cacheKey)
-        || 'mixdog-session';
-    const threadId = _cleanMetaString(sendOpts?.threadId || sendOpts?.codexThreadId || sendOpts?.session?.threadId || cacheKey || sessionId)
-        || sessionId;
-    const installationId = _codexInstallationId(sendOpts);
-    const startedAt = Number.isFinite(Number(sendOpts?.turnStartedAtUnixMs))
-        ? Math.floor(Number(sendOpts.turnStartedAtUnixMs))
-        : _sessionStartedAtUnixMs(sessionId);
-    const requestKind = _codexRequestKind(sendOpts, sessionId);
-    const wireParity = process.env.MIXDOG_OAI_CODEX_WIRE_PARITY === '1';
-    // codex opens the WS with a prewarm (empty turn_id) BEFORE issuing the
-    // real turn (client.rs). Our handshake headers are built once, up-front,
-    // and were carrying a turn_id (= sessionId) — i.e. presenting the
-    // handshake as a live turn. Under wire parity, treat the handshake as the
-    // prewarm so its turn_id is empty, matching codex. Default (parity off) is
-    // unchanged: the wireParity gate below leaves turnId as before.
-    const isPrewarm = requestKind === 'prewarm' || handshake === true;
-    const explicitTurnId = _cleanMetaString(sendOpts?.turnId || sendOpts?.codexTurnId || sendOpts?.session?.turnId);
-    const explicitWindowId = _cleanMetaString(sendOpts?.windowId || sendOpts?.codexWindowId || sendOpts?.session?.windowId);
-    const turnId = wireParity && isPrewarm
-        ? ''
-        : (explicitTurnId || sessionId);
-    // Under wire parity the handshake IS the prewarm (empty turn_id above), so
-    // its request_kind must be 'prewarm' too — codex tags the prewarm request
-    // as prewarm, not turn (client.rs). Previously we emptied turn_id but left
-    // request_kind='turn', presenting the prewarm as a live turn. Default
-    // (parity off) is unchanged: requestKind passes through untouched.
-    const effectiveRequestKind = wireParity && isPrewarm ? 'prewarm' : requestKind;
-    const windowId = explicitWindowId
-        || `${threadId}:${wireParity ? 0 : 1}`;
-    const turnMetadata = {
-        installation_id: installationId,
-        session_id: sessionId,
-        thread_id: threadId,
-        turn_id: turnId,
-        window_id: windowId,
-        request_kind: effectiveRequestKind,
-        // Richer codex turn-metadata fields (responses_metadata.rs:264-280:
-        // thread_source "user" per protocol.rs:2751-2765, sandbox label).
-        // A/B 2026-07-04 (rvA/rvB interleaved, 24 sessions/arm): no effect
-        // (it2 full 3 vs 2, miss 2 vs 3 — noise). Default OFF; keep the knob
-        // for future probes if the backend starts gating on payload richness.
-        // Codex WS metadata parity (opt-in): the richer turn-metadata fields
-        // codex emits (responses_metadata.rs:264-280) also go on the wire under
-        // MIXDOG_OAI_CODEX_WIRE_PARITY. Default (both flags off) is unchanged.
-        ...((process.env.MIXDOG_OAI_TURN_METADATA_RICH === '1' || wireParity) ? {
-            thread_source: 'user',
-            sandbox: 'read-only',
-        } : {}),
-        turn_started_at_unix_ms: startedAt,
-    };
-    const metadata = {
-        'x-codex-installation-id': installationId,
-        session_id: sessionId,
-        thread_id: threadId,
-        turn_id: turnId,
-        'x-codex-window-id': windowId,
-        'x-codex-turn-metadata': JSON.stringify(turnMetadata),
-    };
-    // NOTE: no entry-level caching — pooled sockets outlive turns, and codex
-    // rebuilds metadata per request (responses_metadata.rs client_metadata()).
-    // Caching the first turn's turn_id on the socket would replay stale turn
-    // identity for every later turn on that connection.
-    return metadata;
-}
-
-function _metadataTrace(metadata) {
-    if (!metadata || typeof metadata !== 'object') {
-        return { count: 0, hash: null, hasTurnMetadata: false, hasThreadId: false };
-    }
-    const keys = Object.keys(metadata).sort();
-    return {
-        count: keys.length,
-        hash: _hashText(keys.map((key) => `${key}=${metadata[key]}`).join('\n'), 12),
-        hasTurnMetadata: typeof metadata['x-codex-turn-metadata'] === 'string' && metadata['x-codex-turn-metadata'].length > 0,
-        hasThreadId: typeof metadata.thread_id === 'string' && metadata.thread_id.length > 0,
-    };
-}
-
-function _codexWsCompatibilityHeaders(context = {}) {
-    const metadata = _codexMetadataBase(null, context);
-    const headers = {};
-    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'];
-    // codex sends x-codex-installation-id on EVERY request incl. the WS
-    // handshake (client.rs:582-584). We previously carried it only in the
-    // body client_metadata; the server may gate x-codex-turn-state issuance
-    // on handshake-level client identity, so mirror codex here.
-    if (metadata['x-codex-installation-id']) headers['x-codex-installation-id'] = metadata['x-codex-installation-id'];
-    // Turn-metadata handshake header. codex's compatibility_headers()
-    // (responses_metadata.rs:227-252) attaches x-codex-turn-metadata /
-    // x-codex-parent-thread-id / x-codex-window-id on the request. A/B
-    // (2026-07-04, tm0b vs tm1b, 10 parallel-5 sessions each, gpt-5.5):
-    // WITH the turn-metadata blob it2 cache misses dropped 4/10 -> 0/10 and
-    // full-prefix hits rose 2/10 -> 7/10; x-codex-turn-state was never issued
-    // in either arm, so the win comes from better cache routing on the
-    // handshake fingerprint, not sticky turn-state. Default ON.
-    // MIXDOG_OAI_TURN_METADATA overrides:
-    //   unset / 1 / turn-metadata : window-id + turn-metadata + installation-id
-    //   parent                    : + x-codex-parent-thread-id (= thread_id)
-    //   window                    : window-id only (drop turn-metadata blob)
-    //   0 / off / false / no      : strip the blob (pre-2026-07-04 baseline)
-    const probe = String(process.env.MIXDOG_OAI_TURN_METADATA || '').trim().toLowerCase();
-    if (probe === '0' || probe === 'off' || probe === 'false' || probe === 'no') {
-        // Not opted in: keep window-id + installation-id but drop the full
-        // turn-metadata blob so we match the historical (turn-state-never-issued)
-        // baseline exactly.
-        delete headers['x-codex-turn-metadata'];
-    } else if (probe === 'parent') {
-        const parentThreadId = _cleanMetaString(context?.sendOpts?.parentThreadId
-            || context?.sendOpts?.codexParentThreadId
-            || metadata.thread_id);
-        if (parentThreadId) headers['x-codex-parent-thread-id'] = parentThreadId;
-    } else if (probe === 'window') {
-        delete headers['x-codex-turn-metadata'];
-    }
-    // probe === '1' | 'true' | 'yes' | 'on' | 'turn-metadata' => full set as built above.
-    // Turn-state gate experiment bundle (MIXDOG_OAI_CODEX_TURN_STATE_GATE): the
-    // debugger's hypothesis is that x-codex-turn-state issuance also wants the
-    // parent-thread header present, independent of MIXDOG_OAI_TURN_METADATA.
-    // Attach it (= thread_id) when the gate is explicitly enabled and the probe
-    // above didn't already set it. Default OFF; composes with the probe.
-    const gate = String(process.env.MIXDOG_OAI_CODEX_TURN_STATE_GATE || '').trim().toLowerCase();
-    if (['1', 'true', 'yes', 'on'].includes(gate) && !headers['x-codex-parent-thread-id']) {
-        const parentThreadId = _cleanMetaString(context?.sendOpts?.parentThreadId
-            || context?.sendOpts?.codexParentThreadId
-            || metadata.thread_id);
-        if (parentThreadId) headers['x-codex-parent-thread-id'] = parentThreadId;
-    }
-    return headers;
-}
-
-export function _withCodexWsClientMetadata(frame, entry, enabled, context = {}) {
-    if (!enabled || !frame || typeof frame !== 'object') return frame;
-    const base = _codexMetadataBase(entry, context);
-    const metadata = {
-        ...base,
-        ...(frame.client_metadata && typeof frame.client_metadata === 'object' ? frame.client_metadata : {}),
-        'x-codex-ws-stream-request-start-ms': String(Date.now()),
-    };
-    if (entry && typeof entry === 'object') {
-        // codex scopes x-codex-turn-state to ONE turn (client.rs:263-279 —
-        // "must not send it between different turns"). Pooled sockets span
-        // turns, so key the stored token by the turn that captured it and
-        // drop it when the turn changes. turnState is captured at handshake
-        // (pool) / mid-stream (ws-stream) without knowing the owning turn, so
-        // attribute it to the FIRST turn that observes it here; once turn_id
-        // moves off that owner, drop the stale token. (Previously
-        // turnStateTurnId was checked but never assigned, so this guard was
-        // dead and stale turn-state could leak across turns under parity.)
-        if (entry.turnState) {
-            // An empty turn_id (parity prewarm) is a VALID owner attribution, not
-            // "unassigned". Test against null/undefined so a prewarm-owned token
-            // (turn_id '') is retired once turn_id advances to the real turn,
-            // instead of being reattributed onto it. Default (parity off) never
-            // produces an empty turn_id, so this is unchanged there.
-            if (entry.turnStateTurnId == null) {
-                entry.turnStateTurnId = base.turn_id;
-            } else if (entry.turnStateTurnId !== base.turn_id) {
-                entry.turnState = null;
-                entry.turnStateTurnId = null;
-            }
-        }
-        entry.currentTurnId = base.turn_id;
-    }
-    if (entry?.turnState) {
-        metadata['x-codex-turn-state'] = String(entry.turnState);
-    }
-    return {
-        ...frame,
-        client_metadata: metadata,
-    };
-}
+// Codex client metadata (identity block, handshake headers, per-turn
+// turn-state guard) lives in openai-codex-metadata.mjs.
+import {
+    _codexWsCompatibilityHeaders,
+    _hashText,
+    _metadataTrace,
+    _withCodexWsClientMetadata,
+} from './openai-codex-metadata.mjs';
 
 function _cacheObservation({ entry, result, continuityResetReason = null }) {
     const inputTokens = _num(result?.usage?.inputTokens, 0);

package/src/runtime/agent/orchestrator/session/cache/prefetch-cache.mjs

@@ -7,6 +7,7 @@
 import { classifyResultKind } from '../result-classification.mjs';
 import { _normalizeAbs, _normalizeCacheKey, _statTuple, _statEqual } from './util.mjs';
 import { readFileSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
+import { readdir, stat as statAsync, unlink } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
 import { createHash } from 'node:crypto';
 import { writeJsonAtomicSync } from '../../../../shared/atomic-file.mjs';
@@ -24,6 +25,30 @@ const _pendingDiskWrites = new Map();
 let _diskWriteTimer = null;
 
 const DISK_CACHE_DIR = join(resolvePluginData(), 'cache', 'prefetch');
+// Disk GC: an entry is only unlinked when something looks it up again and
+// finds it stale, so files for paths that are never re-read (or whose process
+// died) sit in cache/prefetch forever. Sweep past-TTL files on an interval.
+const DISK_SWEEP_INTERVAL_MS = 60 * 60 * 1000;
+let _diskSweptAt = 0;
+async function _sweepDiskCache() {
+    let names;
+    try { names = await readdir(DISK_CACHE_DIR); } catch { return; }
+    const cutoff = Date.now() - _prefetchTtlMs;
+    await Promise.all(names.map(async (name) => {
+        if (!name.endsWith('.json')) return;
+        const p = join(DISK_CACHE_DIR, name);
+        try {
+            const st = await statAsync(p);
+            if (st.mtimeMs < cutoff) await unlink(p).catch(() => {});
+        } catch { /* raced with another sweep */ }
+    }));
+}
+function _maybeSweepDiskCache() {
+    const now = Date.now();
+    if (now - _diskSweptAt < DISK_SWEEP_INTERVAL_MS) return;
+    _diskSweptAt = now;
+    void _sweepDiskCache();
+}
 function _diskPath(absPath) {
     const hash = createHash('sha256').update(absPath).digest('hex').slice(0, 16);
     return join(DISK_CACHE_DIR, `${hash}.json`);
@@ -70,6 +95,7 @@ function _deleteDiskEntry(absPath) {
  */
 export function tryPrefetchCached(absPath) {
     if (typeof absPath !== 'string' || absPath.length === 0) return null;
+    _maybeSweepDiskCache();
     absPath = _normalizeCacheKey(absPath);
     let entry = _prefetchCache.get(absPath);
     if (!entry) {