mixdog 0.9.49 → 0.9.51

package/README.md

@@ -152,12 +152,12 @@ current Anthropic models.
 ## Scripts
 
 ```bash
-npm run smoke          # basic smoke check
-npm run smoke:all      # core smoke suite
-npm run smoke:tui      # TUI render smoke
-npm run smoke:tools    # tool smoke suite
-npm run build:tui      # build the bundled Ink TUI
-npm run audit:models   # inspect model catalog metadata
+npm run smoke                # fast core feature smoke
+npm run smoke:all            # feature-surface smoke suite
+npm run smoke:tui            # TUI feature smoke
+npm run test:tool-contracts  # optional tool contract suite
+npm run build:tui            # build the bundled Ink TUI
+npm run audit:models         # inspect model catalog metadata
 ```
 
 Additional diagnostics and benchmarks live under `scripts/`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.49",
+  "version": "0.9.51",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -36,14 +36,14 @@
     "prepack": "npm run build:tui",
     "prepublishOnly": "node -e \"if(!process.env.CI){console.error('local npm publish is disabled — run npm run release:patch');process.exit(1)}\"",
     "start": "node src/cli.mjs",
-    "smoke": "node scripts/smoke.mjs && node --test scripts/ship-mode-test.mjs && npm run test:memory-routing && node --test scripts/explore-prompt-policy-test.mjs && node --test scripts/routing-corpus-test.mjs",
-    "smoke:all": "npm run smoke && npm run smoke:boot && npm run smoke:tools && npm run smoke:patch && npm run smoke:output && npm run smoke:tui && npm run smoke:freevars && npm run smoke:logguard && npm run smoke:live-worker && npm run test:session",
+    "smoke": "node scripts/smoke.mjs",
+    "smoke:all": "npm run smoke && npm run smoke:boot && npm run smoke:patch && npm run smoke:output && npm run smoke:tui && npm run smoke:live-worker",
     "smoke:boot": "node scripts/boot-smoke.mjs",
     "smoke:compact": "node scripts/compact-smoke.mjs",
     "smoke:loop": "node scripts/smoke-loop.mjs",
-    "smoke:loop:final": "node scripts/smoke-loop-report.mjs --require-complete --min-elapsed 5h --min-iterations 400 --max-gap 60s --max-smoke-ms 10000 --max-avg-smoke-ms 8500 --max-step-ms boot-smoke.mjs=8000 --max-step-ms tool-smoke.mjs=4000 --max-rss-mb 140 --max-rss-growth-mb 50",
+    "smoke:loop:final": "node scripts/smoke-loop-report.mjs --require-complete --min-elapsed 5h --min-iterations 400 --max-gap 60s --max-smoke-ms 10000 --max-avg-smoke-ms 8500 --max-step-ms smoke.mjs=4000 --max-step-ms boot-smoke.mjs=8000 --max-rss-mb 140 --max-rss-growth-mb 50",
     "smoke:loop:report": "node scripts/smoke-loop-report.mjs",
-    "smoke:tools": "node scripts/tool-smoke.mjs",
+    "test:tool-contracts": "node scripts/tool-smoke.mjs",
     "smoke:patch": "node scripts/apply-patch-edit-smoke.mjs",
     "smoke:output": "node scripts/output-style-smoke.mjs",
     "smoke:tui": "node scripts/tui-render-smoke.mjs && npm run test:tui-input-render && npm run test:tui-streaming-window && npm run test:tui-queue",
@@ -62,14 +62,14 @@
     "test:anthropic-oauth-race": "node --test scripts/anthropic-oauth-refresh-race-test.mjs",
     "test:grok-oauth-race": "node --test scripts/grok-oauth-refresh-race-test.mjs",
     "test:atomiclock": "node --test scripts/atomic-lock-tryonce-test.mjs",
-    "test:memory-routing": "node --test scripts/memory-cycle-routing-test.mjs scripts/memory-rule-contract-test.mjs scripts/maintenance-default-routes-test.mjs",
+    "test:memory-routing": "node --test scripts/memory-cycle-routing-test.mjs scripts/maintenance-default-routes-test.mjs scripts/embedding-worker-exit-test.mjs",
     "test:code-graph-dispatch": "node --test scripts/code-graph-dispatch-test.mjs",
     "test:code-graph-clean-cache": "node --test scripts/code-graph-dispatch-test.mjs",
     "test:tui-queue": "node --test scripts/submit-commandbusy-race-test.mjs scripts/steering-drain-buckets-test.mjs scripts/abort-recovery-test.mjs scripts/execution-pending-resume-kick-test.mjs scripts/execution-resume-esc-integration-test.mjs",
     "test:tui-input-render": "node --test scripts/prompt-immediate-render-test.mjs",
     "test:tui-streaming-window": "node --test scripts/streaming-tail-window-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:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && npm run smoke:tools && node --test 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 && node --test scripts/tui-transcript-perf-test.mjs",
+    "test:release-focused": "npm run test:release-assets && npm run test:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && node --test 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 && 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",

package/scripts/embedding-worker-exit-test.mjs

@@ -0,0 +1,76 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { spawn } from 'node:child_process'
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const providerUrl = new URL('../src/runtime/memory/lib/embedding-provider.mjs', import.meta.url)
+const CHILD_DEADLINE_MS = 3_000
+
+async function createExitWorkerFixture() {
+  const tempDir = await mkdtemp(join(tmpdir(), 'mixdog-embed-worker-exit-'))
+  const workerPath = join(tempDir, 'exit-before-reply.mjs')
+  await writeFile(workerPath, `
+    import { parentPort } from 'node:worker_threads'
+    parentPort.once('message', () => process.exit(0))
+  `)
+  const source = await readFile(providerUrl, 'utf8')
+  const instrumented = source
+    .replace("'./model-profile.mjs'", JSON.stringify(new URL('../src/runtime/memory/lib/model-profile.mjs', import.meta.url).href))
+    .replace("'./embedding-model-config.mjs'", JSON.stringify(new URL('../src/runtime/memory/lib/embedding-model-config.mjs', import.meta.url).href))
+    .replace(/^const WORKER_PATH = .*$/m, `const WORKER_PATH = ${JSON.stringify(workerPath)}`)
+  const providerModule = `data:text/javascript;base64,${Buffer.from(instrumented).toString('base64')}#${Date.now()}`
+  const fixturePath = join(tempDir, 'run-exit-test.mjs')
+  await writeFile(fixturePath, `
+    import { embedText } from ${JSON.stringify(providerModule)}
+    const started = Date.now()
+    const settled = await Promise.allSettled([embedText('first'), embedText('second')])
+    if (Date.now() - started >= 2_000) throw new Error('worker exit did not reject pending embeds promptly')
+    if (settled.some(({ status }) => status !== 'rejected')) throw new Error('worker exit resolved a pending embed')
+    for (const result of settled) {
+      if (result.reason?.message !== 'Worker exited with code 0') throw result.reason
+    }
+    process.stdout.write('ok')
+  `)
+  return { fixturePath, tempDir }
+}
+
+function runFixture(fixturePath) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [fixturePath], { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true })
+    let stdout = ''
+    let stderr = ''
+    let timedOut = false
+    const deadline = setTimeout(() => {
+      timedOut = true
+      child.kill()
+    }, CHILD_DEADLINE_MS)
+    child.stdout.on('data', (chunk) => { stdout += chunk })
+    child.stderr.on('data', (chunk) => { stderr += chunk })
+    child.once('error', (error) => {
+      clearTimeout(deadline)
+      reject(error)
+    })
+    child.once('close', (code, signal) => {
+      clearTimeout(deadline)
+      if (timedOut) {
+        reject(new Error(`exit-worker fixture exceeded ${CHILD_DEADLINE_MS}ms and was killed`))
+        return
+      }
+      resolve({ code, signal, stdout, stderr })
+    })
+  })
+}
+
+test('code-zero worker exit before reply promptly rejects every pending embed', async () => {
+  const { fixturePath, tempDir } = await createExitWorkerFixture()
+  try {
+    const result = await runFixture(fixturePath)
+    assert.equal(result.code, 0, result.stderr)
+    assert.equal(result.signal, null, result.stderr)
+    assert.equal(result.stdout, 'ok')
+  } finally {
+    await rm(tempDir, { recursive: true, force: true })
+  }
+})

package/scripts/hook-bus-test.mjs

@@ -60,6 +60,29 @@ if (command.includes('rm -rf')) {
   }
 });
 
+test('standard PreToolUse hook can replace the tool name', async () => {
+  const root = tempRoot();
+  const hookScript = join(root, 'rename.mjs');
+  writeFileSync(hookScript, `console.log(JSON.stringify({ hookSpecificOutput: {
+    hookEventName: 'PreToolUse',
+    updatedToolName: 'local_fetch'
+  }}));\n`, 'utf8');
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, { hooks: { PreToolUse: [{ matcher: 'web_fetch', hooks: [{ type: 'command', command: process.execPath, args: [hookScript] }] }] } });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const decision = await createStandaloneHookBus({ dataDir: root }).beforeTool({
+      cwd: root, name: 'web_fetch', args: { url: 'http://localhost:3000/' },
+    });
+    assert.equal(decision.action, 'modify');
+    assert.equal(decision.name, 'local_fetch');
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
 test('UserPromptSubmit hook returns additional context', async () => {
   const root = tempRoot();
   const hookScript = join(root, 'prompt.mjs');

package/scripts/internal-tools-normalization-test.mjs

@@ -50,3 +50,13 @@ test('isError:false output stays normal', async () => {
     assert.equal(result, 'search complete');
     assert.equal(classifyResultKind(result), 'normal');
 });
+
+test('structured image output survives internal tool normalization', async () => {
+    const input = {
+        content: [
+            { type: 'text', text: 'downloaded' },
+            { type: 'image', source: { type: 'base64', media_type: 'image/png', data: 'YWJj' } },
+        ],
+    };
+    assert.deepEqual(await normalizeToolResult(input), input);
+});

package/scripts/openai-oauth-ws-1006-retry-test.mjs

@@ -1,9 +1,16 @@
 // Regression: OpenAI OAuth WS abnormal-close recovery before visible output.
 import test from 'node:test';
 import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
 import { OpenAIOAuthProvider } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
 import { _acquireWithRetry, sendViaWebSocket } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
-import { _sendFrame } from '../src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs';
+import {
+    _clearWebSocketPoolForTest,
+    _seedWebSocketEntryForTest,
+    acquireWebSocket,
+    releaseWebSocket,
+    _sendFrame,
+} from '../src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs';
 
 function close1006() {
     const err = new Error('WebSocket closed abnormally');
@@ -28,6 +35,65 @@ function wsArgs(overrides = {}) {
     };
 }
 
+class PoolSocket extends EventEmitter {
+    constructor() {
+        super();
+        this.readyState = 1;
+        this._socket = { ref() {}, unref() {} };
+    }
+    close() { this.readyState = 3; }
+    ping() { queueMicrotask(() => this.emit('pong')); }
+}
+
+function poolEntry(responseId) {
+    return {
+        socket: new PoolSocket(),
+        busy: true,
+        closing: false,
+        ephemeral: false,
+        lastResponseId: responseId,
+    };
+}
+
+test('pool release/acquire preserves latest compatible chain and auth/cache boundaries', async (t) => {
+    t.after(() => _clearWebSocketPoolForTest());
+    const poolKey = 'reused-session-id';
+    const authA = { account_id: 'account-a', access_token: 'token-a' };
+    const authB = { account_id: 'account-b', access_token: 'token-b' };
+    const oldest = _seedWebSocketEntryForTest({
+        poolKey, auth: authA, cacheKey: 'cache-a', entry: poolEntry('resp-old'),
+    });
+    const latest = _seedWebSocketEntryForTest({
+        poolKey, auth: authA, cacheKey: 'cache-a', entry: poolEntry('resp-latest'),
+    });
+    const otherAccount = _seedWebSocketEntryForTest({
+        poolKey, auth: authB, cacheKey: 'cache-a', entry: poolEntry('resp-account-b'),
+    });
+    const otherCache = _seedWebSocketEntryForTest({
+        poolKey, auth: authA, cacheKey: 'cache-b', entry: poolEntry('resp-cache-b'),
+    });
+
+    releaseWebSocket({ entry: oldest, poolKey, keep: true });
+    releaseWebSocket({ entry: otherAccount, poolKey, keep: true });
+    releaseWebSocket({ entry: otherCache, poolKey, keep: true });
+    releaseWebSocket({ entry: latest, poolKey, keep: true });
+
+    const first = await acquireWebSocket({
+        auth: authA, poolKey, cacheKey: 'cache-a', forceFresh: false,
+    });
+    assert.equal(first.entry, latest, 'latest completed compatible chain wins');
+    assert.equal(first.reused, true);
+    assert.equal(latest.busy, true, 'acquire reserves the selected entry');
+
+    const second = await acquireWebSocket({
+        auth: authA, poolKey, cacheKey: 'cache-a', forceFresh: false,
+    });
+    assert.equal(second.entry, oldest, 'reserved latest entry cannot be acquired concurrently');
+    assert.equal(second.entry.lastResponseId, 'resp-old');
+    assert.notEqual(second.entry, otherAccount);
+    assert.notEqual(second.entry, otherCache);
+});
+
 test('acquire timeout reconnects successfully with progress, not a terminal WS error', async () => {
     const oldWrite = process.stderr.write;
     const oldQuiet = process.env.MIXDOG_QUIET_PROVIDER_LOG;

package/scripts/provider-toolcall-test.mjs

@@ -37,6 +37,7 @@ import {
 import {
     _cacheObservationForTest,
     _cacheContinuityResetReasonForTest,
+    sendViaWebSocket,
 } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
 import {
     _withCodexWsClientMetadata,
@@ -1786,13 +1787,23 @@ test('openai oauth ws delta: ws-delta mode uses previous_response_id without tur
             entry: {
                 ...entry,
                 lastRequestInput: [body.input[0]],
-                lastResponseItems: [{ type: 'function_call', call_id: 'call_1', name: 'tool', arguments: '{}' }],
+                lastResponseItems: [{
+                    type: 'function_call',
+                    call_id: 'call_1',
+                    name: 'tool',
+                    arguments: '{"api_key":"provider-function-secret","nested":{"z":2,"a":1}}',
+                }],
             },
             body: {
                 ...body,
                 input: [
                     body.input[0],
-                    { type: 'function_call', call_id: 'call_other', name: 'tool', arguments: '{}' },
+                    {
+                        type: 'function_call',
+                        call_id: 'call_other',
+                        name: 'tool',
+                        arguments: '{"nested":{"a":1,"z":2},"api_key":"replayed-function-secret"}',
+                    },
                     body.input[1],
                 ],
             },
@@ -1800,6 +1811,193 @@ test('openai oauth ws delta: ws-delta mode uses previous_response_id without tur
         assert.equal(responseMismatch.mode, 'full');
         assert.equal(responseMismatch.reason, 'response_output_mismatch:function_call');
         assert.equal(responseMismatch.frame.previous_response_id, undefined);
+        const mismatch = responseMismatch.responseOutputMismatch;
+        assert.deepEqual({
+            expectedType: mismatch.response_output_mismatch_expected_type,
+            actualType: mismatch.response_output_mismatch_actual_type,
+            expectedCount: mismatch.response_output_mismatch_expected_response_item_count,
+            actualCount: mismatch.response_output_mismatch_actual_replayed_input_item_count,
+        }, {
+            expectedType: 'function_call',
+            actualType: 'function_call',
+            expectedCount: 1,
+            actualCount: 2,
+        });
+        assert.match(mismatch.response_output_mismatch_expected_hash, /^[a-f0-9]{64}$/);
+        assert.match(mismatch.response_output_mismatch_actual_hash, /^[a-f0-9]{64}$/);
+        const traceSafe = JSON.stringify(mismatch);
+        assert.equal(traceSafe.includes('call_other'), false);
+        assert.equal(traceSafe.includes('provider-function-secret'), false);
+        assert.equal(traceSafe.includes('replayed-function-secret'), false);
+    } finally {
+        if (prevTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
+        else process.env.MIXDOG_OAI_TRANSPORT = prevTransport;
+    }
+});
+
+test('openai oauth ws delta: message mismatch diagnostics hash normalized content without tracing it', () => {
+    const prevTransport = process.env.MIXDOG_OAI_TRANSPORT;
+    try {
+        process.env.MIXDOG_OAI_TRANSPORT = 'ws-delta';
+        const prior = { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'prior' }] };
+        const expected = { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'provider secret' }] };
+        const actual = { type: 'message', role: 'assistant', content: [{ type: 'input_text', text: 'replayed secret' }] };
+        const delta = _computeDelta({
+            entry: {
+                lastRequestSansInput: '{"model":"gpt-5.5"}',
+                lastResponseId: 'resp_prev',
+                lastRequestInput: [prior],
+                lastResponseItems: [expected],
+            },
+            body: { model: 'gpt-5.5', input: [prior, actual] },
+        });
+        const mismatch = delta.responseOutputMismatch;
+        assert.equal(delta.reason, 'response_output_mismatch:message');
+        assert.equal(mismatch.response_output_mismatch_expected_type, 'message');
+        assert.equal(mismatch.response_output_mismatch_actual_type, 'message');
+        assert.notEqual(mismatch.response_output_mismatch_expected_hash, mismatch.response_output_mismatch_actual_hash);
+        const traceSafe = JSON.stringify(mismatch);
+        assert.equal(traceSafe.includes('provider secret'), false);
+        assert.equal(traceSafe.includes('replayed secret'), false);
+    } finally {
+        if (prevTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
+        else process.env.MIXDOG_OAI_TRANSPORT = prevTransport;
+    }
+});
+
+test('openai oauth ws delta: diagnostic hashes normalize equivalent message and function-call forms', () => {
+    const prevTransport = process.env.MIXDOG_OAI_TRANSPORT;
+    try {
+        process.env.MIXDOG_OAI_TRANSPORT = 'ws-delta';
+        const prior = { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'prior' }] };
+        const mismatch = (expected, actual) => _computeDelta({
+            entry: {
+                lastRequestSansInput: '{"model":"gpt-5.5"}',
+                lastResponseId: 'resp_prev',
+                lastRequestInput: [prior],
+                lastResponseItems: [expected],
+            },
+            body: { model: 'gpt-5.5', input: [prior, actual] },
+        }).responseOutputMismatch;
+        const message = { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'same sensitive message' }] };
+        const messageExpected = mismatch(message, {
+            type: 'message',
+            role: 'assistant',
+            content: [{ type: 'output_text', text: 'different message' }],
+        });
+        const messageActual = mismatch({
+            type: 'message',
+            role: 'assistant',
+            content: [{ type: 'output_text', text: 'different message' }],
+        }, {
+            type: 'message',
+            role: 'assistant',
+            content: [{ type: 'input_text', text: 'same sensitive message' }],
+        });
+        assert.equal(
+            messageExpected.response_output_mismatch_expected_hash,
+            messageActual.response_output_mismatch_actual_hash,
+        );
+
+        const functionExpected = (argumentsValue) => mismatch({
+            type: 'function_call',
+            call_id: 'call_same',
+            name: 'tool',
+            arguments: argumentsValue,
+        }, {
+            type: 'function_call',
+            call_id: 'call_different',
+            name: 'tool',
+            arguments: '{"ignored":"replayed-function-secret"}',
+        });
+        assert.equal(
+            functionExpected('{"api_key":"function-secret","nested":{"z":2,"a":1}}').response_output_mismatch_expected_hash,
+            functionExpected('{"nested":{"a":1,"z":2},"api_key":"function-secret"}').response_output_mismatch_expected_hash,
+        );
+    } finally {
+        if (prevTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
+        else process.env.MIXDOG_OAI_TRANSPORT = prevTransport;
+    }
+});
+
+test('openai oauth ws delta: mismatch diagnostics reach transport and cache_break without sensitive values', async () => {
+    const prevTransport = process.env.MIXDOG_OAI_TRANSPORT;
+    try {
+        process.env.MIXDOG_OAI_TRANSPORT = 'ws-delta';
+        const rows = [];
+        const prior = { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'prior' }] };
+        const cases = [{
+            expected: {
+                type: 'function_call',
+                call_id: 'call_expected',
+                name: 'tool',
+                arguments: '{"api_key":"provider-function-secret","nested":{"z":2,"a":1}}',
+            },
+            actual: {
+                type: 'function_call',
+                call_id: 'call_actual',
+                name: 'tool',
+                arguments: '{"nested":{"a":1,"z":2},"api_key":"replayed-function-secret"}',
+            },
+        }, {
+            expected: {
+                type: 'custom_tool_call',
+                call_id: 'custom_expected',
+                name: 'apply_patch',
+                input: 'provider-custom-input-secret',
+            },
+            actual: {
+                type: 'custom_tool_call',
+                call_id: 'custom_actual',
+                name: 'apply_patch',
+                input: 'replayed-custom-input-secret',
+            },
+        }];
+        for (const { expected, actual } of cases) {
+            const body = { model: 'gpt-5.5', input: [prior, actual] };
+            const entry = {
+                socket: { close() {} },
+                lastRequestSansInput: _stableStringify(_sansInput(body)),
+                lastResponseId: 'resp_prev',
+                lastRequestInput: [prior],
+                lastResponseItems: [expected],
+            };
+            const expectedDiagnostics = _computeDelta({ entry, body }).responseOutputMismatch;
+            await sendViaWebSocket({
+                auth: { type: 'xai', access_token: 'test-token' },
+                body,
+                poolKey: `mismatch-trace-${expected.type}`,
+                cacheKey: 'mismatch-trace-test',
+                iteration: 1,
+                useModel: 'gpt-5.5',
+                traceProvider: 'xai',
+                _acquireWithRetryFn: async () => ({ entry, reused: false }),
+                _sendFrameFn: async () => {},
+                _streamFn: async () => ({
+                    content: 'ok',
+                    model: 'gpt-5.5',
+                    toolCalls: [],
+                    usage: {},
+                    responseId: 'resp_next',
+                    responseItems: [],
+                    closeSocket: true,
+                }),
+                _agentTraceFn: (row) => rows.push(row),
+            });
+            const emitted = rows.filter((row) => row.payload?.response_output_mismatch_expected_type === expected.type);
+            assert.deepEqual(emitted.map((row) => row.kind).sort(), ['cache_break', 'transport']);
+            for (const row of emitted) assert.deepEqual(
+                Object.fromEntries(Object.keys(expectedDiagnostics).map((key) => [key, row.payload[key]])),
+                expectedDiagnostics,
+            );
+        }
+        const traceText = JSON.stringify(rows);
+        for (const secret of [
+            'provider-function-secret',
+            'replayed-function-secret',
+            'provider-custom-input-secret',
+            'replayed-custom-input-secret',
+        ]) assert.equal(traceText.includes(secret), false);
     } finally {
         if (prevTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
         else process.env.MIXDOG_OAI_TRANSPORT = prevTransport;

package/scripts/session-bench-cache-break-test.mjs

@@ -0,0 +1,102 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+test('root session bench promotes actionable compact mismatches without hiding intentional transitions', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'mixdog-session-bench-'));
+  const trace = join(dir, 'trace.jsonl');
+  const sessionId = 'cache-break-observability';
+  const rows = [
+    ...Array.from({ length: 4 }, (_, index) => ({
+      ts: index + 1, sessionId, iteration: index + 1, kind: 'cache_break',
+      payload: { reason: 'input_prefix_mismatch', intentional_transition: 'automatic_compaction' },
+    })),
+    ...Array.from({ length: 2 }, (_, index) => ({
+      ts: index + 5, sessionId, iteration: index + 5, kind: 'cache_break',
+      payload: { reason: 'input_prefix_mismatch', intentional_transition: 'transcript_rebuild' },
+    })),
+    ...Array.from({ length: 2 }, (_, index) => ({
+      ts: index + 7, sessionId, iteration: index + 7, kind: 'cache_break',
+      payload: {
+        reason: 'request_properties_changed',
+        intentional_transition: 'explorer_hard_cap_final_tool_choice_none',
+        request_tool_choice: 'none',
+      },
+    })),
+    {
+      ts: 9, sessionId, iteration: 9, kind: 'cache_break',
+      payload: { reason: 'response_output_mismatch:function_call' },
+    },
+    {
+      ts: 10, sessionId, iteration: 10, kind: 'cache_break',
+      payload: { reason: 'input_prefix_mismatch', intentional_transition: 'unknown_transition' },
+    },
+    {
+      ts: 11, sessionId, iteration: 11, kind: 'cache_break',
+      payload: {
+        reason: 'response_output_mismatch:function_call',
+        intentional_transition: 'automatic_compaction',
+      },
+    },
+    {
+      ts: 12, sessionId: `${sessionId}:compact`, iteration: 1, kind: 'cache_break',
+      payload: { reason: 'input_prefix_mismatch' },
+    },
+    {
+      ts: 13, sessionId, iteration: 13, kind: 'cache_break',
+      payload: {
+        reason: 'request_properties_changed',
+        intentional_transition: 'explorer_hard_cap_final_tool_choice_none',
+      },
+    },
+    ...Array.from({ length: 6 }, (_, index) => ({
+      ts: index + 14, sessionId, iteration: index + 14, kind: 'cache_break',
+      payload: { reason: 'response_output_mismatch:function_call' },
+    })),
+  ];
+  writeFileSync(trace, `${rows.map((row) => JSON.stringify(row)).join('\n')}\n`);
+  try {
+    const output = execFileSync(process.execPath, [
+      'scripts/session-bench.mjs', '--json', '--trace', trace, '--session', sessionId,
+    ], { cwd: process.cwd(), encoding: 'utf8' });
+    const report = JSON.parse(output);
+    assert.equal(report.cache.cache_breaks.length, 19, 'raw evidence is retained');
+    assert.equal(report.cache.intentional_cache_breaks.length, 8);
+    assert.equal(report.cache.actionable_cache_breaks.length, 11);
+    assert.deepEqual(
+      report.cache.intentional_cache_breaks.map((row) => row.phase),
+      [
+        ...Array(4).fill('intentional_automatic_compaction'),
+        ...Array(2).fill('intentional_transcript_rebuild'),
+        ...Array(2).fill('intentional_explorer_hard_cap_final_tool_choice_none'),
+      ],
+    );
+    assert.equal(report.cache.actionable_cache_breaks[0].reason, 'response_output_mismatch:function_call');
+    const actionableByTs = new Map(report.cache.actionable_cache_breaks.map((row) => [row.ts, row]));
+    assert.equal(actionableByTs.get(10).intentional_transition, 'unknown_transition');
+    assert.equal(actionableByTs.get(11).intentional_transition, 'automatic_compaction');
+    assert.equal(actionableByTs.get(12).session_id, `${sessionId}:compact`);
+    assert.equal(actionableByTs.get(13).intentional_transition, 'explorer_hard_cap_final_tool_choice_none');
+    const cacheBreakIssues = report.issues.filter((issue) => issue.type === 'cache_break');
+    assert.equal(cacheBreakIssues.length, 10, 'the cache-break issue cap remains bounded');
+    assert.equal(cacheBreakIssues.filter((issue) => issue.session_id === sessionId).length, 9);
+    assert.ok(
+      report.issues.some((issue) => issue.type === 'cache_break' && issue.session_id === `${sessionId}:compact`),
+      'the root report must surface a child compact mismatch as an issue',
+    );
+    assert.ok(
+      report.rankings.some((ranking) => ranking.type === 'cache_breaks' && ranking.message.includes('11 actionable cache break(s)')),
+      'the root report must rank child compact mismatches with other actionable breaks',
+    );
+    const text = execFileSync(process.execPath, [
+      'scripts/session-bench.mjs', '--trace', trace, '--session', sessionId,
+    ], { cwd: process.cwd(), encoding: 'utf8' });
+    assert.match(text, /compact cache breaks \(actionable\):/);
+    assert.doesNotMatch(text, /compact cache resets \(intentional\):/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});