mixdog 0.9.47 → 0.9.50

package/scripts/provider-toolcall-test.mjs

@@ -53,7 +53,9 @@ import {
 } from '../src/runtime/agent/orchestrator/providers/gemini-cache.mjs';
 import { parseSSEStream as anthropicParseSSEStream } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
 import { _buildRequestBodyForCacheSmoke } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
+import { _test as _anthropicApiKeyTest } from '../src/runtime/agent/orchestrator/providers/anthropic.mjs';
 import { _toAnthropicMessagesForTest } from '../src/runtime/agent/orchestrator/providers/anthropic.mjs';
+import { _test as _anthropicOAuthTest } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
 import {
     EFFORT_BETA_HEADER,
     LEGACY_EFFORT_BUDGET,
@@ -66,9 +68,191 @@ import { buildAnthropicBetaHeaders } from '../src/runtime/agent/orchestrator/pro
 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';
+import { _convertMessagesToResponsesInputForTest } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
 
 // --- Helpers ---------------------------------------------------------------
 
+test('native deferred history normalizes per provider without leaking OpenAI variants to xAI', () => {
+    const nativePayload = {
+        provider: 'openai-oauth',
+        toolReferences: ['mcp__demo__ping'],
+        openaiTools: [{
+            type: 'function',
+            name: 'mcp__demo__ping',
+            defer_loading: true,
+            parameters: { type: 'object', properties: {} },
+        }],
+    };
+    const history = [
+        { role: 'user', content: 'load it' },
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'load-1', name: 'load_tool', arguments: { names: ['mcp__demo__ping'] }, nativeType: 'tool_search_call' }],
+        },
+        { role: 'tool', toolCallId: 'load-1', content: 'Loaded', nativeToolSearch: nativePayload },
+    ];
+    const openai = _convertMessagesToResponsesInputForTest(history);
+    assert.equal(openai[1].type, 'tool_search_call');
+    assert.equal(openai[2].type, 'tool_search_output');
+    assert.equal(openai[2].tools[0].name, 'mcp__demo__ping');
+
+    const xai = _toXaiResponsesInputForTest(history, {
+        xaiResponses: { previousResponseId: 'resp-1', seenMessageCount: 0, model: 'grok-4' },
+    }, { model: 'grok-4' }).input;
+    assert.equal(xai.some((item) => item.type === 'tool_search_call' || item.type === 'tool_search_output'), false);
+    assert.equal(xai[1].type, 'function_call');
+    assert.equal(xai[2].type, 'function_call_output');
+});
+
+test('Anthropic native deferred result retains tool_reference history and defer_loading declarations', () => {
+    const base = [{ name: 'load_tool', description: 'loader', inputSchema: { type: 'object', properties: {} } }];
+    const deferred = { name: 'mcp__demo__ping', description: 'ping', inputSchema: { type: 'object', properties: {} } };
+    const session = {
+        deferredNativeTools: true,
+        deferredToolCatalog: [...base, deferred],
+    };
+    const firstBody = _buildRequestBodyForCacheSmoke(
+        [{ role: 'user', content: 'find ping' }],
+        'claude-sonnet-4-6',
+        base,
+        { session },
+    );
+    assert.equal(firstBody.tools.some((tool) => tool.name === 'mcp__demo__ping'), false);
+    assert.deepEqual(_anthropicApiKeyTest.deferredAnthropicTools(base, [], { session }), []);
+    const history = [
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'load-a1', name: 'load_tool', arguments: { names: ['mcp__demo__ping'] } }],
+        },
+        {
+            role: 'tool',
+            toolCallId: 'load-a1',
+            content: 'Loaded',
+            nativeToolSearch: {
+                provider: 'anthropic-oauth',
+                toolReferences: ['mcp__demo__ping'],
+                openaiTools: [],
+            },
+        },
+    ];
+    const body = _buildRequestBodyForCacheSmoke(history, 'claude-sonnet-4-6', base, { session });
+    const result = body.messages.flatMap((message) => Array.isArray(message.content) ? message.content : [])
+        .find((block) => block.type === 'tool_result');
+    assert.deepEqual(result.content, [{ type: 'tool_reference', tool_name: 'mcp__demo__ping' }]);
+    assert.equal(body.tools.find((tool) => tool.name === 'mcp__demo__ping')?.defer_loading, true);
+    const apiKeyHistory = history.map((message) => (
+        message.nativeToolSearch
+            ? { ...message, nativeToolSearch: { ...message.nativeToolSearch, provider: 'anthropic' } }
+            : message
+    ));
+    const apiKeyDiscovered = _anthropicApiKeyTest.deferredAnthropicTools(base, apiKeyHistory, { session });
+    assert.equal(apiKeyDiscovered.find((tool) => tool.name === 'mcp__demo__ping')?.deferLoading, true);
+    session.deferredDiscoveredTools = ['mcp__demo__ping'];
+    const compacted = _buildRequestBodyForCacheSmoke(
+        [{ role: 'user', content: 'continue after compact' }],
+        'claude-sonnet-4-6',
+        base,
+        { session },
+    );
+    assert.equal(compacted.tools.find((tool) => tool.name === 'mcp__demo__ping')?.defer_loading, true);
+    const apiKeyCompacted = _anthropicApiKeyTest.deferredAnthropicTools(base, [], { session });
+    assert.equal(apiKeyCompacted.find((tool) => tool.name === 'mcp__demo__ping')?.deferLoading, true);
+});
+
+test('Anthropic API-key and OAuth preserve root properties across compound schemas', () => {
+    const properties = {
+        pattern: { type: 'string' },
+        path: { type: 'string' },
+    };
+    const branches = [
+            { required: ['pattern'] },
+            { required: ['path'] },
+    ];
+    for (const compoundKey of ['oneOf', 'anyOf', 'allOf']) {
+        const schema = { type: 'object', properties, [compoundKey]: branches };
+        const expected = { type: 'object', properties };
+        const apiKey = _anthropicApiKeyTest.sanitizeInputSchema(schema, 'grep');
+        const oauth = _anthropicOAuthTest.sanitizeInputSchema(schema, 'grep');
+
+        assert.deepEqual(apiKey, expected, `API-key ${compoundKey}`);
+        assert.deepEqual(oauth, expected, `OAuth ${compoundKey}`);
+        assert.deepEqual(apiKey, oauth, `${compoundKey} parity`);
+    }
+});
+
+test('OpenAI native provider-tag switches keep tool_search call/output paired', () => {
+    const history = [
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'native-pair', name: 'load_tool', arguments: {}, nativeType: 'tool_search_call' }],
+        },
+        {
+            role: 'tool',
+            toolCallId: 'native-pair',
+            content: 'Loaded',
+            nativeToolSearch: {
+                provider: 'openai',
+                toolReferences: ['read'],
+                openaiTools: [{ type: 'function', name: 'read', parameters: { type: 'object', properties: {} } }],
+            },
+        },
+    ];
+    const oauth = _convertMessagesToResponsesInputForTest(history, { nativeToolSearchProvider: 'openai-oauth' });
+    assert.deepEqual(oauth.map((item) => item.type), ['tool_search_call', 'tool_search_output']);
+    history[1].nativeToolSearch.provider = 'openai-oauth';
+    const direct = _convertMessagesToResponsesInputForTest(history, { nativeToolSearchProvider: 'openai' });
+    assert.deepEqual(direct.map((item) => item.type), ['tool_search_call', 'tool_search_output']);
+});
+
+test('Anthropic native provider-tag switches preserve tool_reference and loaded schema bidirectionally', () => {
+    const base = [{ name: 'load_tool', description: 'loader', inputSchema: { type: 'object', properties: {} } }];
+    const deferred = { name: 'mcp__demo__ping', description: 'ping', inputSchema: { type: 'object', properties: {} } };
+    const session = {
+        deferredNativeTools: true,
+        deferredToolCatalog: [...base, deferred],
+    };
+    const history = (provider) => [
+        {
+            role: 'assistant',
+            content: '',
+            toolCalls: [{ id: 'anthropic-family-pair', name: 'load_tool', arguments: { names: ['mcp__demo__ping'] } }],
+        },
+        {
+            role: 'tool',
+            toolCallId: 'anthropic-family-pair',
+            content: 'Loaded deferred tools: mcp__demo__ping',
+            nativeToolSearch: {
+                provider,
+                toolReferences: ['mcp__demo__ping'],
+                openaiTools: [],
+            },
+        },
+    ];
+    const apiKeyToOauth = _buildRequestBodyForCacheSmoke(
+        history('anthropic'),
+        'claude-sonnet-4-6',
+        base,
+        { session },
+    );
+    const oauthResult = apiKeyToOauth.messages
+        .flatMap((message) => Array.isArray(message.content) ? message.content : [])
+        .find((block) => block.type === 'tool_result');
+    assert.deepEqual(oauthResult.content, [{ type: 'tool_reference', tool_name: 'mcp__demo__ping' }]);
+    assert.equal(apiKeyToOauth.tools.find((tool) => tool.name === 'mcp__demo__ping')?.defer_loading, true);
+
+    const oauthHistory = history('anthropic-oauth');
+    const oauthToApiKeyMessages = _toAnthropicMessagesForTest(oauthHistory);
+    const apiKeyResult = oauthToApiKeyMessages
+        .flatMap((message) => Array.isArray(message.content) ? message.content : [])
+        .find((block) => block.type === 'tool_result');
+    assert.deepEqual(apiKeyResult.content, [{ type: 'tool_reference', tool_name: 'mcp__demo__ping' }]);
+    const apiKeyTools = _anthropicApiKeyTest.deferredAnthropicTools(base, oauthHistory, { session });
+    assert.equal(apiKeyTools.find((tool) => tool.name === 'mcp__demo__ping')?.deferLoading, true);
+});
+
 // Wraps an array of Anthropic SSE event objects in a minimal Response-like
 // shape exposing the single `body.getReader()` API that parseSSEStream uses.
 // Each event becomes a `data: <json>` SSE frame, preceded by its `event:` line.
@@ -500,7 +684,7 @@ test('openai-compat/xai Responses: first Grok request after provider switch drop
     assert.deepEqual(input.map((item) => item.role), ['system', 'user', 'user']);
 });
 
-test('openai-oauth Responses: load_tool schema and history stay function_call', () => {
+test('openai-oauth Responses: load_tool uses native tool_search history', () => {
     const loadTool = {
         name: 'load_tool',
         description: 'load tools',
@@ -517,19 +701,51 @@ test('openai-oauth Responses: load_tool schema and history stay function_call',
             content: '',
             toolCalls: [{ id: 'call_load_1', name: 'tool_search', arguments: { names: ['read'] }, nativeType: 'tool_search_call' }],
         },
-        { role: 'tool', toolCallId: 'call_load_1', content: '{}' },
+        {
+            role: 'tool',
+            toolCallId: 'call_load_1',
+            content: 'Loaded deferred tools: read',
+            nativeToolSearch: {
+                provider: 'openai-oauth',
+                toolReferences: ['read'],
+                openaiTools: [{
+                    type: 'function',
+                    name: 'read',
+                    description: 'read',
+                    defer_loading: true,
+                    parameters: { type: 'object', properties: {} },
+                }],
+            },
+        },
     ], 'gpt-5.5', [loadTool], {});
-    assert.equal(JSON.stringify(body).includes('tool_search'), false);
-    assert.deepEqual(body.tools?.[0], {
-        type: 'function',
-        name: 'load_tool',
+    assert.equal(JSON.stringify(body).includes('tool_search'), true);
+    assert.deepEqual(body.tools, [{
+        type: 'tool_search',
+        execution: 'client',
         description: loadTool.description,
         parameters: loadTool.inputSchema,
+    }]);
+    const call = body.input.find((item) => item.type === 'tool_search_call');
+    assert.deepEqual(call, {
+        type: 'tool_search_call',
+        call_id: 'call_load_1',
+        execution: 'client',
+        arguments: { names: ['read'] },
+    });
+    const output = body.input.find((item) => item.type === 'tool_search_output' && item.call_id === 'call_load_1');
+    assert.deepEqual(output, {
+        type: 'tool_search_output',
+        call_id: 'call_load_1',
+        status: 'completed',
+        execution: 'client',
+        tools: [{
+            type: 'function',
+            name: 'read',
+            description: 'read',
+            defer_loading: true,
+            parameters: { type: 'object', properties: {} },
+        }],
     });
-    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', () => {
@@ -1432,7 +1648,7 @@ 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', () => {
+test('anthropic-oauth: foreign native references normalize to ordinary tool_result after provider switches', () => {
     const body = _buildRequestBodyForCacheSmoke(
         [
             { role: 'user', content: 'load a tool' },
@@ -1445,7 +1661,7 @@ test('anthropic-oauth: load_tool native references replay as ordinary tool_resul
                 role: 'tool',
                 toolCallId: 'toolu_load_1',
                 content: '{"loaded":["read"]}',
-                nativeToolSearch: { toolReferences: ['read'] },
+                nativeToolSearch: { provider: 'openai-oauth', toolReferences: ['read'] },
             },
         ],
         'claude-opus-4-8',
@@ -1617,6 +1833,55 @@ test('openai oauth ws delta: warmup generate:false does not force request_proper
     }
 });
 
+test('openai oauth ws delta: native tool_search output replays with canonical fields', () => {
+    const prevTransport = process.env.MIXDOG_OAI_TRANSPORT;
+    try {
+        process.env.MIXDOG_OAI_TRANSPORT = 'ws-delta';
+        const baseTools = [{
+            type: 'tool_search',
+            execution: 'client',
+            description: 'load tools',
+            parameters: { type: 'object', properties: {} },
+        }];
+        const output = {
+            type: 'tool_search_output',
+            call_id: 'call_load_1',
+            status: 'completed',
+            execution: 'client',
+            tools: [{ type: 'function', name: 'read', parameters: { type: 'object', properties: {} } }],
+        };
+        const body = {
+            model: 'gpt-5.5',
+            instructions: 'sys',
+            tools: baseTools,
+            prompt_cache_key: 'cache-key',
+            input: [
+                { type: 'message', role: 'user', content: 'load read' },
+                { type: 'tool_search_call', call_id: 'call_load_1', execution: 'client', arguments: { names: ['read'] } },
+                output,
+                { type: 'message', role: 'user', content: 'use read' },
+            ],
+        };
+        const delta = _computeDelta({
+            entry: {
+                lastRequestSansInput: _stableStringify(_sansInput(body)),
+                lastResponseId: 'resp_prev',
+                lastRequestInput: [body.input[0]],
+                lastResponseItems: [body.input[1]],
+            },
+            body,
+        });
+        assert.equal(delta.mode, 'delta');
+        assert.equal(delta.frame.prompt_cache_key, 'cache-key');
+        assert.deepEqual(delta.frame.tools, baseTools);
+        assert.equal(delta.frame.instructions, 'sys');
+        assert.deepEqual(delta.frame.input, [output, body.input[3]]);
+    } finally {
+        if (prevTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
+        else process.env.MIXDOG_OAI_TRANSPORT = prevTransport;
+    }
+});
+
 test('canonical frame: full-frame builder leads with type and preserves codex body key order', () => {
     const body = {
         model: 'gpt-5.5',
@@ -1639,7 +1904,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 chained instructions, overrides input', () => {
+test('canonical frame: delta insert keeps key order and chained instructions, overrides input', () => {
     const body = {
         model: 'gpt-5.5',
         instructions: 'sys',
@@ -1648,8 +1913,8 @@ test('canonical frame: delta insert keeps key order, drops chained instructions,
         text: { verbosity: 'low' },
     };
     const delta = _buildResponseCreateFrame(body, { previousResponseId: 'resp_prev', inputOverride: [{ b: 2 }] });
-    assert.deepEqual(Object.keys(delta), ['type', 'model', 'previous_response_id', 'input', 'tool_choice', 'text']);
-    assert.equal(delta.instructions, undefined);
+    assert.deepEqual(Object.keys(delta), ['type', 'model', 'instructions', 'previous_response_id', 'input', 'tool_choice', 'text']);
+    assert.equal(delta.instructions, 'sys');
     assert.equal(delta.previous_response_id, 'resp_prev');
     assert.deepEqual(delta.input, [{ b: 2 }]);
     // Empty instructions is also dropped in delta mode (server resolves via prev id).

package/scripts/shell-failure-diagnostics-test.mjs

@@ -0,0 +1,211 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { chmodSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { classifyToolFailure } from '../src/runtime/agent/orchestrator/agent-trace-format.mjs';
+import { ExecResult, execShellCommand } from '../src/runtime/agent/orchestrator/tools/shell-command.mjs';
+import { _composeShellFailure, _shellFailureStatus } from '../src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs';
+
+test('shell trace classification uses only the leading status marker', () => {
+  assert.equal(classifyToolFailure(
+    'Error: [shell-run-failed] [exit code: 1]\n\ncommand timed out while parsing an aborted field',
+    'shell',
+  ), 'command-exit');
+  assert.equal(classifyToolFailure(
+    'Error: [shell-run-failed] [signal: SIGKILL]\n\n(no output)',
+    'shell',
+  ), 'process/signal');
+  assert.equal(classifyToolFailure(
+    'Error: [shell-run-failed] [timeout: 500ms signal: SIGTERM cause: timeout]',
+    'shell',
+  ), 'timeout/abort');
+  assert.equal(classifyToolFailure(
+    'Error: [shell-run-failed] [signal: SIGTERM cause: cancellation]',
+    'shell',
+  ), 'timeout/abort');
+  assert.equal(classifyToolFailure(
+    'Error: [shell-run-failed] [signal: SIGKILL cause: output-limit]',
+    'shell',
+  ), 'runtime/failure');
+  assert.equal(classifyToolFailure(
+    '⚠️ destructive command warning\nError: [shell-run-failed] [signal: SIGKILL]',
+    'shell',
+  ), 'process/signal');
+});
+
+test('shell failure rendering preserves actual signals and runtime kill causes', () => {
+  const status = (opts) => _shellFailureStatus(new ExecResult({
+    stdout: '', stderr: '', exitCode: null, taskId: 'test', ...opts,
+  }), 500).statusDetail;
+  assert.match(status({ signal: 'SIGKILL' }), /^\[signal: SIGKILL\]$/);
+  assert.match(status({ signal: 'SIGTERM', killed: true, killCause: 'cancellation' }),
+    /^\[signal: SIGTERM cause: cancellation\]$/);
+  assert.match(status({ signal: 'SIGTERM', killed: true, timedOut: true, killCause: 'timeout' }),
+    /^\[timeout: 500ms signal: SIGTERM cause: timeout\]/);
+  assert.match(status({
+    killed: true,
+    killCause: 'output-capture-error',
+    outputCaptureError: new Error('disk full'),
+  }), /^\[output capture failed cause: output-capture-error signal: SIGKILL\]$/);
+  assert.match(status({ signal: 'SIGKILL', killed: true, killCause: 'output-limit' }),
+    /^\[signal: SIGKILL cause: output-limit\]$/);
+});
+
+test('WMIC rewrite note follows the leading shell failure marker', () => {
+  const rendered = _composeShellFailure(
+    '[shell-run-failed] [exit code: 1]',
+    'Error: ',
+    '[auto-rewrite: deprecated wmic process query -> PowerShell; timeout capped at 30000ms]',
+    '(no output)',
+  );
+  assert.match(rendered, /^Error: \[shell-run-failed\] \[exit code: 1\]\n\[auto-rewrite:/);
+  assert.equal(classifyToolFailure(rendered, 'shell'), 'command-exit');
+});
+
+async function withoutUnhandledProcessFailure(run) {
+  const uncaught = [];
+  const rejected = [];
+  const onUncaught = (err) => uncaught.push(err);
+  const onRejected = (err) => rejected.push(err);
+  process.on('uncaughtException', onUncaught);
+  process.on('unhandledRejection', onRejected);
+  try {
+    const result = await run();
+    await new Promise((resolveTurn) => setImmediate(resolveTurn));
+    assert.deepEqual(uncaught, [], `unexpected uncaught error: ${uncaught[0]?.stack || uncaught[0]}`);
+    assert.deepEqual(rejected, [], `unexpected unhandled rejection: ${rejected[0]?.stack || rejected[0]}`);
+    return result;
+  } finally {
+    process.removeListener('uncaughtException', onUncaught);
+    process.removeListener('unhandledRejection', onRejected);
+  }
+}
+
+function assertSpawnToolFailure(result) {
+  assert.equal(result.failurePhase, 'tool');
+  assert.equal(result.failureReason, 'spawn failed');
+  const status = _shellFailureStatus(result, 1000);
+  assert.equal(status.shellToolFailed, true);
+  const rendered = _composeShellFailure(
+    `[shell-tool-failed] ${status.statusDetail}`,
+    'Error: ',
+    '',
+    result.stderr,
+  );
+  assert.match(rendered, /^Error: \[shell-tool-failed\] \[spawn failed\]/);
+  assert.equal(classifyToolFailure(rendered, 'shell'), 'tool-call/failure');
+}
+
+test('asynchronous ENOENT spawn errors remain shell tool failures', async () => {
+  const missing = await withoutUnhandledProcessFailure(() => execShellCommand({
+    shell: join(tmpdir(), `mixdog-missing-shell-${process.pid}`),
+    shellArg: '-c',
+    command: 'echo unreachable',
+    env: process.env,
+    cwd: process.cwd(),
+    timeoutMs: 1000,
+  }));
+  assertSpawnToolFailure(missing);
+  assert.match(missing.stderr, /ENOENT|not found/i);
+});
+
+test('asynchronous EACCES spawn errors remain shell tool failures', async (t) => {
+  if (process.platform === 'win32') return t.skip('executable-bit case is POSIX-only');
+  const dir = mkdtempSync(join(tmpdir(), 'mixdog-eacces-shell-'));
+  try {
+    const denied = join(dir, 'denied.sh');
+    writeFileSync(denied, '#!/bin/sh\necho unreachable\n');
+    chmodSync(denied, 0o600);
+    const result = await withoutUnhandledProcessFailure(() => execShellCommand({
+      shell: denied,
+      shellArg: '-c',
+      command: 'echo unreachable',
+      env: process.env,
+      cwd: process.cwd(),
+      timeoutMs: 1000,
+    }));
+    assertSpawnToolFailure(result);
+    assert.match(result.stderr, /EACCES|permission denied/i);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('execShellCommand carries cancellation cause alongside process signal', async () => {
+  const controller = new AbortController();
+  const isWindows = process.platform === 'win32';
+  const promise = execShellCommand({
+    shell: isWindows ? (process.env.ComSpec || 'cmd.exe') : '/bin/sh',
+    shellArg: isWindows ? '/c' : '-c',
+    command: isWindows ? 'ping 127.0.0.1 -n 20 > nul' : 'sleep 10',
+    env: process.env,
+    cwd: process.cwd(),
+    timeoutMs: 5000,
+    abortSignal: controller.signal,
+    backgroundOnTimeout: false,
+  });
+  setTimeout(() => controller.abort(), 100);
+  const result = await promise;
+  assert.equal(result.killed, true);
+  assert.equal(result.killCause, 'cancellation');
+  assert.ok(result.signal || process.platform === 'win32');
+});
+
+test('cancellation racing with auto-background adoption is returned as cancelled', async () => {
+  let abortReads = 0;
+  const racingSignal = {
+    get aborted() { abortReads += 1; return abortReads >= 2; },
+    addEventListener() {},
+    removeEventListener() {},
+  };
+  const isWindows = process.platform === 'win32';
+  const result = await execShellCommand({
+    shell: isWindows ? (process.env.ComSpec || 'cmd.exe') : '/bin/sh',
+    shellArg: isWindows ? '/c' : '-c',
+    command: isWindows ? 'ping 127.0.0.1 -n 20 > nul' : 'sleep 10',
+    env: process.env,
+    cwd: process.cwd(),
+    timeoutMs: 5000,
+    abortSignal: racingSignal,
+    autoBackgroundMs: 25,
+    backgroundOnTimeout: false,
+  });
+  assert.equal(result.backgrounded, false);
+  assert.equal(result.killed, true);
+  assert.equal(result.killCause, 'cancellation');
+});
+
+test('tool-failures separates actionable totals while retaining command-exit rows', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'mixdog-tool-failures-test-'));
+  try {
+    const history = join(dir, 'history');
+    mkdirSync(history);
+    const rows = [
+      { ts: 1, tool_name: 'shell', category: 'process/signal', error_first_line: 'SIGKILL' },
+      { ts: 2, tool_name: 'shell', category: 'runtime/failure', error_first_line: 'capture guard' },
+      ...Array.from({ length: 45 }, (_, index) => ({
+        ts: index + 3,
+        tool_name: 'shell',
+        category: 'command-exit',
+        error_first_line: `exit ${index}`,
+      })),
+    ];
+    writeFileSync(join(history, 'tool-failures.jsonl'), `${rows.map(JSON.stringify).join('\n')}\n`);
+    const script = resolve('scripts/tool-failures.mjs');
+    const text = spawnSync(process.execPath, [script, '--data-dir', dir, '--limit', '2'], { encoding: 'utf8' });
+    assert.equal(text.status, 0, text.stderr);
+    assert.match(text.stdout, /actionable failures: 2\/2 shown/);
+    assert.match(text.stdout, /command exits: 2\/45 shown \(retained\)/);
+    assert.equal((text.stdout.match(/^- /gm) || []).length, 4);
+    const json = spawnSync(process.execPath, [script, '--data-dir', dir, '--limit', '2', '--json'], { encoding: 'utf8' });
+    assert.equal(json.status, 0, json.stderr);
+    const report = JSON.parse(json.stdout);
+    assert.deepEqual(report.actionable_failures, { shown: 2, matched: 2 });
+    assert.deepEqual(report.command_exits, { shown: 2, matched: 45 });
+    assert.equal(report.rows.length, 4);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/scripts/smoke-loop.mjs

@@ -58,7 +58,7 @@ function runNode(args, label, timeoutMs = 180_000) {
 function runSmokeAll(iteration) {
   let totalMs = 0;
   const steps = [];
-  for (const script of ['scripts/boot-smoke.mjs', 'scripts/tool-smoke.mjs']) {
+  for (const script of ['scripts/smoke.mjs', 'scripts/boot-smoke.mjs']) {
     const result = runNode([script], `${script} iteration ${iteration}`);
     totalMs += result.ms;
     steps.push({
@@ -161,8 +161,14 @@ while (Date.now() < deadline && iteration < maxIterations) {
   const iterStartedAt = Date.now();
   const smoke = runSmokeAll(iteration);
   smokeTimes.push(smoke.ms);
-  const failure = runNode(['scripts/tool-failures.mjs', '--since', since, '--limit', '1'], `failures iteration ${iteration}`, 60_000);
-  if (!/tool failures:\s+0\/0 shown/.test(failure.stdout)) {
+  const failure = runNode(['scripts/tool-failures.mjs', '--since', since, '--limit', '1', '--json'], `failures iteration ${iteration}`, 60_000);
+  let failureSummary;
+  try {
+    failureSummary = JSON.parse(failure.stdout);
+  } catch {
+    throw new Error(`tool failures returned malformed JSON:\n${failure.stdout}`);
+  }
+  if (failureSummary?.actionable_failures?.matched !== 0) {
     throw new Error(`tool failures appeared after loop start:\n${failure.stdout}`);
   }
   const currentRss = rssMb();