mixdog 0.9.151 → 0.9.153

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

@@ -0,0 +1,378 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+    bindAgentDispatchHostCallbacks,
+    buildAgentDispatchAskSessionArgs,
+    makeAgentDispatch,
+    resolveAgentDispatchLiveCallbacks,
+} from './agent-dispatch.mjs';
+
+const preparedSession = Object.freeze({
+    id: 'sess_host_adapt',
+    agent: 'worker',
+    owner: 'agent',
+    model: 'test-model',
+    provider: 'test',
+});
+
+function noopAdmission() {
+    return {
+        async acquire() {
+            return { release: async () => {} };
+        },
+        async runWithLease(_lease, task) {
+            return await task();
+        },
+    };
+}
+
+function lifecycleDispatch({ askSession, brief = true }) {
+    const events = [];
+    const session = {
+        id: 'sess_lifecycle',
+        agent: 'worker',
+        owner: 'agent',
+        model: 'test-model',
+        provider: 'test',
+        status: 'idle',
+        closed: false,
+        tools: [],
+        messages: [],
+    };
+    const dispatch = makeAgentDispatch({
+        agent: 'worker',
+        preset: { provider: 'test', model: 'test-model' },
+        config: { presets: [] },
+        brief,
+        resourceAdmission: noopAdmission(),
+        prepareAgentSession: () => ({ session }),
+        getSession: () => session,
+        updateSessionStatus: async (_id, status) => {
+            events.push(['status', status]);
+            if (session.closed) return false;
+            session.status = status;
+            return true;
+        },
+        closeSession: (_id, reason) => {
+            events.push(['close', reason, session.status]);
+            session.closed = true;
+            session.closeReason = reason;
+            return true;
+        },
+        askSession: async (...args) => {
+            events.push(['ask']);
+            return await askSession(session, ...args);
+        },
+    });
+    return { dispatch, events, session };
+}
+
+test('dispatch live callbacks stay suppressed without a live-text request', () => {
+    const onToolCall = () => {};
+    const onToolResult = () => {};
+    const onStageChange = () => {};
+    const onSessionStart = () => {};
+    const onAssistantMessageCommitted = () => {};
+    const onReasoningDelta = () => {};
+    const resolved = resolveAgentDispatchLiveCallbacks({
+        onToolCall,
+        onToolResult,
+        onStageChange,
+        onSessionStart,
+        onAssistantMessageCommitted,
+        onReasoningDelta,
+    }, {});
+    assert.equal(resolved.liveProjection, false);
+    assert.equal(resolved.callbacks.onToolCall, onToolCall);
+    assert.equal(resolved.callbacks.onStageChange, onStageChange);
+    assert.equal(resolved.callbacks.onSessionStart, onSessionStart);
+    assert.equal(resolved.callbacks.onAssistantMessageCommitted, onAssistantMessageCommitted);
+    assert.equal(resolved.callbacks.onReasoningDelta, onReasoningDelta);
+    assert.equal(resolved.callbacks.onTextDelta, undefined);
+});
+
+test('per-call live-text callbacks win and request liveProjection', () => {
+    const factoryDelta = () => {};
+    const callDelta = () => {};
+    const callReset = async () => true;
+    const resolved = resolveAgentDispatchLiveCallbacks({
+        onTextDelta: factoryDelta,
+        onToolCall: () => {},
+    }, {
+        onTextDelta: callDelta,
+        onTextReset: callReset,
+    });
+    assert.equal(resolved.liveProjection, true);
+    assert.equal(resolved.callbacks.onTextDelta, callDelta);
+    assert.equal(resolved.callbacks.onTextReset, callReset);
+});
+
+test('explicit liveProjection requests streaming even without text callbacks', () => {
+    assert.equal(resolveAgentDispatchLiveCallbacks({ liveProjection: true }, {}).liveProjection, true);
+    assert.equal(resolveAgentDispatchLiveCallbacks({}, { liveProjection: true }).liveProjection, true);
+    assert.equal(resolveAgentDispatchLiveCallbacks({
+        onAssistantText: () => {},
+    }, {}).liveProjection, true);
+});
+
+test('askSession args wrap host callbacks with the prepared session', async () => {
+    const events = [];
+    const compactEvents = [];
+    const host = {
+        onToolCall(session, iteration, calls) { events.push(['tool', session, iteration, calls]); },
+        onTextDelta(session, chunk) { events.push(['delta', session, chunk]); },
+        onTextReset(session, detail) { events.push(['reset', session, detail]); return detail?.chars === 3; },
+        onSessionStart(session) { events.push(['start', session]); },
+        onStageChange(session, stage, detail) { events.push(['stage', session, stage, detail]); },
+        onAssistantText(session, text) { events.push(['asst', session, text]); },
+        onAssistantMessageCommitted(session) { events.push(['commit', session]); },
+        onToolResult(session, message) { events.push(['result', session, message]); },
+        onReasoningDelta(session, chunk) { events.push(['reason', session, chunk]); },
+    };
+    const { onToolCall: positional, askOpts } = buildAgentDispatchAskSessionArgs({
+        interactiveSessionSurface: true,
+        liveProjection: false,
+        onToolCall: host.onToolCall,
+    }, {
+        onTextDelta: host.onTextDelta,
+        onTextReset: host.onTextReset,
+        onSessionStart: host.onSessionStart,
+        onStageChange: host.onStageChange,
+        onAssistantText: host.onAssistantText,
+        onAssistantMessageCommitted: host.onAssistantMessageCommitted,
+        onToolResult: host.onToolResult,
+        onReasoningDelta: host.onReasoningDelta,
+        interactiveSessionSurface: true,
+    }, {
+        onCompactEvent: (event) => compactEvents.push(event),
+        interactiveSessionSurface: true,
+    }, preparedSession);
+
+    assert.equal(askOpts.liveProjection, true);
+    assert.notEqual(askOpts.onTextDelta, host.onTextDelta);
+    assert.equal(Object.hasOwn(askOpts, 'interactiveSessionSurface'), false);
+    assert.equal(Object.hasOwn(askOpts, 'onToolCall'), false);
+
+    askOpts.onSessionStart({ sessionId: 'ignored' });
+    askOpts.onStageChange('streaming', { message: 'hi' });
+    askOpts.onReasoningDelta('think');
+    askOpts.onTextDelta('hello');
+    assert.equal(await askOpts.onTextReset({ chars: 3 }), true);
+    assert.equal(await askOpts.onTextReset({ chars: 99 }), false);
+    askOpts.onAssistantText('hello');
+    askOpts.onAssistantMessageCommitted({ role: 'assistant', content: 'hello' });
+    positional(1, [{ id: 'c1', name: 'read' }]);
+    askOpts.onToolResult({ role: 'tool', toolCallId: 'c1' });
+    askOpts.onCompactEvent({ status: 'ok' });
+
+    assert.deepEqual(events, [
+        ['start', preparedSession],
+        ['stage', preparedSession, 'streaming', { message: 'hi' }],
+        ['reason', preparedSession, 'think'],
+        ['delta', preparedSession, 'hello'],
+        ['reset', preparedSession, { chars: 3 }],
+        ['reset', preparedSession, { chars: 99 }],
+        ['asst', preparedSession, 'hello'],
+        ['commit', preparedSession],
+        ['tool', preparedSession, 1, [{ id: 'c1', name: 'read' }]],
+        ['result', preparedSession, { role: 'tool', toolCallId: 'c1' }],
+    ]);
+    assert.equal(compactEvents.length, 1);
+});
+
+test('silent dispatch askOpts keep liveProjection false', () => {
+    const { onToolCall, askOpts } = buildAgentDispatchAskSessionArgs({}, { prompt: 'hello' }, {}, preparedSession);
+    assert.equal(onToolCall, null);
+    assert.equal(askOpts.liveProjection, false);
+    assert.equal(askOpts.onTextDelta, undefined);
+    assert.equal(askOpts.onSessionStart, undefined);
+    assert.equal(Object.hasOwn(askOpts, 'interactiveSessionSurface'), false);
+});
+
+test('text-reset binding preserves the exact host acknowledgement', async () => {
+    const boundTrue = bindAgentDispatchHostCallbacks({
+        onTextReset: () => true,
+    }, preparedSession);
+    const boundFalse = bindAgentDispatchHostCallbacks({
+        onTextReset: () => false,
+    }, preparedSession);
+    const boundTruthy = bindAgentDispatchHostCallbacks({
+        onTextReset: () => 'yes',
+    }, preparedSession);
+    assert.equal(await boundTrue.onTextReset({ chars: 1 }), true);
+    assert.equal(await boundFalse.onTextReset({ chars: 1 }), false);
+    assert.equal(await boundTruthy.onTextReset({ chars: 1 }), 'yes');
+});
+
+test('makeAgentDispatch prepends the prepared session onto host-shaped callbacks', async () => {
+    const events = [];
+    const session = {
+        id: 'sess_make_dispatch_adapt',
+        agent: 'worker',
+        owner: 'agent',
+        model: 'test-model',
+        provider: 'test',
+        tools: [],
+    };
+    let capturedAskOpts = null;
+    let capturedOnToolCall = null;
+    const dispatch = makeAgentDispatch({
+        agent: 'worker',
+        preset: { provider: 'test', model: 'test-model' },
+        config: { presets: [] },
+        brief: false,
+        resourceAdmission: noopAdmission(),
+        prepareAgentSession: () => ({ session }),
+        updateSessionStatus: async () => {},
+        closeSession: () => {},
+        getSession: () => session,
+        askSession: async (_id, _prompt, _ctx, onToolCall, _cwd, _prefetch, askOpts) => {
+            capturedAskOpts = askOpts;
+            capturedOnToolCall = onToolCall;
+            askOpts.onSessionStart({ sessionId: session.id, agent: 'worker' });
+            askOpts.onStageChange('streaming', { transport: 'test' });
+            askOpts.onReasoningDelta('think');
+            askOpts.onTextDelta('PARTIAL');
+            const acked = await askOpts.onTextReset({ chars: 3 });
+            const rejected = await askOpts.onTextReset({ chars: 99 });
+            events.push(['ack', acked, rejected]);
+            askOpts.onAssistantText('PARTIAL');
+            askOpts.onAssistantMessageCommitted({ role: 'assistant', content: 'PARTIAL' });
+            await onToolCall(2, [{ id: 'c1', name: 'read' }]);
+            askOpts.onToolResult({ role: 'tool', toolCallId: 'c1' });
+            return { content: 'DONE' };
+        },
+        onSessionStart(received) { events.push(['start', received]); },
+        onStageChange(received, stage, detail) { events.push(['stage', received, stage, detail]); },
+        onReasoningDelta(received, chunk) { events.push(['reason', received, chunk]); },
+        onTextDelta(received, chunk) { events.push(['delta', received, chunk]); },
+        onTextReset(received, detail) {
+            events.push(['reset', received, detail]);
+            return detail?.chars === 3;
+        },
+        onAssistantText(received, text) { events.push(['asst', received, text]); },
+        onAssistantMessageCommitted(received) { events.push(['commit', received]); },
+        onToolCall(received, iteration, calls) { events.push(['tool', received, iteration, calls]); },
+        onToolResult(received, message) { events.push(['result', received, message]); },
+    });
+
+    const text = await dispatch({ prompt: 'Reply exactly DONE' });
+    assert.equal(text, 'DONE');
+    assert.equal(capturedAskOpts.liveProjection, true);
+    assert.equal(Object.hasOwn(session, 'interactiveSessionSurface'), false);
+    assert.equal(Object.hasOwn(session, 'liveProjection'), false);
+    assert.notEqual(capturedAskOpts.onTextDelta, dispatch);
+    assert.equal(typeof capturedOnToolCall, 'function');
+    assert.deepEqual(events, [
+        ['start', session],
+        ['stage', session, 'streaming', { transport: 'test' }],
+        ['reason', session, 'think'],
+        ['delta', session, 'PARTIAL'],
+        ['reset', session, { chars: 3 }],
+        ['reset', session, { chars: 99 }],
+        ['ack', true, false],
+        ['asst', session, 'PARTIAL'],
+        ['commit', session],
+        ['tool', session, 2, [{ id: 'c1', name: 'read' }]],
+        ['result', session, { role: 'tool', toolCallId: 'c1' }],
+    ]);
+});
+
+test('makeAgentDispatch silent path does not request live projection', async () => {
+    const session = { id: 'sess_silent', agent: 'worker', owner: 'agent', tools: [] };
+    let capturedAskOpts = null;
+    const dispatch = makeAgentDispatch({
+        agent: 'worker',
+        preset: { provider: 'test', model: 'test-model' },
+        config: { presets: [] },
+        brief: false,
+        resourceAdmission: noopAdmission(),
+        prepareAgentSession: () => ({ session }),
+        updateSessionStatus: async () => {},
+        closeSession: () => {},
+        getSession: () => session,
+        askSession: async (_id, _prompt, _ctx, onToolCall, _cwd, _prefetch, askOpts) => {
+            capturedAskOpts = askOpts;
+            assert.equal(onToolCall, null);
+            return { content: 'ok' };
+        },
+    });
+    assert.equal(await dispatch({ prompt: 'hello' }), 'ok');
+    assert.equal(capturedAskOpts.liveProjection, false);
+    assert.equal(capturedAskOpts.onTextDelta, undefined);
+    assert.equal(capturedAskOpts.onSessionStart, undefined);
+    assert.equal(Object.hasOwn(session, 'interactiveSessionSurface'), false);
+});
+
+test('successful dispatch publishes idle before done tombstoning and preserves brief trimming', async () => {
+    const raw = 'S'.repeat((12 * 1024) + 32);
+    const { dispatch, events, session } = lifecycleDispatch({
+        askSession: async () => ({ content: raw }),
+    });
+
+    const text = await dispatch({ prompt: 'hello' });
+
+    assert.notEqual(text, raw);
+    assert.equal(text.startsWith('S'.repeat(12 * 1024)), true);
+    assert.match(text, /\[TRUNCATED — full answer was/);
+    assert.deepEqual(events, [
+        ['status', 'running'],
+        ['ask'],
+        ['status', 'idle'],
+        ['close', 'ephemeral-done', 'idle'],
+    ]);
+    assert.equal(session.status, 'idle');
+    assert.equal(session.closed, true);
+    assert.equal(session.closeReason, 'ephemeral-done');
+});
+
+test('partial-salvage dispatch publishes idle before done tombstoning and preserves trimming', async () => {
+    const partial = 'P'.repeat((12 * 1024) + 32);
+    const { dispatch, events, session } = lifecycleDispatch({
+        askSession: async (activeSession) => {
+            activeSession.messages.push({ role: 'assistant', content: partial });
+            const error = new Error('deadline');
+            error.salvagePartial = true;
+            throw error;
+        },
+    });
+
+    const text = await dispatch({ prompt: 'hello' });
+
+    assert.notEqual(text, partial);
+    assert.equal(text.startsWith('P'.repeat(12 * 1024)), true);
+    assert.match(text, /\[TRUNCATED — full answer was/);
+    assert.deepEqual(events, [
+        ['status', 'running'],
+        ['ask'],
+        ['status', 'idle'],
+        ['close', 'ephemeral-done', 'idle'],
+    ]);
+    assert.equal(session.status, 'idle');
+    assert.equal(session.closed, true);
+    assert.equal(session.closeReason, 'ephemeral-done');
+});
+
+test('failed dispatch publishes error before error tombstoning and propagates the original error', async () => {
+    const failure = new Error('provider failed');
+    const { dispatch, events, session } = lifecycleDispatch({
+        askSession: async () => {
+            throw failure;
+        },
+    });
+
+    await assert.rejects(
+        dispatch({ prompt: 'hello' }),
+        (error) => error === failure,
+    );
+
+    assert.deepEqual(events, [
+        ['status', 'running'],
+        ['ask'],
+        ['status', 'error'],
+        ['close', 'ephemeral-error', 'error'],
+    ]);
+    assert.equal(session.status, 'error');
+    assert.equal(session.closed, true);
+    assert.equal(session.closeReason, 'ephemeral-error');
+});

package/src/runtime/agent/orchestrator/agent-runtime/session-builder.mjs

@@ -59,6 +59,7 @@ function normalizeAgentCompactionConfig(value = {}) {
  * @param {number}  [opts.maxLoopIterations]
  * @param {string}  [opts.parentSessionId]
  * @param {string|null} [opts.ownerSessionId] - owning Mixdog MCP instance id for statusline isolation
+ * @param {string|null} [opts.visibility] - catalog visibility scope
  * @param {string|null} [opts.mcpScopeId] - owning session-runtime MCP registry scope
  * @returns {{ session: object, effectiveCwd: string|null }}
  */
@@ -77,6 +78,7 @@ export function prepareAgentSession({
     maxLoopIterations,
     parentSessionId,
     ownerSessionId,
+    visibility,
     clientHostPid,
     agentTag,
     cacheKeyOverride,
@@ -115,7 +117,9 @@ export function prepareAgentSession({
         maxLoopIterations: Number.isFinite(effectiveMaxLoopIterations) ? effectiveMaxLoopIterations : undefined,
         sourceType: sourceType || undefined,
         sourceName: sourceName || undefined,
+        parentSessionId: parentSessionId || null,
         ownerSessionId: effectiveOwnerSessionId || null,
+        visibility: visibility || null,
         clientHostPid: clientHostPid || null,
         compaction: compaction || undefined,
         mcpScopeId: mcpScopeId || null,

package/src/runtime/agent/orchestrator/cache-break-trace.mjs

@@ -0,0 +1,109 @@
+import { appendAgentTrace } from './agent-trace.mjs';
+
+const HASH_CHARS = 16;
+
+function cleanText(value, max = 120) {
+    if (value == null || value === '') return null;
+    return String(value).replace(/[\r\n\t]+/g, ' ').slice(0, max);
+}
+
+function cleanHash(value) {
+    const text = cleanText(value, 128);
+    return text ? text.slice(0, HASH_CHARS) : null;
+}
+
+function finiteNumber(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : null;
+}
+
+export function buildCacheBreakPayload(record = {}) {
+    const payload = {
+        classification: cleanText(record.classification) || 'unknown',
+        reason: cleanText(record.reason) || 'unknown',
+        source: cleanText(record.source),
+        provider: cleanText(record.provider),
+        model: cleanText(record.model),
+        transport: cleanText(record.transport),
+        intentional_transition: cleanText(record.intentionalTransition),
+        index: finiteNumber(record.index),
+        previous_count: finiteNumber(record.previousCount),
+        next_count: finiteNumber(record.nextCount),
+        previous_hash: cleanHash(record.previousHash),
+        next_hash: cleanHash(record.nextHash),
+        previous_request_prefix_hash: cleanHash(record.previousRequestPrefixHash),
+        next_request_prefix_hash: cleanHash(record.nextRequestPrefixHash),
+        request_prefix_changed: record.requestPrefixChanged === true,
+        cached_tokens: finiteNumber(record.cachedTokens),
+        prompt_tokens: finiteNumber(record.promptTokens),
+        uncached_tokens: finiteNumber(record.uncachedTokens),
+        cache_ratio: finiteNumber(record.cacheRatio),
+        actual_cache_miss: record.actualCacheMiss === true,
+        input_prefix_mismatch_index: finiteNumber(record.inputPrefixMismatchIndex),
+        input_prefix_mismatch_previous_count: finiteNumber(record.inputPrefixMismatchPreviousCount),
+        input_prefix_mismatch_current_count: finiteNumber(record.inputPrefixMismatchCurrentCount),
+        input_prefix_mismatch_expected_type: cleanText(record.inputPrefixMismatchExpectedType),
+        input_prefix_mismatch_expected_hash: cleanHash(record.inputPrefixMismatchExpectedHash),
+        input_prefix_mismatch_actual_type: cleanText(record.inputPrefixMismatchActualType),
+        input_prefix_mismatch_actual_hash: cleanHash(record.inputPrefixMismatchActualHash),
+    };
+    return Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== null));
+}
+
+export function formatCacheBreakLine(record = {}) {
+    const payload = buildCacheBreakPayload(record);
+    const fields = [
+        ['classification', payload.classification],
+        ['reason', payload.reason],
+        ['source', payload.source],
+        ['session', cleanText(record.sessionId, 160)],
+        ['provider', payload.provider],
+        ['model', payload.model],
+        ['iteration', finiteNumber(record.iteration)],
+        ['index', payload.index],
+        ['previousCount', payload.previous_count],
+        ['nextCount', payload.next_count],
+        ['previousHash', payload.previous_hash],
+        ['nextHash', payload.next_hash],
+        ['inputMismatchIndex', payload.input_prefix_mismatch_index],
+        ['intent', payload.intentional_transition],
+        ['cachedTokens', payload.cached_tokens],
+        ['promptTokens', payload.prompt_tokens],
+    ].filter(([, value]) => value !== null && value !== undefined);
+    return `[cache-break] ${fields.map(([key, value]) => (
+        typeof value === 'string' ? `${key}=${JSON.stringify(value)}` : `${key}=${value}`
+    )).join(' ')}`;
+}
+
+export function traceCacheBreak(record = {}, options = {}) {
+    const payload = buildCacheBreakPayload(record);
+    const traceFn = options.traceFn === null
+        ? null
+        : (typeof options.traceFn === 'function' ? options.traceFn : appendAgentTrace);
+    if (traceFn) {
+        try {
+            traceFn({
+                sessionId: record.sessionId || null,
+                iteration: finiteNumber(record.iteration),
+                kind: 'cache_break',
+                classification: payload.classification,
+                reason: payload.reason,
+                source: payload.source || null,
+                provider: payload.provider || null,
+                model: payload.model || null,
+                transport: payload.transport || null,
+                payload,
+            });
+        } catch { /* cache diagnostics never affect provider execution */ }
+    }
+    const explicitStderr = typeof options.stderrFn === 'function';
+    if (options.stderr !== false && (explicitStderr || !process.env.NODE_TEST_CONTEXT)) {
+        try {
+            const write = explicitStderr
+                ? options.stderrFn
+                : (line) => process.stderr.write(line);
+            write(`${formatCacheBreakLine(record)}\n`);
+        } catch { /* cache diagnostics never affect provider execution */ }
+    }
+    return payload;
+}

package/src/runtime/agent/orchestrator/cache-break-trace.test.mjs

@@ -0,0 +1,115 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+    buildCacheBreakPayload,
+    traceCacheBreak,
+} from './cache-break-trace.mjs';
+import {
+    prepareProviderPrefixGuard,
+    ProviderPrefixMutationError,
+} from './session/provider-prefix-guard.mjs';
+
+test('cache-break trace emits structured hashes without message content', () => {
+    const rows = [];
+    const lines = [];
+    const payload = traceCacheBreak({
+        sessionId: 'sess_test',
+        iteration: 2,
+        classification: 'unexpected',
+        reason: 'message_prefix',
+        source: 'browser_snapshot_supersession',
+        provider: 'openai-oauth',
+        model: 'gpt-test',
+        index: 7,
+        previousHash: 'a'.repeat(64),
+        nextHash: 'b'.repeat(64),
+        message: 'must never be logged',
+    }, {
+        traceFn: (row) => rows.push(row),
+        stderrFn: (line) => lines.push(line),
+    });
+    assert.equal(payload.previous_hash, 'a'.repeat(16));
+    assert.equal(payload.next_hash, 'b'.repeat(16));
+    assert.equal(rows[0].kind, 'cache_break');
+    assert.match(lines[0], /reason="message_prefix"/);
+    assert.doesNotMatch(`${JSON.stringify(rows)}${lines.join('')}`, /must never be logged/);
+});
+
+test('provider prefix guard explains unexpected rewrites and intentional compaction', () => {
+    const events = [];
+    const first = prepareProviderPrefixGuard(
+        null,
+        [{ role: 'user', content: 'one' }],
+        { tools: [{ name: 'read' }], nativeTools: [] },
+        { provider: 'openai-oauth', model: 'gpt-test' },
+    );
+    assert.throws(
+        () => prepareProviderPrefixGuard(
+            first,
+            [{ role: 'user', content: 'rewritten' }],
+            { tools: [{ name: 'read' }], nativeTools: [] },
+            {
+                provider: 'openai-oauth',
+                model: 'gpt-test',
+                mutationSource: 'test_projection',
+                onCacheBreak: (event) => events.push(event),
+            },
+        ),
+        (error) => error instanceof ProviderPrefixMutationError
+            && error.details.kind === 'message_prefix'
+            && error.details.index === 0,
+    );
+    assert.equal(events[0].classification, 'unexpected');
+    assert.equal(events[0].source, 'test_projection');
+
+    const compactEvents = [];
+    assert.doesNotThrow(() => prepareProviderPrefixGuard(
+        first,
+        [{ role: 'user', content: 'summary' }],
+        { tools: [{ name: 'read' }], nativeTools: [] },
+        {
+            provider: 'openai-oauth',
+            model: 'gpt-test',
+            cacheBreakIntent: 'automatic_compaction',
+            onCacheBreak: (event) => compactEvents.push(event),
+        },
+    ));
+    assert.equal(compactEvents[0].classification, 'intentional');
+    assert.equal(compactEvents[0].reason, 'automatic_compaction');
+});
+
+test('defer_loading tool changes are excluded from Anthropic cache-key diagnostics', () => {
+    const first = prepareProviderPrefixGuard(
+        null,
+        [{ role: 'user', content: 'one' }],
+        { tools: [{ name: 'read' }], nativeTools: [] },
+        { provider: 'anthropic-oauth', model: 'claude-test' },
+    );
+    const events = [];
+    const next = prepareProviderPrefixGuard(
+        first,
+        [{ role: 'user', content: 'one' }],
+        {
+            tools: [
+                { name: 'read' },
+                { name: 'mcp__demo__deferred', deferLoading: true },
+            ],
+            nativeTools: [],
+        },
+        {
+            provider: 'anthropic-oauth',
+            model: 'claude-test',
+            onCacheBreak: (event) => events.push(event),
+        },
+    );
+    assert.equal(next.requestPrefixHash, first.requestPrefixHash);
+    assert.deepEqual(events, []);
+
+    const payload = buildCacheBreakPayload({
+        classification: 'intentional',
+        reason: 'tool_schema_changed',
+        previousHash: 'c'.repeat(64),
+    });
+    assert.equal(payload.previous_hash.length, 16);
+});