mixdog 0.9.49 → 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;
@@ -58,7 +59,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 +162,8 @@ 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);
+  if (actionableFailureCount(failure.stdout) > 0) {
     throw new Error(`tool failures appeared after loop start:\n${failure.stdout}`);
   }
   const currentRss = rssMb();

package/scripts/smoke.mjs

@@ -19,120 +19,19 @@ function runNode(args, label, options = {}) {
   return child;
 }
 
-const child = runNode(['src/cli.mjs', '--help'], 'help smoke');
-const isolatedStatuslineEnv = {
-  MIXDOG_DATA_DIR: resolve(root, '.mixdog-smoke-data-empty'),
-  MIXDOG_HOME: resolve(root, '.mixdog-smoke-home-empty'),
-  MIXDOG_CONFIG_DIR: resolve(root, '.mixdog-smoke-config-empty'),
-};
-
-if (!child.stdout.includes('standalone mixdog CLI/TUI coding agent')) {
-  process.stderr.write(`unexpected help output:\n${child.stdout}`);
-  process.exit(1);
-}
+runNode(['src/cli.mjs', '--help'], 'help smoke');
 
 runNode(['--input-type=module', '-e', `
   const mod = await import('./src/tui/dist/index.mjs');
   if (typeof mod.runTui !== 'function') throw new Error('runTui export missing');
 `], 'tui bundle import smoke');
 
-runNode(['--input-type=module', '-e', `
-  process.stdout.columns = 120;
-  const { renderStatusline } = await import('./src/ui/statusline.mjs');
-  const line = await renderStatusline({
-    provider: 'openai',
-    model: 'gpt-5.5',
-    contextWindow: 1000000,
-    stats: { currentContextTokens: 999 },
-  });
-  if (/▓/.test(line) || !line.includes('░') || !line.includes('0.1%')) throw new Error('sub-1% context bar should stay empty: ' + JSON.stringify(line));
-`], 'statusline sub-percent context smoke', { env: isolatedStatuslineEnv });
-
-runNode(['--input-type=module', '-e', `
-  process.stdout.columns = 120;
-  const { renderStatusline } = await import('./src/ui/statusline.mjs');
-  const line = await renderStatusline({
-    provider: 'openai',
-    model: 'gpt-5.5',
-    contextWindow: 950000,
-    rawContextWindow: 1000000,
-    stats: { currentContextTokens: 900000 },
-  });
-  if (!line.includes('94%') || line.includes('100%')) throw new Error('statusline context% should use effective compact capacity, not the 90% auto-compact trigger: ' + JSON.stringify(line));
-`], 'statusline compact-capacity context smoke', { env: isolatedStatuslineEnv });
-
-runNode(['--input-type=module', '-e', `
-  process.stdout.columns = 120;
-  const { renderStatusline } = await import('./src/ui/statusline.mjs');
-  const line = await renderStatusline({
-    provider: 'openai',
-    model: 'gpt-5.5',
-    contextWindow: 950000,
-    stats: { currentContextTokens: 350000, currentContextSource: 'estimated' },
-  });
-  if (line.includes('37%') || !line.includes('0%')) throw new Error('statusline must not show local estimated context as session usage: ' + JSON.stringify(line));
-`], 'statusline estimated-context isolation smoke', { env: isolatedStatuslineEnv });
-
-runNode(['--input-type=module', '-e', `
-  process.stdout.columns = 120;
-  const { renderStatusline } = await import('./src/ui/statusline.mjs');
-  const line = await renderStatusline({
-    provider: 'openai',
-    model: 'gpt-5.5',
-    contextWindow: 950000,
-    stats: { currentContextTokens: 360000, currentContextSource: 'post_compact_estimate' },
-  });
-  if (!line.includes('37%')) throw new Error('statusline must show post-compact estimated context after stale API usage: ' + JSON.stringify(line));
-`], 'statusline post-compact context smoke', { env: isolatedStatuslineEnv });
-
-runNode(['--input-type=module', '-e', `
-  process.stdout.columns = 120;
-  const { renderStatusline } = await import('./src/ui/statusline.mjs');
-  const line = await renderStatusline({
-    provider: 'openai',
-    model: 'gpt-5.5',
-    contextWindow: 950000,
-    stats: { currentContextTokens: 0 },
-    agentJobs: [{ task_id: 'task_statusline_smoke', status: 'running', tag: 'bench-agent', startedAt: new Date().toISOString() }],
-  });
-  if (!line.includes('Running 1 Agent') || line.includes('bench-agent')) throw new Error('statusline must render live agent count without task tags: ' + JSON.stringify(line));
-`], 'statusline live agent task smoke', { env: isolatedStatuslineEnv });
-
-runNode(['--input-type=module', '-e', `
-  const { mkdtempSync, mkdirSync, writeFileSync } = await import('node:fs');
-  const { tmpdir } = await import('node:os');
-  const { join } = await import('node:path');
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-status-smoke-'));
-  mkdirSync(join(root, 'runtime'), { recursive: true });
-  writeFileSync(join(root, 'runtime', 'active-instance.json'), JSON.stringify({
-    gateway_port: 3468,
-    gateway_server_pid: process.pid,
-    gateway_provider: 'openai',
-    gateway_model: 'gpt-5.5',
-    gateway_context_window: 950000,
-    gateway_raw_context_window: 1000000,
-    gateway_auto_compact_token_limit: 950000,
-    gateway_context_used_pct: 37,
-    gateway_cc_session_id: 'other-session',
-    gateway_updated_at: Date.now()
-  }));
-  process.env.MIXDOG_RUNTIME_ROOT = join(root, 'runtime');
-  const { loadGatewayStatus } = await import('./src/vendor/statusline/bin/statusline-route.mjs');
-  const status = loadGatewayStatus({ sessionId: 'fresh-session', clientHostPid: process.pid, activeContextTokens: 0 });
-  if (status?.contextUsedPct === 37) throw new Error('statusline leaked active-instance context from another session');
-`], 'statusline session metrics isolation smoke', { env: isolatedStatuslineEnv });
-
-const boot = spawnSync(process.execPath, ['src/cli.mjs', '--help'], {
-  cwd: root,
-  env: { ...process.env, MIXDOG_BOOT_PROFILE: '1' },
-  encoding: 'utf8',
-  stdio: ['ignore', 'pipe', 'pipe'],
-  timeout: 10000,
+const boot = runNode(['src/cli.mjs', '--help'], 'boot profile smoke', {
+  env: { MIXDOG_BOOT_PROFILE: '1' },
 });
-
-if (boot.status !== 0 || !boot.stderr.includes('[mixdog-boot]') || !boot.stderr.includes('app:run:start')) {
+if (!boot.stderr.includes('[mixdog-boot]')) {
   process.stderr.write(boot.stderr || boot.stdout || 'boot profile smoke failed\n');
-  process.exit(boot.status || 1);
+  process.exit(1);
 }
 
 process.stdout.write('smoke passed ✓\n');

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' });