mixdog 0.9.63 → 0.9.64

package/scripts/max-output-recovery-test.mjs

@@ -1,368 +0,0 @@
-#!/usr/bin/env node
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import { agentLoop } from '../src/runtime/agent/orchestrator/session/agent-loop.mjs';
-import { HIDDEN_AGENT_NAMES } from '../src/runtime/agent/orchestrator/session/loop/hidden-agents.mjs';
-
-function queuedProvider(responses, streamed = []) {
-    const sent = [];
-    let index = 0;
-    return {
-        sent,
-        async send(messages, _model, _tools, opts = {}) {
-            sent.push(structuredClone(messages));
-            const response = responses[index++];
-            assert.ok(response, `unexpected provider send ${index}`);
-            if (response instanceof Error) {
-                if (typeof response.partialContent === 'string') {
-                    opts.onTextDelta?.(response.partialContent);
-                    streamed.push(response.partialContent);
-                }
-                throw response;
-            }
-            if (typeof response.content === 'string') {
-                opts.onTextDelta?.(response.content);
-                streamed.push(response.content);
-            }
-            return {
-                usage: { inputTokens: 1, outputTokens: 1 },
-                ...response,
-            };
-        },
-    };
-}
-
-async function run(provider, messages = [{ role: 'user', content: 'answer fully' }], options = {}) {
-    return agentLoop(provider, messages, 'fake-model', [], options.onToolCall, process.cwd(), {
-        onTextDelta: options.onTextDelta,
-        takeAssistantTranscriptMetadata: options.takeAssistantTranscriptMetadata,
-        session: options.session,
-        providerState: options.providerState,
-    });
-}
-
-function persistedAssistantText(messages, result) {
-    const terminal = typeof result.historyContent === 'string' ? result.historyContent : result.content;
-    return [
-        ...messages.filter((message) => message.role === 'assistant').map((message) => message.content),
-        terminal,
-    ].join('');
-}
-
-test('one max-output continuation resumes from preserved partial and returns one complete text', async () => {
-    const streamed = [];
-    const provider = queuedProvider([
-        { content: 'alpha ', stopReason: 'length', truncated: true },
-        { content: 'omega', stopReason: 'end_turn' },
-    ], streamed);
-    const messages = [{ role: 'user', content: 'answer fully' }];
-    const recoveryTranscriptMeta = {
-        at: 1_735_689_600_000,
-        model: 'Fake Model',
-        provider: 'fake-provider',
-        agent: 'Test Workflow',
-    };
-
-    const result = await run(provider, messages, {
-        onTextDelta: () => {},
-        takeAssistantTranscriptMetadata: () => recoveryTranscriptMeta,
-    });
-
-    assert.equal(provider.sent.length, 2);
-    assert.equal(result.content, 'alpha omega');
-    assert.equal(streamed.join(''), result.content);
-    assert.equal(result.historyContent, 'omega');
-    assert.equal(result.maxOutputRecoveryAttempts, 1);
-    assert.equal(result.terminationReason, undefined);
-    assert.deepEqual(provider.sent[1].map((message) => message.role), ['user', 'assistant', 'user']);
-    assert.equal(provider.sent[1][1].content, 'alpha ');
-    assert.deepEqual(provider.sent[1][1].meta?.transcript, recoveryTranscriptMeta);
-    assert.match(provider.sent[1][2].content, /Resume directly/);
-    assert.match(provider.sent[1][2].content, /no apology, no recap/i);
-    assert.equal(persistedAssistantText(messages, result), result.content);
-    assert.equal(messages.some((message) => message.role === 'assistant' && message.content === result.content), false);
-});
-
-test('Gemini MAX_TOKENS ProviderIncompleteError enters the same bounded recovery and aggregates usage', async () => {
-    const streamed = [];
-    const geminiIncomplete = Object.assign(new Error('Gemini response incomplete: finishReason=MAX_TOKENS'), {
-        name: 'ProviderIncompleteError',
-        code: 'PROVIDER_INCOMPLETE',
-        providerIncomplete: true,
-        finishReason: 'MAX_TOKENS',
-        partialContent: 'gemini ',
-        partialToolCalls: undefined,
-        model: 'gemini-test',
-        rawUsage: {
-            promptTokenCount: 10,
-            candidatesTokenCount: 4,
-            thoughtsTokenCount: 1,
-            cachedContentTokenCount: 3,
-        },
-    });
-    const provider = queuedProvider([
-        geminiIncomplete,
-        {
-            content: 'complete',
-            stopReason: 'end_turn',
-            usage: { inputTokens: 1, outputTokens: 2, cachedTokens: 1, promptTokens: 1 },
-        },
-    ], streamed);
-    const messages = [{ role: 'user', content: 'answer fully' }];
-
-    const result = await run(provider, messages, { onTextDelta: () => {} });
-
-    assert.equal(provider.sent.length, 2);
-    assert.equal(result.content, 'gemini complete');
-    assert.equal(streamed.join(''), result.content, 'TUI-facing deltas and final aggregate contain each segment once');
-    assert.deepEqual(
-        {
-            inputTokens: result.usage.inputTokens,
-            outputTokens: result.usage.outputTokens,
-            cachedTokens: result.usage.cachedTokens,
-            promptTokens: result.usage.promptTokens,
-        },
-        { inputTokens: 11, outputTokens: 7, cachedTokens: 4, promptTokens: 11 },
-    );
-    assert.equal(result.lastTurnUsage.outputTokens, 2);
-    assert.equal(provider.sent[1][1].content, 'gemini ');
-});
-
-test('Gemini MAX_TOKENS recovery derives missing prompt usage from total minus output', async () => {
-    const incomplete = Object.assign(new Error('Gemini response incomplete: finishReason=MAX_TOKENS'), {
-        code: 'PROVIDER_INCOMPLETE',
-        providerIncomplete: true,
-        finishReason: 'MAX_TOKENS',
-        partialContent: 'gemini ',
-        rawUsage: {
-            total_token_count: 20,
-            candidates_token_count: 4,
-            thoughts_token_count: 1,
-        },
-    });
-    const result = await run(queuedProvider([
-        incomplete,
-        {
-            content: 'complete',
-            stopReason: 'end_turn',
-            usage: { inputTokens: 1, outputTokens: 2, promptTokens: 1 },
-        },
-    ]), undefined, { onTextDelta: () => {} });
-
-    assert.deepEqual(
-        {
-            inputTokens: result.usage.inputTokens,
-            outputTokens: result.usage.outputTokens,
-            promptTokens: result.usage.promptTokens,
-        },
-        { inputTokens: 16, outputTokens: 7, promptTokens: 16 },
-    );
-});
-
-test('Gemini MAX_TOKENS continuation preserves provider-scoped replay metadata', async () => {
-    const providerMetadata = {
-        gemini: { thoughtParts: [{ text: 'signed thought', thoughtSignature: 'sig-gemini' }] },
-    };
-    const incomplete = Object.assign(new Error('MAX_TOKENS'), {
-        code: 'PROVIDER_INCOMPLETE',
-        providerIncomplete: true,
-        finishReason: 'MAX_TOKENS',
-        partialContent: 'first ',
-        providerMetadata,
-    });
-    const provider = queuedProvider([
-        incomplete,
-        { content: 'second', stopReason: 'end_turn' },
-    ]);
-    await run(provider);
-    assert.deepEqual(provider.sent[1][1].providerMetadata, providerMetadata);
-});
-
-test('Gemini partial-final stall commits signed provider metadata with partial text', async () => {
-    const providerMetadata = {
-        gemini: {
-            thoughtParts: [{ text: 'private', thoughtSignature: 'sig-private' }],
-            textParts: [{ text: 'partial answer', thoughtSignature: 'sig-text' }],
-        },
-    };
-    const stalled = Object.assign(new Error('stalled'), {
-        streamStalled: true,
-        pendingToolUse: false,
-        emittedToolCall: false,
-        partialContent: 'partial answer',
-        providerMetadata,
-    });
-    const messages = [{ role: 'user', content: 'answer' }];
-    const result = await run(queuedProvider([stalled]), messages);
-    assert.equal(result.content, 'partial answer');
-    assert.deepEqual(result.providerMetadata, providerMetadata);
-});
-
-test('pause_turn and Gemini OTHER preserve prior non-empty semantics and do not recover', async () => {
-    for (const stopReason of ['pause_turn', 'OTHER']) {
-        const provider = queuedProvider([{ content: `partial-${stopReason}`, stopReason }]);
-        const result = await run(provider);
-        assert.equal(provider.sent.length, 1, stopReason);
-        assert.equal(result.content, `partial-${stopReason}`, stopReason);
-        assert.equal(result.terminationReason, undefined, stopReason);
-        assert.equal(Object.hasOwn(result, 'historyContent'), false, stopReason);
-    }
-});
-
-test('empty safety refusal gets one context-changing retry, then terminates as refusal', async () => {
-    const provider = queuedProvider([
-        { content: '', stopReason: 'refusal', stopDetails: { category: 'safety' } },
-        { content: '', stopReason: 'refusal', stopDetails: { category: 'safety' } },
-    ]);
-    const messages = [{ role: 'user', content: 'answer fully' }];
-
-    const result = await run(provider, messages);
-
-    assert.equal(provider.sent.length, 2);
-    assert.equal(result.terminationReason, 'refusal');
-    assert.equal(messages.filter((message) => message?.meta?.source === 'refusal-recovery').length, 1);
-    assert.match(provider.sent[1].at(-1).content, /safety classifier/);
-    assert.match(provider.sent[1].at(-1).content, /within policy/);
-});
-
-test('one refusal retry can recover to a normal answer', async () => {
-    const provider = queuedProvider([
-        { content: '', stopReason: 'refusal' },
-        { content: 'compliant answer', stopReason: 'end_turn' },
-    ]);
-
-    const result = await run(provider);
-
-    assert.equal(provider.sent.length, 2);
-    assert.equal(result.content, 'compliant answer');
-    assert.equal(result.terminationReason, undefined);
-});
-
-test('hidden-agent empty refusal gets one retry, then terminates as refusal', async () => {
-    const hiddenAgent = HIDDEN_AGENT_NAMES.values().next().value;
-    assert.ok(hiddenAgent, 'expected at least one configured hidden agent');
-    const provider = queuedProvider([
-        { content: '', stopReason: 'refusal' },
-        { content: '', stopReason: 'refusal' },
-    ]);
-    const messages = [{ role: 'user', content: 'complete the assigned output' }];
-
-    const result = await run(provider, messages, { session: { agent: hiddenAgent } });
-
-    assert.equal(provider.sent.length, 2);
-    assert.equal(result.terminationReason, 'refusal');
-    assert.equal(messages.filter((message) => message?.meta?.source === 'refusal-recovery').length, 1);
-    assert.match(provider.sent[1].at(-1).content, /assigned output within policy/);
-    assert.doesNotMatch(provider.sent[1].at(-1).content, /answer the user/i);
-});
-
-test('non-output ProviderIncompleteError remains an error', async () => {
-    const other = Object.assign(new Error('Gemini response incomplete: finishReason=OTHER'), {
-        code: 'PROVIDER_INCOMPLETE',
-        providerIncomplete: true,
-        finishReason: 'OTHER',
-        partialContent: 'unsafe partial',
-        partialToolCalls: undefined,
-    });
-    await assert.rejects(run(queuedProvider([other])), (error) => error === other);
-});
-
-test('adaptive-thinking replay state is preserved on the partial assistant history turn', async () => {
-    const thinkingBlocks = [{ type: 'thinking', thinking: 'signed thought', signature: 'sig-123' }];
-    const reasoningItems = [{ type: 'reasoning', encrypted_content: 'enc-1' }];
-    const provider = queuedProvider([
-        {
-            content: 'first ',
-            stopReason: 'max_tokens',
-            truncated: true,
-            thinkingBlocks,
-            reasoningItems,
-            reasoningContent: 'display thought',
-        },
-        { content: 'second', stopReason: 'end_turn' },
-    ]);
-
-    const result = await run(provider);
-
-    assert.equal(result.content, 'first second');
-    assert.deepEqual(provider.sent[1][1].thinkingBlocks, thinkingBlocks);
-    assert.deepEqual(provider.sent[1][1].reasoningItems, reasoningItems);
-    assert.equal(provider.sent[1][1].reasoningContent, 'display thought');
-});
-
-test('max-output recovery stops after three continuations and surfaces explicit truncation', async () => {
-    const provider = queuedProvider([
-        { content: 'A', stopReason: 'max_tokens', truncated: true },
-        { content: 'B', stopReason: 'max_tokens', truncated: true },
-        { content: 'C', stopReason: 'max_tokens', truncated: true },
-        { content: 'D', stopReason: 'max_tokens', truncated: true },
-    ]);
-    const messages = [{ role: 'user', content: 'answer fully' }];
-
-    const result = await run(provider, messages);
-
-    assert.equal(provider.sent.length, 4);
-    assert.equal(result.maxOutputRecoveryAttempts, 3);
-    assert.equal(result.terminationReason, 'truncated');
-    assert.match(result.content, /^ABCD/);
-    assert.match(result.content, /remained truncated after 3 continuation attempts/);
-    assert.equal(messages.filter((message) => message?.meta?.source === 'max-output-recovery').length, 3);
-    assert.equal(messages.filter((message) => message.role === 'assistant').length, 3);
-    assert.equal(persistedAssistantText(messages, result), result.content);
-});
-
-test('clean end_turn is unchanged and does not enter recovery', async () => {
-    const provider = queuedProvider([
-        { content: 'clean answer', stopReason: 'end_turn' },
-    ]);
-    const messages = [{ role: 'user', content: 'answer fully' }];
-
-    const result = await run(provider, messages);
-
-    assert.equal(provider.sent.length, 1);
-    assert.equal(result.content, 'clean answer');
-    assert.equal(result.terminationReason, undefined);
-    assert.equal(Object.hasOwn(result, 'historyContent'), false);
-    assert.deepEqual(messages, [{ role: 'user', content: 'answer fully' }]);
-});
-
-test('providerState distinguishes no update from an explicit clear for other providers', async () => {
-    const initial = { otherProvider: { continuation: 'keep' } };
-    const noUpdate = await run(queuedProvider([
-        { content: 'done', stopReason: 'end_turn' },
-    ]), undefined, { providerState: initial });
-    assert.deepEqual(noUpdate.providerState, initial);
-    assert.equal(noUpdate.providerStateUpdated, false);
-
-    const cleared = await run(queuedProvider([
-        { content: 'done', stopReason: 'end_turn', providerState: null },
-    ]), undefined, { providerState: initial });
-    assert.equal(cleared.providerState, null);
-    assert.equal(cleared.providerStateUpdated, true);
-});
-
-test('tool-call turns keep the normal tool execution path', async () => {
-    const provider = queuedProvider([
-        {
-            content: '',
-            stopReason: 'tool_use',
-            toolCalls: [{ id: 'call-1', name: 'unknown_test_tool', arguments: {} }],
-        },
-        { content: 'done', stopReason: 'end_turn' },
-    ]);
-    const batches = [];
-    const messages = [{ role: 'user', content: 'use a tool' }];
-
-    const result = await run(provider, messages, {
-        onToolCall: (_iteration, calls) => batches.push(calls),
-    });
-
-    assert.equal(provider.sent.length, 2);
-    assert.equal(result.content, 'done');
-    assert.equal(result.toolCallsTotal, 1);
-    assert.equal(result.terminationReason, undefined);
-    assert.equal(Object.hasOwn(result, 'historyContent'), false);
-    assert.equal(batches.length, 1);
-    assert.deepEqual(messages.map((message) => message.role), ['user', 'assistant', 'tool']);
-});

package/scripts/mcp-client-normalization-test.mjs

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { normalizeMcpToolResult } from '../src/runtime/agent/orchestrator/mcp/client.mjs';
-import { classifyResultKind } from '../src/runtime/agent/orchestrator/session/result-classification.mjs';
-import { normalizeToolEnvelope } from '../src/runtime/agent/orchestrator/session/tool-envelope.mjs';
-
-test('isError:true plain MCP text receives one canonical Error: prefix', () => {
-    const result = normalizeMcpToolResult({
-        content: [{ type: 'text', text: 'connection refused' }],
-        isError: true,
-    });
-    assert.equal(result, 'Error: connection refused');
-    assert.equal(classifyResultKind(result), 'error');
-});
-
-test('isError:true already-prefixed MCP text is unchanged', () => {
-    const result = normalizeMcpToolResult({
-        content: [{ type: 'text', text: 'Error: connection refused' }],
-        isError: true,
-    });
-    assert.equal(result, 'Error: connection refused');
-});
-
-test('absent or false isError leaves MCP text untouched', () => {
-    for (const isError of [undefined, false]) {
-        const result = normalizeMcpToolResult({
-            content: [{ type: 'text', text: 'search complete' }],
-            ...(isError === undefined ? {} : { isError }),
-        });
-        assert.equal(result, 'search complete');
-        assert.equal(classifyResultKind(result), 'normal');
-    }
-});
-
-test('isError:false Error:-leading MCP text stays untouched and normal', () => {
-    const returned = normalizeMcpToolResult({
-        content: [{ type: 'text', text: 'Error: quoted search result' }],
-        isError: false,
-    });
-    const normalized = normalizeToolEnvelope(returned);
-    assert.equal(normalized.result, 'Error: quoted search result');
-    assert.equal(normalized.explicitSuccess, true);
-    assert.equal(classifyResultKind(normalized.result, normalized.explicitSuccess), 'normal');
-});

package/scripts/mcp-grace-deferred-test.mjs

@@ -1,225 +0,0 @@
-// Regression tests for turn-time deferred-manifest construction (claude-code
-// style). An MCP server that finishes its handshake BETWEEN session-create and
-// the user's FIRST send is folded — on the first turn, synchronously, with no
-// boot await — into the INITIAL <available-deferred-tools> manifest (BP1) and
-// pre-marked announced, so the first-turn tool-catalog reconcile emits NO late
-// <system-reminder> for it. A server that connects AFTER the first turn keeps
-// the append-only late-reminder path. Unit-style: exercise the tool-catalog
-// exports directly (no runtime, no spawn) the way session-turn-api/runtime-core
-// wire them.
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import {
-    applyDeferredToolSurface,
-    rebuildDeferredToolSurfaceForProvider,
-    refreshInitialDeferredMcpSurface,
-    reconcileDeferredMcpToolCatalog,
-} from '../src/session-runtime/tool-catalog.mjs';
-
-function baseSession(provider = 'anthropic-oauth') {
-    return {
-        provider,
-        tools: [{ name: 'read', description: 'read a file' }, { name: 'grep', description: 'search' }],
-        messages: [{ role: 'system', content: 'BASE PROMPT' }],
-    };
-}
-
-// A freshly-created session: the create-time surface is baked WITHOUT any MCP
-// (server still mid-handshake at create). `shell` is a deferred (non-active)
-// standalone tool so BP1 carries a manifest block even before MCP arrives.
-function createdSession(provider = 'anthropic-oauth') {
-    const session = baseSession(provider);
-    applyDeferredToolSurface(session, 'full', [{ name: 'shell', description: 'run a command' }], { provider: session.provider });
-    return session;
-}
-
-function systemContent(session) {
-    return session.messages.find((m) => m.role === 'system').content;
-}
-
-const mcpTool = { name: 'mcp__unity__get_scene', description: 'Return the active Unity scene graph.' };
-const mcpTool2 = { name: 'mcp__unity__run_tests', description: 'Run the Unity test runner.' };
-
-// Mirror the session-turn-api first-turn gate: refresh runs ONCE, only for a
-// session flagged fresh (deferredInitialRefreshPending) at create; a resumed
-// session (reloaded transcript, flag absent) takes the late-reconcile path and
-// its already-baked BP1 is never rebuilt or re-announced.
-function firstTurnGate(session, liveMcp) {
-    if (session.deferredInitialRefreshPending) {
-        session.deferredInitialRefreshPending = false;
-        return refreshInitialDeferredMcpSurface(session, liveMcp) ? 'refreshed' : 'refresh-noop';
-    }
-    return 'late';
-}
-
-test('MCP connecting between session-create and first send lands in the INITIAL manifest, not a late reminder', () => {
-    const session = createdSession();
-    assert.ok(!systemContent(session).includes('mcp__unity__get_scene'), 'MCP absent from create-time BP1');
-
-    // First-turn refresh: the live registry now includes the connected server.
-    const changed = refreshInitialDeferredMcpSurface(session, [mcpTool]);
-    assert.equal(changed, true, 'first-turn refresh folded the newly-connected MCP tool');
-
-    const sys = systemContent(session);
-    assert.ok(sys.includes('<available-deferred-tools>'), 'manifest block present');
-    assert.ok(sys.includes('mcp__unity__get_scene'), 'MCP tool in the INITIAL manifest');
-    assert.ok(session.deferredAnnouncedTools.includes('mcp__unity__get_scene'), 'MCP tool pre-marked announced');
-
-    let enqueued = null;
-    const result = reconcileDeferredMcpToolCatalog(session, [mcpTool], {
-        enqueue: (text) => { enqueued = text; return true; },
-    });
-    assert.equal(result, null, 'no late-tool announcement for a first-turn-folded tool');
-    assert.equal(enqueued, null, 'nothing enqueued for a first-turn-folded tool');
-});
-
-test('an MCP server connecting AFTER the first turn is still announced via the late reminder', () => {
-    const session = createdSession();
-    // First turn: no MCP connected yet — nothing to fold.
-    assert.equal(refreshInitialDeferredMcpSurface(session, []), false, 'no live MCP => first-turn no-op');
-    assert.ok(!(session.deferredAnnouncedTools || []).includes('mcp__unity__get_scene'), 'MCP not pre-announced');
-
-    // A later turn: the server has since connected → late path fires.
-    let enqueued = null;
-    const result = reconcileDeferredMcpToolCatalog(session, [mcpTool], {
-        enqueue: (text) => { enqueued = text; return true; },
-    });
-    assert.deepEqual(result, ['mcp__unity__get_scene'], 'late tool announced');
-    assert.ok(enqueued && enqueued.includes('mcp__unity__get_scene'), 'late reminder enqueued');
-    assert.ok(enqueued.includes('connected after this session started'), 'reminder carries the late-tool sentinel');
-});
-
-test('recreated session (MCP already connected at create) seeds its manifest, no late re-announce', () => {
-    // Recreate/reset path: createCurrentSession folds the live MCP tools into the
-    // surface at create time, so a cwd-change recreate seeds its BP1 directly and
-    // never needs the first-turn refresh.
-    const session = baseSession();
-    applyDeferredToolSurface(session, 'full', [{ name: 'shell', description: 'run a command' }, mcpTool], { provider: session.provider });
-    assert.ok(systemContent(session).includes('mcp__unity__get_scene'), 'MCP in recreated BP1');
-    assert.ok(session.deferredAnnouncedTools.includes('mcp__unity__get_scene'), 'recreated MCP pre-marked announced');
-
-    let enqueued = null;
-    const result = reconcileDeferredMcpToolCatalog(session, [mcpTool], {
-        enqueue: (text) => { enqueued = text; return true; },
-    });
-    assert.equal(result, null, 'no late announcement on recreate');
-    assert.equal(enqueued, null, 'nothing enqueued on recreate');
-});
-
-test('first-turn refresh is idempotent: a re-render with no new MCP is a no-op and keeps ONE manifest block', () => {
-    const session = createdSession();
-    assert.equal(refreshInitialDeferredMcpSurface(session, [mcpTool]), true, 'first fold applies');
-    const once = systemContent(session);
-    assert.equal(refreshInitialDeferredMcpSurface(session, [mcpTool]), false, 'no genuinely-new MCP => no-op');
-    const twice = systemContent(session);
-    assert.equal(once, twice, 'BP1 byte-identical on re-render');
-    assert.equal((twice.match(/<available-deferred-tools>/g) || []).length, 1, 'exactly one manifest block (no duplicate)');
-});
-
-test('a second newly-connected MCP tool re-renders BP1 in place (both listed, still one block)', () => {
-    const session = createdSession();
-    refreshInitialDeferredMcpSurface(session, [mcpTool]);
-    assert.equal(refreshInitialDeferredMcpSurface(session, [mcpTool, mcpTool2]), true, 're-fold applies the new tool');
-    const sys = systemContent(session);
-    assert.ok(sys.includes('mcp__unity__get_scene') && sys.includes('mcp__unity__run_tests'), 'both MCP tools listed');
-    assert.equal((sys.match(/<available-deferred-tools>/g) || []).length, 1, 'still exactly one block (rebuilt in place)');
-    assert.ok(session.deferredAnnouncedTools.includes('mcp__unity__run_tests'), 'the new tool is pre-announced too');
-});
-
-test('a resumed session (no fresh flag, prior baked BP1) is NOT refreshed on its next turn', () => {
-    // A prior run baked BP1 with the MCP tool; resume reloads that transcript.
-    const session = baseSession();
-    applyDeferredToolSurface(session, 'full', [{ name: 'shell', description: 'run a command' }, mcpTool], { provider: session.provider });
-    const before = systemContent(session);
-    const announcedBefore = [...session.deferredAnnouncedTools];
-    // Resume path never sets the per-session fresh flag.
-    assert.equal(session.deferredInitialRefreshPending, undefined, 'resumed session carries no fresh flag');
-    const route = firstTurnGate(session, [mcpTool, mcpTool2]);
-    assert.equal(route, 'late', 'resumed session takes the late-reconcile path, not the initial refresh');
-    assert.equal(systemContent(session), before, 'BP1 untouched on resume (no rebuild)');
-    assert.deepEqual([...session.deferredAnnouncedTools], announcedBefore, 'announced set unchanged on resume');
-});
-
-test('fresh-session refresh state is isolated, one-shot, and survives provider switches without leaking', () => {
-    const refreshedSession = createdSession();
-    const noOpSession = createdSession();
-    refreshedSession.deferredInitialRefreshPending = true;
-    noOpSession.deferredInitialRefreshPending = true;
-
-    assert.equal(firstTurnGate(refreshedSession, [mcpTool]), 'refreshed', 'fresh session refreshes on its first turn');
-    assert.equal(refreshedSession.deferredInitialRefreshPending, false, 'fresh flag consumed (one-shot)');
-    assert.equal(noOpSession.deferredInitialRefreshPending, true, 'consuming one session does not consume another');
-    assert.ok(refreshedSession.deferredAnnouncedTools.includes('mcp__unity__get_scene'), 'first-turn MCP pre-announced');
-    assert.ok(!noOpSession.deferredAnnouncedTools.includes('mcp__unity__get_scene'), 'announced state does not leak between sessions');
-    assert.equal(firstTurnGate(refreshedSession, [mcpTool2]), 'late', 'second turn no longer refreshes');
-
-    rebuildDeferredToolSurfaceForProvider(noOpSession, 'xai');
-    noOpSession.provider = 'xai';
-    const beforeNoOp = systemContent(noOpSession);
-    assert.equal(beforeNoOp.includes('<available-deferred-tools>'), false, 'canonical switch removes native manifest state');
-    assert.equal(firstTurnGate(noOpSession, []), 'refresh-noop', 'canonical provider consumes an empty one-shot without a manifest refresh');
-    assert.equal(noOpSession.deferredInitialRefreshPending, false, 'no-op also consumes the fresh flag');
-    assert.equal(systemContent(noOpSession), beforeNoOp, 'canonical no-op leaves the initial manifest byte-identical');
-
-    rebuildDeferredToolSurfaceForProvider(noOpSession, 'anthropic-oauth');
-    noOpSession.provider = 'anthropic-oauth';
-    assert.equal(firstTurnGate(noOpSession, [mcpTool2]), 'late', 'switching back cannot resurrect first-turn refresh state');
-    assert.ok(!noOpSession.deferredAnnouncedTools.includes('mcp__unity__run_tests'), 'post-switch tool remains eligible for the late path');
-});
-
-test('legacy canonical snapshot gains a grace-connected MCP tool for the first turn and session lifetime', () => {
-    const session = createdSession('legacy');
-    session.deferredInitialRefreshPending = true;
-    const before = systemContent(session);
-
-    assert.equal(firstTurnGate(session, [mcpTool]), 'refreshed', 'grace fold updates the canonical snapshot');
-    assert.ok(session.tools.some((tool) => tool.name === mcpTool.name), 'tool is provider-visible on the first turn');
-    assert.ok(session.deferredCallableTools.includes(mcpTool.name), 'tool is callable for the session');
-    assert.ok(session.deferredToolCatalog.some((tool) => tool.name === mcpTool.name), 'tool persists in the session catalog');
-    assert.equal(systemContent(session), before, 'canonical refresh does not introduce a native manifest');
-    assert.equal(systemContent(session).includes('<available-deferred-tools>'), false);
-
-    const toolsOnce = JSON.stringify(session.tools);
-    assert.equal(refreshInitialDeferredMcpSurface(session, [mcpTool]), false, 'repeated fold is a no-op');
-    assert.equal(JSON.stringify(session.tools), toolsOnce, 'repeated fold leaves the fixed surface byte-identical');
-    assert.equal(firstTurnGate(session, [mcpTool]), 'late', 'one-shot gate remains consumed');
-});
-
-test('legacy to Anthropic and back preserves grace MCP availability without manifest leakage or duplication', () => {
-    const session = createdSession('legacy');
-    assert.equal(refreshInitialDeferredMcpSurface(session, [mcpTool]), true);
-
-    rebuildDeferredToolSurfaceForProvider(session, 'anthropic-oauth');
-    session.provider = 'anthropic-oauth';
-    assert.ok(session.deferredToolCatalog.some((tool) => tool.name === mcpTool.name), 'native switch retains the MCP catalog entry');
-    assert.ok(systemContent(session).includes(mcpTool.name), 'native switch advertises the retained deferred tool');
-    assert.equal((systemContent(session).match(/<available-deferred-tools>/g) || []).length, 1, 'native switch creates one manifest');
-
-    rebuildDeferredToolSurfaceForProvider(session, 'legacy');
-    session.provider = 'legacy';
-    assert.ok(session.tools.some((tool) => tool.name === mcpTool.name), 'canonical switch restores the MCP tool to the active surface');
-    assert.ok(session.deferredCallableTools.includes(mcpTool.name), 'canonical switch keeps the MCP tool callable');
-    assert.equal(systemContent(session).includes('<available-deferred-tools>'), false, 'native manifest does not leak back to canonical');
-    assert.deepEqual(session.deferredAnnouncedTools, [], 'native announcement state does not leak back to canonical');
-
-    rebuildDeferredToolSurfaceForProvider(session, 'anthropic-oauth');
-    session.provider = 'anthropic-oauth';
-    assert.equal((systemContent(session).match(/<available-deferred-tools>/g) || []).length, 1, 'repeat switch still creates only one manifest');
-});
-
-test('canonical MCP arriving after the first-turn grace keeps the fixed snapshot and emits no late reminder', () => {
-    const session = createdSession('legacy');
-    session.deferredInitialRefreshPending = true;
-    assert.equal(firstTurnGate(session, []), 'refresh-noop');
-    const before = JSON.stringify(session.tools);
-    let enqueued = null;
-
-    const result = reconcileDeferredMcpToolCatalog(session, [mcpTool2], {
-        enqueue: (text) => { enqueued = text; return true; },
-    });
-    assert.equal(result, null, 'canonical reconciliation keeps the create/grace snapshot fixed');
-    assert.equal(JSON.stringify(session.tools), before, 'post-grace MCP does not churn the canonical surface');
-    assert.equal(session.deferredToolCatalog.some((tool) => tool.name === mcpTool2.name), false);
-    assert.equal(enqueued, null, 'canonical provider emits no native late reminder');
-    assert.equal(systemContent(session).includes('<available-deferred-tools>'), false);
-});