mixdog 0.9.36 → 0.9.38

package/scripts/provider-toolcall-test.mjs

@@ -62,6 +62,8 @@ import {
 } from '../src/runtime/agent/orchestrator/providers/anthropic-effort.mjs';
 import { buildAnthropicBetaHeaders } from '../src/runtime/agent/orchestrator/providers/anthropic-betas.mjs';
 import { PATCH_TOOL_DEFS } from '../src/runtime/agent/orchestrator/tools/patch-tool-defs.mjs';
+import { sendViaHttpSse } from '../src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs';
+import { buildRequestBody as buildOpenAIOAuthRequestBody } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
 
 // --- Helpers ---------------------------------------------------------------
 
@@ -100,6 +102,33 @@ function compatResponsesEventStream(events) {
     };
 }
 
+// Minimal 200-OK Response-like shape for the HTTP/SSE Responses path: frames
+// each event as `event:<type>\ndata:<json>\n\n`, delivered synchronously so the
+// semantic-idle watchdog never arms during the test.
+function httpSseResponse(events) {
+    const encoder = new TextEncoder();
+    const chunks = events.map((e) => encoder.encode(`event: ${e.type}\ndata: ${JSON.stringify(e)}\n\n`));
+    let i = 0;
+    return {
+        status: 200,
+        ok: true,
+        headers: new Map(),
+        body: {
+            getReader() {
+                return {
+                    read() {
+                        return i < chunks.length
+                            ? Promise.resolve({ done: false, value: chunks[i++] })
+                            : Promise.resolve({ done: true, value: undefined });
+                    },
+                    cancel() { return Promise.resolve(); },
+                    releaseLock() {},
+                };
+            },
+        },
+    };
+}
+
 // === 1. openai-compat ======================================================
 // Chat path:      parseToolCalls(choice, label)         openai-compat.mjs:957
 // Responses path: parseResponsesToolCalls(response,...) openai-compat.mjs:972
@@ -220,6 +249,126 @@ test('openai-compat/xai Responses stream: response.completed salvages deferred f
     assert.deepEqual(captured, [{ id: 'fc_1', name: 'read', arguments: { path: 'a' } }]);
 });
 
+// Missing-terminal + partial-tool gate (shared tool-stream-state.mjs tracker):
+// a Responses stream that streams a CUSTOM tool call's input then truncates
+// before response.output_item.done / response.completed. The call never lands
+// in pendingCalls or toolCalls, so the truncation error must be gated as
+// pendingToolUse via the shared active tool-item tracker (activeToolItems),
+// NOT accepted as a text-only partial-final that would drop the in-flight tool.
+test('openai-compat/xai Responses stream: mid custom-tool-input truncation is gated pendingToolUse via shared tracker', async () => {
+    const rejected = await consumeCompatResponsesStream(compatResponsesEventStream([
+        { type: 'response.created', response: { id: 'resp_ct', model: 'grok' } },
+        { type: 'response.output_text.delta', delta: 'partial ' },
+        { type: 'response.output_item.added', item: { type: 'custom_tool_call', id: 'ct_item_1' } },
+        { type: 'response.custom_tool_call_input.delta', item_id: 'ct_item_1', delta: '{"x":' },
+        // stream truncates here: no output_item.done, no response.completed.
+    ]), {
+        label: 'test',
+        parseResponsesToolCalls: compatParseResponsesToolCalls,
+        responseOutputText: () => '',
+        onTextDelta: () => {},
+    }).then(() => null, (e) => e);
+    assert.ok(rejected, 'expected the truncated stream to reject');
+    assert.equal(rejected.streamStalled, true);
+    // The in-flight custom tool must gate partial-final success even though it
+    // never reached pendingCalls/toolCalls — the active tracker carries it.
+    assert.equal(rejected.pendingToolUse, true);
+    assert.equal(rejected.partialContent, 'partial ');
+});
+
+// Precision half of the same tracker: once the tool call fully COMPLETES
+// (output_item.done clears the active item) and text keeps streaming, a later
+// truncation is a plain text-only partial — the tracker having been cleared is
+// what lets pendingToolUse fall back to the real emit/pending state.
+test('openai-compat/xai Responses stream: completed tool then trailing-text truncation clears active tracker', async () => {
+    let emitted = 0;
+    const rejected = await consumeCompatResponsesStream(compatResponsesEventStream([
+        { type: 'response.created', response: { id: 'resp_done', model: 'grok' } },
+        { type: 'response.output_item.added', item: { type: 'custom_tool_call', id: 'ct_done_1' } },
+        { type: 'response.custom_tool_call_input.delta', item_id: 'ct_done_1', delta: '{"x":1}' },
+        { type: 'response.output_item.done', item: { type: 'custom_tool_call', id: 'ct_done_1', name: 'load_tool', input: '{"x":1}' } },
+        { type: 'response.output_text.delta', delta: 'after tool ' },
+        // truncates before response.completed.
+    ]), {
+        label: 'test',
+        parseResponsesToolCalls: compatParseResponsesToolCalls,
+        responseOutputText: () => '',
+        onTextDelta: () => {},
+        onToolCall: () => { emitted += 1; },
+    }).then(() => null, (e) => e);
+    assert.ok(rejected, 'expected the truncated stream to reject');
+    assert.equal(rejected.streamStalled, true);
+    // A tool WAS emitted this turn, so the turn is still unsafe/tool-bearing —
+    // pendingToolUse stays true off the emit state, not a stale active latch.
+    assert.ok(emitted >= 1);
+    assert.equal(rejected.pendingToolUse, true);
+});
+
+// Reviewer fix: function output_item.done must delete the pendingCalls itemId
+// before recomputing toolInFlight — otherwise a fully-completed function call
+// keeps pendingCalls.size > 0 forever, and a later max-output cutoff on trailing
+// text is misclassified as a truncated tool-in-flight stall instead of a clean
+// length completion.
+test('openai-compat/xai Responses stream: completed function call clears pendingCalls so max-output cutoff is clean length', async () => {
+    const out = await consumeCompatResponsesStream(compatResponsesEventStream([
+        { type: 'response.created', response: { id: 'resp_len', model: 'grok' } },
+        { type: 'response.output_item.added', item: { type: 'function_call', id: 'fi_len', name: 'read', call_id: 'fc_len' } },
+        { type: 'response.function_call_arguments.done', item_id: 'fi_len', arguments: '{"path":"a"}' },
+        { type: 'response.output_item.done', item: { type: 'function_call', id: 'fi_len', call_id: 'fc_len', name: 'read', arguments: '{"path":"a"}' } },
+        { type: 'response.incomplete', response: { incomplete_details: { reason: 'max_output_tokens' } } },
+    ]), {
+        label: 'test',
+        parseResponsesToolCalls: compatParseResponsesToolCalls,
+        responseOutputText: () => '',
+    });
+    // The completed call drained pendingCalls + the active tracker, so the
+    // max-output cutoff is a clean length truncation (no in-flight-tool stall).
+    assert.equal(out.stopReason, 'length');
+    assert.deepEqual(out.toolCalls, [{ id: 'fc_len', name: 'read', arguments: { path: 'a' } }]);
+});
+
+// Reviewer fix (HTTP/SSE): a max_output_tokens cutoff while a function call is
+// still in flight (added + partial args, no output_item.done) must NOT mark a
+// clean length completion — the tool arguments were truncated. Mirror compat:
+// throw a stream-stalled pendingToolUse error so the loop gates/retries.
+test('openai-oauth HTTP/SSE Responses: max-output cutoff with function call in flight → stream-stalled pendingToolUse', async () => {
+    const rejected = await sendViaHttpSse({
+        auth: { type: 'openai-direct', apiKey: 'k' },
+        body: { model: 'gpt', tools: [] },
+        useModel: 'gpt',
+        fetchFn: async () => httpSseResponse([
+            { type: 'response.created', response: { id: 'r', model: 'gpt' } },
+            { type: 'response.output_item.added', item: { type: 'function_call', id: 'fi_1', name: 'read', call_id: 'fc_1' } },
+            { type: 'response.function_call_arguments.delta', item_id: 'fi_1', delta: '{"path":' },
+            { type: 'response.incomplete', response: { incomplete_details: { reason: 'max_output_tokens' } } },
+        ]),
+    }).then(() => null, (e) => e);
+    assert.ok(rejected, 'expected the truncated-tool cutoff to reject');
+    assert.equal(rejected.streamStalled, true);
+    assert.equal(rejected.pendingToolUse, true);
+});
+
+// Reviewer fix (HTTP/SSE): function output_item.done must delete pendingCalls[id]
+// before recomputing _toolInFlight — otherwise the completed call keeps
+// pendingCalls.size > 0 and a later max-output cutoff is misread as a truncated
+// tool. A fully-completed call before the cutoff must be a clean length result.
+test('openai-oauth HTTP/SSE Responses: completed function call clears pendingCalls so max-output cutoff is clean length', async () => {
+    const out = await sendViaHttpSse({
+        auth: { type: 'openai-direct', apiKey: 'k' },
+        body: { model: 'gpt', tools: [] },
+        useModel: 'gpt',
+        fetchFn: async () => httpSseResponse([
+            { type: 'response.created', response: { id: 'r', model: 'gpt' } },
+            { type: 'response.output_item.added', item: { type: 'function_call', id: 'fi_1', name: 'read', call_id: 'fc_1' } },
+            { type: 'response.function_call_arguments.done', item_id: 'fi_1', arguments: '{"path":"a"}' },
+            { type: 'response.output_item.done', item: { type: 'function_call', id: 'fi_1', call_id: 'fc_1', name: 'read', arguments: '{"path":"a"}' } },
+            { type: 'response.incomplete', response: { incomplete_details: { reason: 'max_output_tokens' } } },
+        ]),
+    });
+    assert.equal(out.stopReason, 'length');
+    assert.deepEqual(out.toolCalls, [{ id: 'fc_1', name: 'read', arguments: { path: 'a' } }]);
+});
+
 test('openai-compat/xai Responses: freeform apply_patch downgrades to function schema', () => {
     const tools = _toResponsesToolsForTest(PATCH_TOOL_DEFS);
     const patch = tools.find((tool) => tool.name === 'apply_patch');
@@ -229,6 +378,135 @@ test('openai-compat/xai Responses: freeform apply_patch downgrades to function s
     assert.deepEqual(patch.parameters?.required, ['patch']);
 });
 
+test('openai-compat/xai Responses: load_tool downgrades from tool_search to function schema', () => {
+    const loadTool = {
+        name: 'load_tool',
+        description: 'load tools',
+        inputSchema: {
+            type: 'object',
+            properties: { names: { type: 'array', items: { type: 'string' } } },
+        },
+    };
+    const [xaiTool] = _toResponsesToolsForTest([loadTool], { provider: 'xai' });
+    assert.equal(xaiTool.type, 'function');
+    assert.equal(xaiTool.name, 'load_tool');
+    assert.equal(xaiTool.execution, undefined);
+    assert.equal(xaiTool.parameters, loadTool.inputSchema);
+
+    const [openaiTool] = _toResponsesToolsForTest([loadTool], { provider: 'openai' });
+    assert.equal(openaiTool.type, 'tool_search');
+    assert.equal(openaiTool.execution, 'client');
+    assert.equal(openaiTool.name, undefined);
+});
+
+test('openai-compat/xai Responses: load_tool history replays as function_call', () => {
+    const { input } = _toXaiResponsesInputForTest([
+        { role: 'user', content: 'load a tool' },
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'call_load_1', name: 'load_tool', arguments: { names: ['read'] }, nativeType: 'tool_search_call' }],
+        },
+        {
+            role: 'tool',
+            toolCallId: 'call_load_1',
+            content: '{}',
+            nativeToolSearch: { openaiTools: [{ name: 'read' }] },
+        },
+    ], {
+        xaiResponses: {
+            previousResponseId: 'resp_same',
+            seenMessageCount: 0,
+            model: 'grok-4.5',
+        },
+    }, { model: 'grok-4.5' });
+    assert.equal(input.some((item) => item.type === 'tool_search_call'), false);
+    assert.equal(input.some((item) => item.type === 'tool_search_output'), false);
+    const call = input.find((item) => item.type === 'function_call' && item.name === 'load_tool');
+    assert.equal(call.call_id, 'call_load_1');
+    assert.deepEqual(JSON.parse(call.arguments), { names: ['read'] });
+    assert.equal(input.some((item) => item.type === 'function_call_output' && item.call_id === 'call_load_1'), true);
+});
+
+test('openai-compat/xai Responses: model switch drops prior tool transcript history', () => {
+    const { input, previousResponseId, continuationResetReason } = _toXaiResponsesInputForTest([
+        { role: 'system', content: 'sys' },
+        { role: 'user', content: 'before switch' },
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'call_load_1', name: 'load_tool', arguments: { names: ['read'] }, nativeType: 'tool_search_call' }],
+        },
+        { role: 'tool', toolCallId: 'call_load_1', content: '{"loaded":["read"]}' },
+        { role: 'user', content: 'after switch' },
+    ], {
+        xaiResponses: {
+            previousResponseId: 'resp_old',
+            seenMessageCount: 4,
+            model: 'grok-4.20',
+        },
+    }, { model: 'grok-4.5' });
+    assert.equal(previousResponseId, null);
+    assert.equal(continuationResetReason, 'model_changed');
+    const serialized = JSON.stringify(input);
+    assert.equal(serialized.includes('tool_search'), false);
+    assert.equal(serialized.includes('function_call'), false);
+    assert.equal(serialized.includes('function_call_output'), false);
+    assert.deepEqual(input.map((item) => item.role), ['system', 'user', 'user']);
+});
+
+test('openai-compat/xai Responses: first Grok request after provider switch drops prior tool transcript history', () => {
+    const { input, previousResponseId, continuationResetReason } = _toXaiResponsesInputForTest([
+        { role: 'system', content: 'sys' },
+        { role: 'user', content: 'before switch' },
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'call_patch_1', name: 'apply_patch', arguments: { patch: '*** Begin Patch\n*** End Patch\n' } }],
+        },
+        { role: 'tool', toolCallId: 'call_patch_1', content: 'OK' },
+        { role: 'user', content: 'after switch' },
+    ], {}, { model: 'grok-4.5' });
+    assert.equal(previousResponseId, null);
+    assert.equal(continuationResetReason, null);
+    const serialized = JSON.stringify(input);
+    assert.equal(serialized.includes('function_call'), false);
+    assert.equal(serialized.includes('function_call_output'), false);
+    assert.deepEqual(input.map((item) => item.role), ['system', 'user', 'user']);
+});
+
+test('openai-oauth Responses: load_tool schema and history stay function_call', () => {
+    const loadTool = {
+        name: 'load_tool',
+        description: 'load tools',
+        inputSchema: {
+            type: 'object',
+            properties: { names: { type: 'array', items: { type: 'string' } } },
+        },
+    };
+    const body = buildOpenAIOAuthRequestBody([
+        { role: 'system', content: 'sys' },
+        { role: 'user', content: 'load a tool' },
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'call_load_1', name: 'tool_search', arguments: { names: ['read'] }, nativeType: 'tool_search_call' }],
+        },
+        { role: 'tool', toolCallId: 'call_load_1', content: '{}' },
+    ], 'gpt-5.5', [loadTool], {});
+    assert.equal(JSON.stringify(body).includes('tool_search'), false);
+    assert.deepEqual(body.tools?.[0], {
+        type: 'function',
+        name: 'load_tool',
+        description: loadTool.description,
+        parameters: loadTool.inputSchema,
+    });
+    const call = body.input.find((item) => item.type === 'function_call' && item.name === 'load_tool');
+    assert.equal(call.call_id, 'call_load_1');
+    assert.deepEqual(JSON.parse(call.arguments), { names: ['read'] });
+    assert.equal(body.input.some((item) => item.type === 'function_call_output' && item.call_id === 'call_load_1'), true);
+});
+
 test('openai-compat/xai Responses: custom_tool_call history replays as function_call', () => {
     const rawPatch = '*** Begin Patch\n*** Add File: xai-history.txt\n+ok\n*** End Patch\n';
     const { input } = _toXaiResponsesInputForTest([
@@ -239,7 +517,13 @@ test('openai-compat/xai Responses: custom_tool_call history replays as function_
             toolCalls: [{ id: 'call_patch_1', name: 'apply_patch', arguments: { patch: rawPatch }, nativeType: 'custom_tool_call' }],
         },
         { role: 'tool', toolCallId: 'call_patch_1', content: 'OK' },
-    ], null, { model: 'grok-composer-2.5-fast' });
+    ], {
+        xaiResponses: {
+            previousResponseId: 'resp_same',
+            seenMessageCount: 0,
+            model: 'grok-composer-2.5-fast',
+        },
+    }, { model: 'grok-composer-2.5-fast' });
     assert.equal(input.some((item) => item.type === 'custom_tool_call'), false);
     assert.equal(input.some((item) => item.type === 'custom_tool_call_output'), false);
     const call = input.find((item) => item.type === 'function_call' && item.name === 'apply_patch');
@@ -1092,6 +1376,35 @@ test('anthropic effort: sonnet-4-6 uses output_config + effort beta, not thinkin
     assert.ok(beta.includes(EFFORT_BETA_HEADER));
 });
 
+test('anthropic-oauth: load_tool native references replay as ordinary tool_result after model switches', () => {
+    const body = _buildRequestBodyForCacheSmoke(
+        [
+            { role: 'user', content: 'load a tool' },
+            {
+                role: 'assistant',
+                content: '',
+                toolCalls: [{ id: 'toolu_load_1', name: 'load_tool', arguments: { names: ['read'] } }],
+            },
+            {
+                role: 'tool',
+                toolCallId: 'toolu_load_1',
+                content: '{"loaded":["read"]}',
+                nativeToolSearch: { toolReferences: ['read'] },
+            },
+        ],
+        'claude-opus-4-8',
+        [],
+        { effort: 'high' },
+    );
+    const serialized = JSON.stringify(body.messages);
+    assert.equal(serialized.includes('tool_reference'), false);
+    const toolResult = body.messages
+        .flatMap((message) => Array.isArray(message.content) ? message.content : [])
+        .find((block) => block?.type === 'tool_result' && block.tool_use_id === 'toolu_load_1');
+    assert.ok(toolResult);
+    assert.equal(toolResult.content, '{"loaded":["read"]}');
+});
+
 test('anthropic effort: legacy sonnet-4-5 maps effort to thinking budget', () => {
     const model = 'claude-sonnet-4-5-20250514';
     const body = _buildRequestBodyForCacheSmoke(
@@ -1270,7 +1583,7 @@ test('canonical frame: full-frame builder leads with type and preserves codex bo
     assert.equal(frame.previous_response_id, undefined);
 });
 
-test('canonical frame: delta insert keeps key order, drops empty instructions, overrides input', () => {
+test('canonical frame: delta insert keeps key order, drops chained instructions, overrides input', () => {
     const body = {
         model: 'gpt-5.5',
         instructions: 'sys',
@@ -1279,10 +1592,11 @@ test('canonical frame: delta insert keeps key order, drops empty instructions, o
         text: { verbosity: 'low' },
     };
     const delta = _buildResponseCreateFrame(body, { previousResponseId: 'resp_prev', inputOverride: [{ b: 2 }] });
-    assert.deepEqual(Object.keys(delta), ['type', 'model', 'instructions', 'previous_response_id', 'input', 'tool_choice', 'text']);
+    assert.deepEqual(Object.keys(delta), ['type', 'model', 'previous_response_id', 'input', 'tool_choice', 'text']);
+    assert.equal(delta.instructions, undefined);
     assert.equal(delta.previous_response_id, 'resp_prev');
     assert.deepEqual(delta.input, [{ b: 2 }]);
-    // Empty instructions is dropped in delta mode (server resolves via prev id).
+    // Empty instructions is also dropped in delta mode (server resolves via prev id).
     const noInstr = _buildResponseCreateFrame({ ...body, instructions: '' }, { previousResponseId: 'resp_prev', inputOverride: [] });
     assert.deepEqual(Object.keys(noInstr), ['type', 'model', 'previous_response_id', 'input', 'tool_choice', 'text']);
 });
@@ -1328,11 +1642,11 @@ import {
     FULL_RESPONSES_TRANSPORT_CAPS,
 } from '../src/runtime/agent/orchestrator/providers/openai-transport-policy.mjs';
 
-test('transport policy: default (no env) is ws-delta / refs continuation ON', () => {
+test('transport policy: default (no env) is auto WS-first / refs continuation ON / HTTP fallback ON', () => {
     const p = resolveOpenAiTransportPolicy({});
-    assert.equal(p.mode, 'ws-delta');
+    assert.equal(p.mode, 'auto');
     assert.equal(p.transport, 'ws');
-    assert.equal(p.allowHttpFallback, false);
+    assert.equal(p.allowHttpFallback, true);
     assert.deepEqual(p.delta, { force: false, refs: true, optIn: true });
 });
 
@@ -1364,10 +1678,11 @@ test('transport policy: http-sse forces the HTTP transport with delta OFF', () =
     assert.equal(p.delta.optIn, false);
 });
 
-test('transport policy: unknown MIXDOG_OAI_TRANSPORT falls back to default ws-delta', () => {
+test('transport policy: unknown MIXDOG_OAI_TRANSPORT falls back to default auto', () => {
     const p = resolveOpenAiTransportPolicy({ MIXDOG_OAI_TRANSPORT: 'quantum' });
-    assert.equal(p.mode, 'ws-delta');
+    assert.equal(p.mode, 'auto');
     assert.equal(p.transport, 'ws');
+    assert.equal(p.allowHttpFallback, true);
 });
 
 test('response frame builder can omit transport-only stream/background for codex warmup parity', () => {
@@ -1383,7 +1698,7 @@ test('transport policy: mode token aliases normalize', () => {
     assert.equal(_normalizeTransportMode('  ws delta '), 'ws-delta');
     assert.equal(_normalizeTransportMode('http/sse'), 'http-sse');
     assert.equal(_normalizeTransportMode('sse'), 'http-sse');
-    assert.equal(_normalizeTransportMode('auto'), 'ws-delta');
+    assert.equal(_normalizeTransportMode('auto'), 'auto');
     assert.equal(_normalizeTransportMode('official'), null);
     assert.equal(_normalizeTransportMode(''), null);
     assert.equal(_normalizeTransportMode('bogus'), null);
@@ -1472,17 +1787,19 @@ test('responses transport policy: openai direct caps match oauth (both full)', (
     assert.deepEqual(direct.delta, { force: false, refs: true, optIn: true });
 });
 
-test('responses transport policy: xai auto defers (transport=auto, delta OFF, no http fallback)', () => {
+test('responses transport policy: xai auto is WS-first with HTTP fallback', () => {
     const p = resolveResponsesTransportPolicy({}, RESPONSES_TRANSPORT_CAPABILITIES.xai);
-    assert.equal(p.mode, 'ws-delta');
+    assert.equal(p.mode, 'auto');
     assert.equal(p.transport, 'ws');
-    assert.equal(p.allowHttpFallback, false);
+    assert.equal(p.allowHttpFallback, true);
     assert.deepEqual(p.delta, { force: false, refs: true, optIn: true });
 });
 
-test('responses transport policy: explicit auto is a ws-delta compatibility spelling', () => {
+test('responses transport policy: explicit auto is WS-first with HTTP fallback', () => {
     const p = resolveResponsesTransportPolicy({ MIXDOG_OAI_TRANSPORT: 'auto' }, RESPONSES_TRANSPORT_CAPABILITIES.xai);
+    assert.equal(p.mode, 'auto');
     assert.equal(p.transport, 'ws');
+    assert.equal(p.allowHttpFallback, true);
     assert.deepEqual(p.delta, { force: false, refs: true, optIn: true });
 });
 
@@ -1570,11 +1887,13 @@ test('grok-oauth: all Grok models inherit global transport; explicit setting is
 test('responses transport policy: _gateTransportMode down-shifts per capability', () => {
     // delta unsupported → ws-delta collapses to ws-full; others pass through.
     const noDelta = { ws: true, http: true, delta: false };
+    assert.equal(_gateTransportMode('auto', noDelta), 'ws-full');
     assert.equal(_gateTransportMode('ws-delta', noDelta), 'ws-full');
     assert.equal(_gateTransportMode('ws-full', noDelta), 'ws-full');
     assert.equal(_gateTransportMode('http-sse', noDelta), 'http-sse');
     // WS unsupported → WS modes prefer HTTP.
     const httpOnly = { ws: false, http: true, delta: false };
+    assert.equal(_gateTransportMode('auto', httpOnly), 'http-sse');
     assert.equal(_gateTransportMode('ws-full', httpOnly), 'http-sse');
     assert.equal(_gateTransportMode('ws-delta', httpOnly), 'http-sse');
     // HTTP unsupported → http-sse prefers full-frame WS.

package/scripts/recall-bench-cases.json

@@ -4,8 +4,8 @@
   { "id": "period-24h", "label": "period window 24h", "args": { "period": "24h", "limit": 10 }, "expect": "browse" },
   { "id": "period-7d", "label": "period window 7d", "args": { "period": "7d", "limit": 10 }, "expect": "browse" },
   { "id": "scope-all", "label": "all-scope query", "args": { "query": "recall", "projectScope": "all", "limit": 10 }, "expect": "results" },
-  { "id": "recent-dryrun-delta", "label": "recent-work topical: dryrun delta sum", "args": { "query": "드라이런 델타 합산", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["드라이런"], "topN": 5 } },
-  { "id": "recent-remote-singleton", "label": "recent-work topical: remote singleton seat", "args": { "query": "remote 싱글톤 좌석", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["싱글톤"], "topN": 5 } },
-  { "id": "recency-today", "label": "query+period recency: today's work (24h)", "args": { "query": "오늘 진행한 작업", "period": "24h", "limit": 10 }, "expect": { "kind": "results", "recencyOrdered": true } },
+  { "id": "recent-dryrun-delta", "label": "recent-work topical: dryrun delta sum", "args": { "query": "\uB4DC\uB77C\uC774\uB7F0 \uB378\uD0C0 \uD569\uC0B0", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["\uB4DC\uB77C\uC774\uB7F0"], "topN": 5 } },
+  { "id": "recent-remote-singleton", "label": "recent-work topical: remote singleton seat", "args": { "query": "remote \uC2F1\uAE00\uD1A4 \uC88C\uC11D", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["\uC2F1\uAE00\uD1A4"], "topN": 5 } },
+  { "id": "recency-today", "label": "query+period recency: today's work (24h)", "args": { "query": "\uC624\uB298 \uC9C4\uD589\uD55C \uC791\uC5C5", "period": "24h", "limit": 10 }, "expect": { "kind": "results", "recencyOrdered": true } },
   { "id": "xlang-embedding-crash", "label": "cross-language: embedding worker crash (strict topN)", "args": { "query": "embedding worker crash", "limit": 10 }, "expect": { "kind": "results", "topNContains": ["embedding"], "topN": 3 } }
 ]

package/scripts/recall-bench.mjs

@@ -31,7 +31,7 @@ function hasFlag(name) { return process.argv.includes(`--${name}`); }
 const WARN_LATENCY_MS = 3000;
 
 const DEFAULT_CASES = [
-  { id: 'kw-ko', label: 'keyword query (ko)', args: { query: '메모리 재현' }, expect: 'results' },
+  { id: 'kw-ko', label: 'keyword query (ko)', args: { query: '\uBA54\uBAA8\uB9AC \uC7AC\uD604' }, expect: 'results' },
   { id: 'kw-en', label: 'keyword query (en)', args: { query: 'memory recall pipeline' }, expect: 'results' },
   { id: 'short-1tok', label: 'short 1-token query', args: { query: 'recall' }, expect: 'results' },
   { id: 'short-2tok', label: 'short 2-token query', args: { query: 'cycle1 drain' }, expect: 'results' },

package/scripts/recall-quality-cases.json

@@ -1,11 +1,11 @@
 [
-  { "id": "q-kr-recall-phrase", "label": "Korean distinctive phrase: persistent memory", "args": { "query": "영속 메모리" }, "expect": { "kind": "results", "topNContains": ["영속 메모리"], "topN": 5 } },
+  { "id": "q-kr-recall-phrase", "label": "Korean distinctive phrase: persistent memory", "args": { "query": "\uC601\uC18D \uBA54\uBAA8\uB9AC" }, "expect": { "kind": "results", "topNContains": ["\uC601\uC18D \uBA54\uBAA8\uB9AC"], "topN": 5 } },
   { "id": "q-en-recall-pipeline", "label": "English distinctive phrase: recall fast-track builder", "args": { "query": "buildRecallFastTrackQuery" }, "expect": { "kind": "results", "topNContains": ["buildRecallFastTrackQuery"], "topN": 5 } },
   { "id": "q-cycle1-drain", "label": "cycle1 ECONNRESET topic", "args": { "query": "cycle1 ECONNRESET" }, "expect": { "kind": "results", "topNContains": ["cycle1", "ECONNRESET"], "topN": 5 } },
   { "id": "q-recall-general", "label": "bare recall keyword", "args": { "query": "recall" }, "expect": { "kind": "results", "topNContains": ["recall"], "topN": 5 } },
-  { "id": "q-uc4-topic-kr", "label": "UC4 topic query with Korean qualifier", "args": { "query": "recall period last 개선", "limit": 8 }, "expect": { "kind": "results", "topNContains": ["개선"], "topN": 5 } },
-  { "id": "q-recall-improve-kr", "label": "cache improvement topic", "args": { "query": "캐시 개선" }, "expect": { "kind": "results", "topNContains": ["개선"], "topN": 5 } },
-  { "id": "q-fanout-recall-cache", "label": "fan-out array query cache+recall", "args": { "query": ["캐시 개선", "recall"], "limit": 5 }, "expect": { "kind": "results", "topNContains": ["개선", "recall"], "topN": 10 } },
+  { "id": "q-uc4-topic-kr", "label": "UC4 topic query with Korean qualifier", "args": { "query": "recall period last \uAC1C\uC120", "limit": 8 }, "expect": { "kind": "results", "topNContains": ["\uAC1C\uC120"], "topN": 5 } },
+  { "id": "q-recall-improve-kr", "label": "cache improvement topic", "args": { "query": "\uCE90\uC2DC \uAC1C\uC120" }, "expect": { "kind": "results", "topNContains": ["\uAC1C\uC120"], "topN": 5 } },
+  { "id": "q-fanout-recall-cache", "label": "fan-out array query cache+recall", "args": { "query": ["\uCE90\uC2DC \uAC1C\uC120", "recall"], "limit": 5 }, "expect": { "kind": "results", "topNContains": ["\uAC1C\uC120", "recall"], "topN": 10 } },
   { "id": "q-short-2tok-cycle", "label": "short 2-token cycle1 query", "args": { "query": "cycle1 drain", "limit": 8 }, "expect": { "kind": "results", "topNContains": ["cycle1"], "topN": 3 } },
   { "id": "q-recall-scope-project", "label": "project-scoped recall query", "args": { "query": "recall", "cwd": "C:\\Project\\mixdog" , "limit": 10 }, "expect": { "kind": "results", "topNContains": ["recall"], "topN": 5 } }
 ]

package/scripts/recall-usecase-cases.json

@@ -8,10 +8,10 @@
   { "id": "uc3-tod-dated", "label": "UC3 dated time window 2026-07-03 09:00~12:00", "args": { "period": "2026-07-03 09:00~12:00", "limit": 10 }, "expect": "browse" },
   { "id": "uc3-date", "label": "UC3 specific date 2026-07-02", "args": { "period": "2026-07-02", "limit": 10 }, "expect": "browse" },
   { "id": "uc3-range", "label": "UC3 date range 2026-07-01~2026-07-03", "args": { "period": "2026-07-01~2026-07-03", "limit": 10 }, "expect": "browse" },
-  { "id": "uc4-topic", "label": "UC4 topic query", "args": { "query": "recall period last 개선", "limit": 8 }, "expect": "results" },
+  { "id": "uc4-topic", "label": "UC4 topic query", "args": { "query": "recall period last \uAC1C\uC120", "limit": 8 }, "expect": "results" },
   { "id": "uc4-topic-time", "label": "UC4 topic + time window", "args": { "query": "recall", "period": "24h", "limit": 8 }, "expect": "results" },
   { "id": "uc4-topic-tod", "label": "UC4 topic + time-of-day", "args": { "query": "recall", "period": "12:00~15:00", "limit": 8 }, "expect": "results" },
-  { "id": "uc4-fanout", "label": "UC4 fan-out array query", "args": { "query": ["recall 개선", "battle balance"], "limit": 5 }, "expect": "results" },
+  { "id": "uc4-fanout", "label": "UC4 fan-out array query", "args": { "query": ["recall \uAC1C\uC120", "battle balance"], "limit": 5 }, "expect": "results" },
   { "id": "uc5-yesterday", "label": "UC5 calendar yesterday", "args": { "period": "yesterday", "limit": 10 }, "expect": "browse" },
   { "id": "uc5-thisweek", "label": "UC5 calendar this_week", "args": { "period": "this_week", "limit": 10 }, "expect": "browse" },
   { "id": "uc6-category", "label": "UC6 category decision 7d", "args": { "period": "7d", "category": "decision", "limit": 10 }, "expect": "browse" }

package/scripts/session-bench.mjs

@@ -226,11 +226,11 @@ function cacheRatioFromUsage(rows) {
 
 function cacheBreakExplanation(reason) {
   const r = String(reason || '');
-  if (r === 'no_anchor') return 'delta 기준점/previous response 없음';
-  if (r === 'input_prefix_mismatch') return '요청 prefix가 이전 turn과 달라짐';
-  if (r.startsWith('response_output_mismatch')) return '이전 응답 output 체인이 기대값과 다름';
-  if (r === 'cache_key_changed') return 'cache key 변경';
-  return r ? '원인 미분류' : '원인 기록 없음';
+  if (r === 'no_anchor') return 'delta \uAE30\uC900\uC810/previous response \uC5C6\uC74C';
+  if (r === 'input_prefix_mismatch') return '\uC694\uCCAD prefix\uAC00 \uC774\uC804 turn\uACFC \uB2EC\uB77C\uC9D0';
+  if (r.startsWith('response_output_mismatch')) return '\uC774\uC804 \uC751\uB2F5 output \uCCB4\uC778\uC774 \uAE30\uB300\uAC12\uACFC \uB2E4\uB984';
+  if (r === 'cache_key_changed') return 'cache key \uBCC0\uACBD';
+  return r ? '\uC6D0\uC778 \uBBF8\uBD84\uB958' : '\uC6D0\uC778 \uAE30\uB85D \uC5C6\uC74C';
 }
 
 function classifyCacheBreakPhase(row, usageRows, transportRows) {
@@ -1342,27 +1342,27 @@ function buildExecutiveSummary(report) {
   const tools = report.summary.total_tool_ms || 0;
   const total = headers + stream + tools;
   const dominant = [['stream', stream], ['tools', tools], ['headers', headers]].sort((a, b) => b[1] - a[1])[0];
-  lines.push(`주 병목=${dominant[0]} ${fmtMs(dominant[1])}/${fmtMs(total)}; cache=${fmtPct((report.summary.cache_ratio ?? 0) * 100)}; turns=${report.summary.turns}; tools=${report.summary.tool_calls}`);
+  lines.push(`\uC8FC \uBCD1\uBAA9=${dominant[0]} ${fmtMs(dominant[1])}/${fmtMs(total)}; cache=${fmtPct((report.summary.cache_ratio ?? 0) * 100)}; turns=${report.summary.turns}; tools=${report.summary.tool_calls}`);
   if (report.cache.cache_breaks.length) {
     const summary = countBy(report.cache.cache_breaks, (b) => `${b.reason || 'unknown'}/${b.phase || 'unknown'}`).slice(0, 3).map(([k, v]) => `${k}×${v}`).join(', ');
-    lines.push(`캐시 깨짐=${report.cache.cache_breaks.length} (${summary})`);
+    lines.push(`\uCE90\uC2DC \uAE68\uC9D0=${report.cache.cache_breaks.length} (${summary})`);
   }
   if (report.cache.actual_cache_misses?.length) {
     const top = [...report.cache.actual_cache_misses].sort((a, b) => (b.uncached_tokens || 0) - (a.uncached_tokens || 0))[0];
-    lines.push(`실제 캐시 미스=${report.cache.actual_cache_misses.length} (top uncached=${fmtTok(top?.uncached_tokens || 0)})`);
+    lines.push(`\uC2E4\uC81C \uCE90\uC2DC \uBBF8\uC2A4=${report.cache.actual_cache_misses.length} (top uncached=${fmtTok(top?.uncached_tokens || 0)})`);
   }
   if (report.compact?.cache_breaks?.length) {
     const summary = countBy(report.compact.cache_breaks, (b) => `${b.reason || 'unknown'}/${b.phase || 'unknown'}`).slice(0, 3).map(([k, v]) => `${k}×${v}`).join(', ');
-    lines.push(`컴팩트 호출=${report.compact.sessions.length} session, cache reset=${report.compact.cache_breaks.length} (${summary})`);
+    lines.push(`\uCEF4\uD329\uD2B8 \uD638\uCD9C=${report.compact.sessions.length} session, cache reset=${report.compact.cache_breaks.length} (${summary})`);
   }
   if (report.tools.failures.length) {
     const summary = countBy(report.tools.failures, (f) => f.category || f.tool || 'unknown').slice(0, 3).map(([k, v]) => `${k}×${v}`).join(', ');
-    lines.push(`툴 실패=${report.tools.failures.length} (${summary})`);
+    lines.push(`\uD234 \uC2E4\uD328=${report.tools.failures.length} (${summary})`);
   }
   const topGrowth = report.tokens.growth_turns[0];
-  if (topGrowth) lines.push(`토큰 증폭=${topGrowth.agent || '-'} it=${topGrowth.turn_label} promptΔ=${fmtTok(topGrowth.prompt_delta)} out=${fmtTok(topGrowth.output_tokens + topGrowth.thinking_tokens)}`);
+  if (topGrowth) lines.push(`\uD1A0\uD070 \uC99D\uD3ED=${topGrowth.agent || '-'} it=${topGrowth.turn_label} promptΔ=${fmtTok(topGrowth.prompt_delta)} out=${fmtTok(topGrowth.output_tokens + topGrowth.thinking_tokens)}`);
   const topChurn = report.tools.duplicates[0];
-  if (topChurn) lines.push(`툴 헛돎=${topChurn.tool}×${topChurn.count} ${compactText(topChurn.target, 90)}`);
+  if (topChurn) lines.push(`\uD234 \uD5DB\uB3CE=${topChurn.tool}×${topChurn.count} ${compactText(topChurn.target, 90)}`);
   return lines;
 }
 
@@ -1626,7 +1626,7 @@ function renderText(report) {
     if (report.tools.failures.length) {
       lines.push('tool failures:');
       for (const f of report.tools.failures.slice(0, 10)) {
-        lines.push(`- ${f.agent || '-'} it=${f.iteration ?? '-'} ${f.tool || '-'} ${fmtMs(f.tool_ms)} category=${f.category || '-'} reason=${f.reason || 'trace에 상세 stderr/예외 미저장'} result=${Math.round(f.bytes / 1024)}KB/${f.lines}l: ${f.target}`);
+        lines.push(`- ${f.agent || '-'} it=${f.iteration ?? '-'} ${f.tool || '-'} ${fmtMs(f.tool_ms)} category=${f.category || '-'} reason=${f.reason || 'trace\uC5D0 \uC0C1\uC138 stderr/\uC608\uC678 \uBBF8\uC800\uC7A5'} result=${Math.round(f.bytes / 1024)}KB/${f.lines}l: ${f.target}`);
         if (opts.failuresOnly && f.preview) {
           const preview = compactText(f.preview, 700);
           lines.push(`  preview: ${preview}`);