mixdog 0.9.50 → 0.9.51

package/scripts/session-bench.mjs

@@ -210,10 +210,27 @@ function cacheBreakExplanation(reason) {
   return r ? '\uC6D0\uC778 \uBBF8\uBD84\uB958' : '\uC6D0\uC778 \uAE30\uB85D \uC5C6\uC74C';
 }
 
+function cacheBreakTransitionTag(row) {
+  const transition = field(row, 'intentional_transition');
+  return typeof transition === 'string' && transition ? transition : null;
+}
+
+function cacheBreakIntentionalTransition(row) {
+  const transition = cacheBreakTransitionTag(row);
+  const reason = field(row, 'reason') || field(row, 'chain_delta_reason') || null;
+  if (transition === 'automatic_compaction' && reason === 'input_prefix_mismatch') return transition;
+  if (transition === 'transcript_rebuild' && reason === 'input_prefix_mismatch') return transition;
+  if (transition === 'explorer_hard_cap_final_tool_choice_none'
+    && reason === 'request_properties_changed'
+    && field(row, 'request_tool_choice') === 'none') return transition;
+  return null;
+}
+
 function classifyCacheBreakPhase(row, usageRows, transportRows) {
   const reason = field(row, 'reason') || field(row, 'chain_delta_reason') || field(row, 'payload')?.reason || null;
   const sid = sessionId(row);
-  if (isCompactSessionId(sid)) return 'intentional_compact';
+  const intentionalTransition = cacheBreakIntentionalTransition(row);
+  if (intentionalTransition) return `intentional_${intentionalTransition}`;
   const ts = Number(row.ts || 0);
   const priorUsage = usageRows.filter((r) => sessionId(r) === sid && Number(r.ts || 0) < ts)
     .sort((a, b) => Number(b.ts || 0) - Number(a.ts || 0));
@@ -397,6 +414,44 @@ function buildCacheDiagnostics(rows) {
     model: field(r, 'model'),
     ts: r.ts,
   }));
+  const cacheBreaks = breaks.map((r) => {
+    const reason = field(r, 'reason') || field(r, 'chain_delta_reason') || field(r, 'payload')?.reason || null;
+    const relatedUsage = nearestRowAround(
+      usage,
+      r.ts,
+      5_000,
+      (u) => sessionId(u) === sessionId(r) && num(u, 'iteration') === num(r, 'iteration'),
+    ) || nearestRowBefore(
+      usage.filter((u) => sessionId(u) === sessionId(r)),
+      r.ts,
+      30_000,
+    );
+    const promptTokens = relatedUsage ? cacheDenom(relatedUsage) : 0;
+    const cachedTokens = relatedUsage ? (num(relatedUsage, 'cached_tokens') || 0) : 0;
+    const transitionTag = cacheBreakTransitionTag(r);
+    const transition = cacheBreakIntentionalTransition(r);
+    return {
+      session_id: sessionId(r),
+      iteration: num(r, 'iteration'),
+      reason,
+      phase: classifyCacheBreakPhase(r, usage, transport),
+      intentional_transition: transitionTag,
+      actionable: !transition,
+      explanation: cacheBreakExplanation(reason),
+      ws_mode: field(r, 'ws_mode'),
+      cache_key_hash: field(r, 'cache_key_hash'),
+      request_tool_choice: field(r, 'request_tool_choice'),
+      request_has_previous_response_id: field(r, 'request_has_previous_response_id'),
+      body_input_items: field(r, 'body_input_items'),
+      frame_input_items: field(r, 'frame_input_items'),
+      prompt_tokens: promptTokens,
+      cached_tokens: cachedTokens,
+      cache_ratio: promptTokens > 0 ? cachedTokens / promptTokens : null,
+      output_tokens: relatedUsage ? (num(relatedUsage, 'output_tokens') || 0) : 0,
+      ts: r.ts,
+    };
+  });
+  const actionableCacheBreaks = cacheBreaks.filter((b) => b.actionable);
   return {
     usage_cache_ratio: cacheRatioFromUsage(usage),
     cached_tokens: sum(usage.map((r) => num(r, 'cached_tokens'))),
@@ -407,38 +462,9 @@ function buildCacheDiagnostics(rows) {
     reused_connection: transport.filter((r) => field(r, 'reused_connection') === true).length,
     previous_response_id: transport.filter((r) => field(r, 'request_has_previous_response_id') === true).length,
     cache_key_hashes: [...keyCounts.entries()].map(([key, count]) => ({ key, count })).sort((a, b) => b.count - a.count),
-    cache_breaks: breaks.map((r) => {
-      const reason = field(r, 'reason') || field(r, 'chain_delta_reason') || field(r, 'payload')?.reason || null;
-      const relatedUsage = nearestRowAround(
-        usage,
-        r.ts,
-        5_000,
-        (u) => sessionId(u) === sessionId(r) && num(u, 'iteration') === num(r, 'iteration'),
-      ) || nearestRowBefore(
-        usage.filter((u) => sessionId(u) === sessionId(r)),
-        r.ts,
-        30_000,
-      );
-      const promptTokens = relatedUsage ? cacheDenom(relatedUsage) : 0;
-      const cachedTokens = relatedUsage ? (num(relatedUsage, 'cached_tokens') || 0) : 0;
-      return {
-        session_id: sessionId(r),
-        iteration: num(r, 'iteration'),
-        reason,
-        phase: classifyCacheBreakPhase(r, usage, transport),
-        explanation: cacheBreakExplanation(reason),
-        ws_mode: field(r, 'ws_mode'),
-        cache_key_hash: field(r, 'cache_key_hash'),
-        request_has_previous_response_id: field(r, 'request_has_previous_response_id'),
-        body_input_items: field(r, 'body_input_items'),
-        frame_input_items: field(r, 'frame_input_items'),
-        prompt_tokens: promptTokens,
-        cached_tokens: cachedTokens,
-        cache_ratio: promptTokens > 0 ? cachedTokens / promptTokens : null,
-        output_tokens: relatedUsage ? (num(relatedUsage, 'output_tokens') || 0) : 0,
-        ts: r.ts,
-      };
-    }),
+    cache_breaks: cacheBreaks,
+    actionable_cache_breaks: actionableCacheBreaks,
+    intentional_cache_breaks: cacheBreaks.filter((b) => !b.actionable),
     actual_cache_misses: misses.map((r) => ({
       session_id: sessionId(r),
       iteration: num(r, 'iteration'),
@@ -1146,6 +1172,18 @@ function buildCompactDiagnostics(rows, selectedIds) {
   };
 }
 
+function selectCacheBreakIssues(rows, limit = 10) {
+  const ordered = [...rows].sort((a, b) => (
+    Number(a.ts || 0) - Number(b.ts || 0)
+    || String(a.session_id || '').localeCompare(String(b.session_id || ''))
+    || Number(a.iteration || 0) - Number(b.iteration || 0)
+  ));
+  const root = ordered.filter((row) => !isCompactSessionId(row.session_id));
+  const compact = ordered.filter((row) => isCompactSessionId(row.session_id));
+  if (!root.length || !compact.length || limit < 2) return ordered.slice(0, limit);
+  return [...root.slice(0, limit - 1), ...compact.slice(0, 1)];
+}
+
 function buildIssues(routeGroups, cache, tools) {
   const issues = [];
   for (const stall of (tools.readonly_stalls || []).slice(0, 10)) {
@@ -1181,7 +1219,7 @@ function buildIssues(routeGroups, cache, tools) {
       issues.push({ severity: 'high', type: 'cache', message: `${g.agent || shortId(g.session_id)} low cache ratio ${fmtPct(g.cache_ratio * 100)}`, session_id: g.session_id });
     }
   }
-  for (const b of cache.cache_breaks.slice(0, 10)) {
+  for (const b of selectCacheBreakIssues(cache.actionable_cache_breaks, 10)) {
     issues.push({ severity: b.reason === 'no_anchor' ? 'medium' : 'high', type: 'cache_break', message: `cache_break ${b.reason || 'unknown'} at it=${b.iteration ?? '-'}`, session_id: b.session_id });
   }
   for (const m of (cache.actual_cache_misses || []).slice(0, 10)) {
@@ -1253,9 +1291,9 @@ function buildWhySlowRankings(report) {
     const summary = countBy(report.tools.failures, (f) => f.category || f.tool || 'unknown').slice(0, 3).map(([k, v]) => `${k}×${v}`).join(', ');
     ranks.push({ score: 50 + report.tools.failures.length, type: 'tool_failures', message: `${report.tools.failures.length} failed tool call(s): ${summary}` });
   }
-  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(', ');
-    ranks.push({ score: 40 + report.cache.cache_breaks.length, type: 'cache_breaks', message: `${report.cache.cache_breaks.length} cache break(s): ${summary}` });
+  if (report.cache.actionable_cache_breaks.length) {
+    const summary = countBy(report.cache.actionable_cache_breaks, (b) => `${b.reason || 'unknown'}/${b.phase || 'unknown'}`).slice(0, 3).map(([k, v]) => `${k}×${v}`).join(', ');
+    ranks.push({ score: 40 + report.cache.actionable_cache_breaks.length, type: 'cache_breaks', message: `${report.cache.actionable_cache_breaks.length} actionable cache break(s): ${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];
@@ -1311,11 +1349,24 @@ function buildReport(rows, selectedIds, failureRows = []) {
   const selected = rows.filter((r) => selectedIds.includes(sessionId(r)));
   const selectedFailures = failureRows.filter((r) => selectedIds.includes(sessionId(r)));
   const routeGroups = buildRouteGroups(selected);
-  const cache = buildCacheDiagnostics(selected);
+  const selectedCache = buildCacheDiagnostics(selected);
   const tools = buildToolDiagnostics(selected, selectedFailures);
   const stages = buildTurnDiagnostics(selected, routeGroups);
   const tokens = buildTokenDiagnostics(stages.turns);
   const compact = buildCompactDiagnostics(rows, selectedIds);
+  // Compact workers are normally sibling sessions rather than direct children,
+  // so their genuine mismatches are absent from `selected`. Promote only those
+  // actionable rows into the root report; intentional compact transitions stay
+  // isolated in compact diagnostics and selected compact children never duplicate.
+  const selectedSessionIds = new Set(selectedIds);
+  const compactActionableBreaks = compact.cache_breaks.filter(
+    (row) => row.actionable && !selectedSessionIds.has(row.session_id),
+  );
+  const cache = {
+    ...selectedCache,
+    cache_breaks: [...selectedCache.cache_breaks, ...compactActionableBreaks],
+    actionable_cache_breaks: [...selectedCache.actionable_cache_breaks, ...compactActionableBreaks],
+  };
   const issues = buildIssues(routeGroups, cache, tools);
   const tsValues = selected.map((r) => Number(r.ts || 0)).filter((n) => n > 0);
   const report = {
@@ -1417,9 +1468,17 @@ function renderText(report) {
         }
       }
     }
-    if (report.compact.cache_breaks.length) {
+    const intentionalCompactBreaks = report.compact.cache_breaks.filter((b) => !b.actionable);
+    const actionableCompactBreaks = report.compact.cache_breaks.filter((b) => b.actionable);
+    if (intentionalCompactBreaks.length) {
       lines.push('compact cache resets (intentional):');
-      for (const b of report.compact.cache_breaks.slice(0, 5)) {
+      for (const b of intentionalCompactBreaks.slice(0, 5)) {
+        lines.push(`- ${shortId(b.session_id)} it=${b.iteration ?? '-'} phase=${b.phase || '-'} reason=${b.reason || '-'} prompt=${fmtTok(b.prompt_tokens)} out=${fmtTok(b.output_tokens)}`);
+      }
+    }
+    if (actionableCompactBreaks.length) {
+      lines.push('compact cache breaks (actionable):');
+      for (const b of actionableCompactBreaks.slice(0, 5)) {
         lines.push(`- ${shortId(b.session_id)} it=${b.iteration ?? '-'} phase=${b.phase || '-'} reason=${b.reason || '-'} prompt=${fmtTok(b.prompt_tokens)} out=${fmtTok(b.output_tokens)}`);
       }
     }
@@ -1458,9 +1517,9 @@ function renderText(report) {
     lines.push(`ws: delta=${report.cache.ws_delta}, full=${report.cache.ws_full}, previous_response_id=${report.cache.previous_response_id}, reused=${report.cache.reused_connection}/${report.cache.transport_count}`);
     if (report.cache.cache_key_hashes.length) lines.push(`cache keys: ${report.cache.cache_key_hashes.slice(0, 5).map((k) => `${k.key}×${k.count}`).join(', ')}`);
     if (report.cache.cache_breaks.length) {
-      lines.push('cache breaks:');
+      lines.push(`cache breaks (raw=${report.cache.cache_breaks.length}, actionable=${report.cache.actionable_cache_breaks.length}):`);
       for (const b of report.cache.cache_breaks.slice(0, 10)) {
-        lines.push(`- ${shortId(b.session_id)} it=${b.iteration ?? '-'} phase=${b.phase || '-'} reason=${b.reason || '-'} (${b.explanation || '-'}) ws=${b.ws_mode || '-'} prev=${b.request_has_previous_response_id} cache=${fmtPct((b.cache_ratio ?? 0) * 100)} prompt=${fmtTok(b.prompt_tokens)} out=${fmtTok(b.output_tokens)} body/frame=${b.body_input_items ?? '-'}/${b.frame_input_items ?? '-'}`);
+        lines.push(`- ${shortId(b.session_id)} it=${b.iteration ?? '-'} ${b.actionable ? 'actionable' : `intentional:${b.intentional_transition}`} phase=${b.phase || '-'} reason=${b.reason || '-'} (${b.explanation || '-'}) ws=${b.ws_mode || '-'} tool_choice=${b.request_tool_choice ?? '-'} prev=${b.request_has_previous_response_id} cache=${fmtPct((b.cache_ratio ?? 0) * 100)} prompt=${fmtTok(b.prompt_tokens)} out=${fmtTok(b.output_tokens)} body/frame=${b.body_input_items ?? '-'}/${b.frame_input_items ?? '-'}`);
       }
     }
     if (report.cache.actual_cache_misses?.length) {

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

@@ -29,6 +29,14 @@ test('shell trace classification uses only the leading status marker', () => {
     'Error: [shell-run-failed] [signal: SIGKILL cause: output-limit]',
     'shell',
   ), 'runtime/failure');
+  assert.equal(classifyToolFailure(
+    'Session "sess_cancelled" closed: aborted during call',
+    'shell',
+  ), 'expected-cancellation');
+  assert.equal(classifyToolFailure(
+    'call aborted',
+    'read',
+  ), 'timeout/abort');
   assert.equal(classifyToolFailure(
     '⚠️ destructive command warning\nError: [shell-run-failed] [signal: SIGKILL]',
     'shell',
@@ -177,7 +185,7 @@ test('cancellation racing with auto-background adoption is returned as cancelled
   assert.equal(result.killCause, 'cancellation');
 });
 
-test('tool-failures separates actionable totals while retaining command-exit rows', () => {
+test('tool-failures excludes session cancellations but retains real abort failures', () => {
   const dir = mkdtempSync(join(tmpdir(), 'mixdog-tool-failures-test-'));
   try {
     const history = join(dir, 'history');
@@ -185,8 +193,17 @@ test('tool-failures separates actionable totals while retaining command-exit row
     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' },
+      { ts: 3, tool_name: 'shell', category: 'timeout/abort', error_first_line: 'Session "sess_cancelled" closed: aborted during call' },
+      {
+        ts: 4,
+        tool_name: 'shell',
+        category: 'timeout/abort',
+        error_first_line: '⚠️ destructive command warning',
+        error_preview: '⚠️ destructive command warning\nSession "sess_warning" closed: aborted during call',
+      },
+      { ts: 5, tool_name: 'shell', category: 'timeout/abort', error_first_line: 'request timed out' },
       ...Array.from({ length: 45 }, (_, index) => ({
-        ts: index + 3,
+        ts: index + 6,
         tool_name: 'shell',
         category: 'command-exit',
         error_first_line: `exit ${index}`,
@@ -196,16 +213,68 @@ test('tool-failures separates actionable totals while retaining command-exit row
     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, /actionable failures: 2\/3 shown/);
     assert.match(text.stdout, /command exits: 2\/45 shown \(retained\)/);
+    assert.doesNotMatch(text.stdout, /aborted during call/);
     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.actionable_failures, { shown: 2, matched: 3 });
     assert.deepEqual(report.command_exits, { shown: 2, matched: 45 });
     assert.equal(report.rows.length, 4);
   } finally {
     rmSync(dir, { recursive: true, force: true });
   }
 });
+
+test('session cancellations remain traceable without entering tool-failures.jsonl', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'mixdog-session-cancellation-test-'));
+  try {
+    const tracePath = join(dir, 'agent-trace.jsonl');
+    const failurePath = join(dir, 'tool-failures.jsonl');
+    const child = spawnSync(process.execPath, ['--input-type=module', '-e', `
+      import { existsSync, readFileSync } from 'node:fs';
+      import { traceAgentTool } from './src/runtime/agent/orchestrator/agent-trace-format.mjs';
+      import { drainAgentTrace } from './src/runtime/agent/orchestrator/agent-trace-io.mjs';
+      traceAgentTool({
+        sessionId: 'sess_cancelled',
+        iteration: 1,
+        toolName: 'read',
+        toolKind: 'function',
+        toolMs: 1,
+        toolArgs: { path: 'ignored' },
+        agent: 'worker',
+        model: 'test',
+        cwd: process.cwd(),
+        resultKind: 'error',
+        resultText: 'Session "sess_cancelled" closed: aborted during call',
+      });
+      await drainAgentTrace();
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      const trace = JSON.parse(readFileSync(process.env.MIXDOG_AGENT_TRACE_PATH, 'utf8').trim());
+      process.stdout.write(JSON.stringify({
+        failureLogExists: existsSync(process.env.MIXDOG_TOOL_FAILURE_LOG_PATH),
+        category: trace.result_error_category,
+      }));
+    `], {
+      cwd: process.cwd(),
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        MIXDOG_AGENT_TRACE_PATH: tracePath,
+        MIXDOG_TOOL_FAILURE_LOG_PATH: failurePath,
+        MIXDOG_AGENT_TRACE_DISABLE: '',
+        MIXDOG_AGENT_TRACE_LOCAL_DISABLE: '',
+        MIXDOG_RUNTIME_ROOT: join(dir, 'no-service'),
+      },
+    });
+    assert.equal(child.status, 0, child.stderr);
+    assert.deepEqual(JSON.parse(child.stdout), {
+      failureLogExists: false,
+      category: 'expected-cancellation',
+    });
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/scripts/smoke-loop-failure-summary-test.mjs

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { actionableFailureCount } from './smoke-loop-failure-summary.mjs';
+
+test('returns a numeric actionable failure count', () => {
+  assert.equal(actionableFailureCount('{"actionable_failures":{"matched":0}}'), 0);
+  assert.equal(actionableFailureCount('{"actionable_failures":{"matched":1}}'), 1);
+});
+
+test('rejects malformed tool-failures JSON', () => {
+  assert.throws(
+    () => actionableFailureCount('{'),
+    /tool failures returned malformed JSON/,
+  );
+});
+
+test('rejects a missing or malformed actionable failure count', () => {
+  assert.throws(
+    () => actionableFailureCount('{}'),
+    /tool failures returned malformed result schema/,
+  );
+  assert.throws(
+    () => actionableFailureCount('{"actionable_failures":{"matched":"0"}}'),
+    /tool failures returned malformed result schema/,
+  );
+  assert.throws(
+    () => actionableFailureCount('{"actionable_failures":{"matched":-1}}'),
+    /tool failures returned malformed result schema/,
+  );
+  assert.throws(
+    () => actionableFailureCount('{"actionable_failures":{"matched":0.5}}'),
+    /tool failures returned malformed result schema/,
+  );
+  assert.throws(
+    () => actionableFailureCount('{"actionable_failures":{"matched":1e999}}'),
+    /tool failures returned malformed result schema/,
+  );
+});

package/scripts/smoke-loop-failure-summary.mjs

@@ -0,0 +1,16 @@
+export function actionableFailureCount(stdout) {
+  let summary;
+  try {
+    summary = JSON.parse(stdout);
+  } catch {
+    throw new Error(`tool failures returned malformed JSON:\n${stdout}`);
+  }
+
+  const matched = summary?.actionable_failures?.matched;
+  if (!Number.isInteger(matched) || matched < 0) {
+    throw new Error(
+      `tool failures returned malformed result schema: expected actionable_failures.matched to be a non-negative integer:\n${stdout}`,
+    );
+  }
+  return matched;
+}

package/scripts/smoke-loop.mjs

@@ -3,6 +3,7 @@ import { appendFileSync, mkdirSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { dirname, isAbsolute, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { actionableFailureCount } from './smoke-loop-failure-summary.mjs';
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const DEFAULT_DURATION_MS = 5 * 60 * 60 * 1000;
@@ -162,13 +163,7 @@ while (Date.now() < deadline && iteration < maxIterations) {
   const smoke = runSmokeAll(iteration);
   smokeTimes.push(smoke.ms);
   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) {
+  if (actionableFailureCount(failure.stdout) > 0) {
     throw new Error(`tool failures appeared after loop start:\n${failure.stdout}`);
   }
   const currentRss = rssMb();

package/scripts/tool-failures.mjs

@@ -95,7 +95,21 @@ const rows = files.flatMap(readRows)
   .filter((row) => !categoryFilter || rowCategory(row) === categoryFilter)
   .sort((a, b) => Number(a.ts || 0) - Number(b.ts || 0));
 const isCommandExit = (row) => rowCategory(row) === 'command-exit';
-const actionableRows = rows.filter((row) => !isCommandExit(row));
+const rowLeadingErrorLine = (row) => [
+  row.error_first_line,
+  row.error_preview,
+  row.result,
+  row.error,
+  row.message,
+].filter(Boolean).join('\n').split(/\r?\n/)
+  .map((line) => line.trim())
+  .find((line) => line && !line.startsWith('⚠️ '))
+  ?.replace(/^Error:\s*/i, '') || '';
+const isExpectedCancellation = (row) => {
+  if (rowCategory(row) === 'expected-cancellation') return true;
+  return /^Session\s+"[^"]+"\s+closed:\s*(?:aborted|closed)\s+during call\b/i.test(rowLeadingErrorLine(row));
+};
+const actionableRows = rows.filter((row) => !isCommandExit(row) && !isExpectedCancellation(row));
 const commandExitRows = rows.filter(isCommandExit);
 // Limit each partition independently so a burst of ordinary command exits
 // cannot crowd runtime/actionable failures out of the displayed report.

package/scripts/tui-transcript-perf-test.mjs

@@ -5,6 +5,11 @@ import { createEngineItemMutators, replaceEngineItemsState } from '../src/tui/en
 import { createEngineApiA } from '../src/tui/engine/session-api.mjs';
 import { createRunTurn } from '../src/tui/engine/turn.mjs';
 import { buildTranscriptRowIndexIncremental } from '../src/tui/app/transcript-window.mjs';
+import {
+  isCompletedTranscriptTail,
+  isCompletedTranscriptTailAppendedThisCommit,
+  isLiveSpinnerMetaVisible,
+} from '../src/tui/app/live-spinner-visibility.mjs';
 
 const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
@@ -91,6 +96,7 @@ function makeTurnHarness(ask, stateOverrides = {}, bagOverrides = {}) {
 
 test('successful mid-turn compact trims history but preserves live turn references', async () => {
   let preservedTail = false;
+  let compactKeepsSpinnerVisible = false;
   let contextSyncs = 0;
   const harness = makeTurnHarness(async (_text, options) => {
     options.onTextDelta('before compact\n');
@@ -98,6 +104,8 @@ test('successful mid-turn compact trims history but preserves live turn referenc
     options.onCompactEvent({ status: 'compacted', trigger: 'reactive' });
     assert.equal(contextSyncs, 1, 'compact event must refresh context before returning');
     preservedTail = harness.getState().streamingTail?.text === 'before compact\n';
+    compactKeepsSpinnerVisible = harness.getState().spinner?.active === true
+      && harness.getState().items.at(-1)?.kind === 'statusdone';
     options.onCompactEvent({ status: 'compacted', trigger: 'reactive' });
     assert.equal(contextSyncs, 2, 'each compact event refreshes context immediately');
     options.onTextDelta('after compact\n');
@@ -113,6 +121,7 @@ test('successful mid-turn compact trims history but preserves live turn referenc
 
   assert.equal(await harness.runTurn('go', { submittedIds: ['current-user'] }), 'done');
   assert.equal(preservedTail, true);
+  assert.equal(compactKeepsSpinnerVisible, true, 'a compact status leaves the active turn spinner in place');
   assert.equal(harness.getState().items.some((item) => item.id === 'old'), false);
   assert.equal(harness.getState().items.some((item) => item.id === 'current-user'), true);
   assert.equal(
@@ -125,6 +134,35 @@ test('successful mid-turn compact trims history but preserves live turn referenc
   );
 });
 
+test('live spinner remains visible across compact status and follows turn teardown', () => {
+  const activeTurnSpinner = { active: true };
+  const visible = (liveSpinner, liveSpinnerIsCommand, kind) => isLiveSpinnerMetaVisible({
+    inputBoxHidden: false,
+    slashPaletteOpen: false,
+    liveSpinner,
+    liveSpinnerIsCommand,
+    latestTranscriptItem: kind ? { kind } : null,
+  });
+
+  assert.equal(visible(activeTurnSpinner, false, 'statusdone'), true);
+  assert.equal(visible(activeTurnSpinner, false, 'turndone'), false);
+  assert.equal(visible(null, false, 'turndone'), false);
+  assert.equal(visible({ active: true }, true, 'turndone'), true);
+});
+
+test('completed transcript tail masking requires a new done tail', () => {
+  assert.equal(isCompletedTranscriptTail({ id: 'turn', kind: 'turndone' }), true);
+  assert.equal(isCompletedTranscriptTail({ id: 'status', kind: 'statusdone' }), true);
+  assert.equal(isCompletedTranscriptTail({ id: 'assistant', kind: 'assistant' }), false);
+  assert.equal(isCompletedTranscriptTail({ id: 'user', kind: 'user' }), false);
+  assert.equal(isCompletedTranscriptTail(null), false);
+  assert.equal(isCompletedTranscriptTailAppendedThisCommit({ id: 'turn', kind: 'turndone' }, 'turn'), false);
+  assert.equal(isCompletedTranscriptTailAppendedThisCommit({ id: 'status', kind: 'statusdone' }, 'status'), false);
+  assert.equal(isCompletedTranscriptTailAppendedThisCommit({ id: 'next', kind: 'turndone' }, 'previous'), true);
+  assert.equal(isCompletedTranscriptTailAppendedThisCommit({ id: 'next-status', kind: 'statusdone' }, 'previous'), true);
+  assert.equal(isCompletedTranscriptTailAppendedThisCommit({ id: 'assistant', kind: 'assistant' }, 'previous'), false);
+});
+
 test('failed mid-turn compact leaves prior transcript items untouched', async () => {
   const harness = makeTurnHarness(async (_text, options) => {
     options.onCompactEvent({ status: 'failed' });

package/scripts/web-fetch-routing-test.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import {
+  isLoopbackHttpUrl,
+  preDispatchDenyForSession,
+} from '../src/runtime/agent/orchestrator/session/loop/pre-dispatch-deny.mjs';
+import { executeTool } from '../src/runtime/agent/orchestrator/session/loop/tool-exec.mjs';
+import {
+  getInternalTools,
+  setInternalToolsProvider,
+} from '../src/runtime/agent/orchestrator/internal-tools.mjs';
+import { previewSessionTools } from '../src/runtime/agent/orchestrator/session/manager/tool-resolution.mjs';
+import { TOOL_DEFS as SEARCH_TOOL_DEFS } from '../src/runtime/search/tool-defs.mjs';
+import { dispatchSearchRuntimeTool } from '../src/session-runtime/runtime-core.mjs';
+import {
+  fetchLoopbackText,
+  fetchPublicImage,
+} from '../src/runtime/search/lib/http-fetch.mjs';
+
+test('pre-dispatch keeps hook-facing web_fetch name unchanged', () => {
+  const local = { name: 'web_fetch', arguments: { url: 'http://127.0.0.1:4321/status' } };
+  const image = { name: 'web_fetch', arguments: { url: 'https://cdn.example.com/a.png?x=1' } };
+  const document = { name: 'web_fetch', arguments: { url: 'https://example.com/docs' } };
+  assert.equal(preDispatchDenyForSession({}, local), null);
+  assert.equal(preDispatchDenyForSession({}, image), null);
+  assert.equal(preDispatchDenyForSession({}, document), null);
+  assert.equal(local.name, 'web_fetch');
+  assert.equal(image.name, 'web_fetch');
+  assert.equal(document.name, 'web_fetch');
+  assert.equal(isLoopbackHttpUrl('http://localhost:80/'), true);
+  assert.equal(isLoopbackHttpUrl('http://192.168.1.2/'), false);
+});
+
+test('hidden routed tools remain dispatchable but absent from every model schema', () => {
+  setInternalToolsProvider({
+    tools: SEARCH_TOOL_DEFS,
+    executor: async () => '',
+  });
+  const registered = getInternalTools().map((tool) => tool.name);
+  assert.equal(registered.includes('local_fetch'), true);
+  assert.equal(registered.includes('image_fetch'), true);
+  for (const spec of ['full', 'mcp', 'readonly', ['tools:mcp']]) {
+    const visible = previewSessionTools(spec, []).map((tool) => tool.name);
+    assert.equal(visible.includes('local_fetch'), false, `local_fetch leaked for ${JSON.stringify(spec)}`);
+    assert.equal(visible.includes('image_fetch'), false, `image_fetch leaked for ${JSON.stringify(spec)}`);
+    assert.equal(visible.includes('web_fetch'), true, `web_fetch missing for ${JSON.stringify(spec)}`);
+  }
+});
+
+test('hook sees public name before routed dispatch and can change routing inputs', async () => {
+  const observed = [];
+  setInternalToolsProvider({
+    tools: SEARCH_TOOL_DEFS,
+    executor: async (name, args) => {
+      observed.push({ stage: 'dispatch', name, args });
+      return { content: [{ type: 'text', text: name }] };
+    },
+  });
+  const result = await executeTool(
+    'web_fetch',
+    { url: 'https://example.com/document' },
+    process.cwd(),
+    'routing-order-test',
+    {
+      beforeToolHook: async ({ name, args }) => {
+        observed.push({ stage: 'hook', name, args });
+        return { action: 'modify', args: { url: 'http://127.0.0.1:4321/status' } };
+      },
+    },
+    { toolCallId: 'routing-order-call' },
+  );
+  assert.equal(result, 'local_fetch');
+  assert.deepEqual(observed.map(({ stage, name }) => ({ stage, name })), [
+    { stage: 'hook', name: 'web_fetch' },
+    { stage: 'dispatch', name: 'local_fetch' },
+  ]);
+});
+
+test('cancellation signal propagates across executeTool and runtime search dispatch', async () => {
+  const received = [];
+  setInternalToolsProvider({
+    tools: SEARCH_TOOL_DEFS,
+    executor: (name, args, callerCtx) => dispatchSearchRuntimeTool(name, args, callerCtx, {
+      getSearchModule: async () => ({
+        handleToolCall: async (_name, _args, options) => {
+          received.push({ name: _name, signal: options.signal });
+          await new Promise((resolve, reject) => {
+            if (options.signal.aborted) reject(options.signal.reason);
+            else options.signal.addEventListener('abort', () => reject(options.signal.reason), { once: true });
+          });
+        },
+      }),
+      getCurrentCwd: () => process.cwd(),
+      getSession: () => null,
+      notifyFnForSession: () => null,
+      runNativeWebSearch: async () => null,
+    }),
+  });
+  for (const [index, testCase] of [
+    { url: 'https://example.com/document', expectedName: 'web_fetch' },
+    { url: 'http://127.0.0.1:4321/status', expectedName: 'local_fetch' },
+  ].entries()) {
+    const controller = new AbortController();
+    const running = executeTool(
+      'web_fetch',
+      { url: testCase.url },
+      process.cwd(),
+      `cancel-test-${index}`,
+      {},
+      { toolCallId: `cancel-call-${index}`, signal: controller.signal },
+    );
+    controller.abort(new Error(`cancelled-by-test-${index}`));
+    await assert.rejects(running, new RegExp(`cancelled-by-test-${index}`));
+    assert.equal(received[index].name, testCase.expectedName);
+    assert.equal(received[index].signal, controller.signal);
+  }
+});
+
+test('local_fetch reads loopback and rejects redirect escape', async (t) => {
+  const server = http.createServer((req, res) => {
+    if (req.url === '/escape') {
+      res.writeHead(302, { location: 'http://169.254.169.254/latest/meta-data/' });
+      res.end();
+      return;
+    }
+    res.writeHead(200, { 'content-type': 'text/plain' });
+    res.end('local-ok');
+  });
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  t.after(() => server.close());
+  const { port } = server.address();
+  assert.equal(await fetchLoopbackText(`http://127.0.0.1:${port}/ok`), 'local-ok');
+  await assert.rejects(fetchLoopbackText(`http://127.0.0.1:${port}/escape`), /non-loopback/);
+  await assert.rejects(fetchLoopbackText('http://10.0.0.1/'), /non-loopback/);
+});
+
+test('public image fetch is bounded, media-shaped, and blocks private redirect targets', async () => {
+  const png = Buffer.from('89504e470d0a1a0a', 'hex');
+  const okFetch = async () => new Response(png, {
+    status: 200,
+    headers: { 'content-type': 'image/png', 'content-length': String(png.length) },
+  });
+  const image = await fetchPublicImage('https://images.example.com/a.png', { fetchImpl: okFetch });
+  assert.deepEqual(image, { mimeType: 'image/png', data: png.toString('base64'), bytes: png.length });
+
+  let calls = 0;
+  const redirectFetch = async () => {
+    calls++;
+    return new Response(null, { status: 302, headers: { location: 'http://169.254.169.254/latest/meta-data/' } });
+  };
+  await assert.rejects(
+    fetchPublicImage('https://images.example.com/a.png', { fetchImpl: redirectFetch }),
+    /private address/,
+  );
+  assert.equal(calls, 1);
+});