mixdog 0.9.3 → 0.9.4

package/src/tui/markdown/render-ansi.test.mjs

@@ -1,108 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import stripAnsi from 'strip-ansi';
-import { assistantBodyWidth } from './table-layout.mjs';
-import { renderTokenAnsiSegments, lexMarkdown, hasMarkdownSyntax } from './render-ansi.mjs';
-import { setThemeSetting } from '../theme.mjs';
-
-setThemeSetting('basic', { persist: false });
-
-// Mirrors the streaming suffix the <Markdown trimPartialFences> path renders.
-const STREAMING = '```js\nconst x = 1;\n`';
-
-function codeBlockVisibleLines(segments) {
-  const codeSeg = segments.find((s) => s.type === 'ansi' && s.token?.type === 'code');
-  assert.ok(codeSeg, 'a fenced code segment is rendered');
-  return stripAnsi(codeSeg.ansi).split('\n');
-}
-
-test('streaming render path drops the partial trailing backtick body line', () => {
-  const segments = renderTokenAnsiSegments(STREAMING, { trimPartialFences: true });
-  const lines = codeBlockVisibleLines(segments);
-  const bodyLines = lines.filter((l) => !/^js$/.test(l.trim()));
-  for (const l of bodyLines) {
-    assert.notEqual(l.trim(), '`', 'no body line is a lone partial fence');
-  }
-  // The real code body is still present.
-  assert.ok(lines.some((l) => l.includes('const x = 1;')), 'code body preserved');
-});
-
-test('without trimPartialFences the partial backtick survives as a body line', () => {
-  // Proves the trim flag is what removes it on the render path (not formatToken).
-  const segments = renderTokenAnsiSegments(STREAMING, { trimPartialFences: false });
-  const lines = codeBlockVisibleLines(segments);
-  const bodyLines = lines.filter((l) => !/^js$/.test(l.trim()));
-  assert.ok(
-    bodyLines.some((l) => l.trim() === '`'),
-    'untrimmed path keeps the partial fence as a body line',
-  );
-});
-
-test('trimPartialFences tokens are not cached (stable text unaffected)', () => {
-  const stable = '```js\nconst y = 2;\n```\n';
-  const a = lexMarkdown(stable, { trimPartialFences: false });
-  const b = lexMarkdown(stable, { trimPartialFences: false });
-  assert.strictEqual(a, b, 'stable content returns the cached token array');
-  // Streaming lex must be a fresh (non-cached) array.
-  const c = lexMarkdown(STREAMING, { trimPartialFences: true });
-  const d = lexMarkdown(STREAMING, { trimPartialFences: true });
-  assert.notStrictEqual(c, d, 'streaming lex is never cached');
-});
-
-test('closed code block renders lang label and body without fence markers', () => {
-  const segments = renderTokenAnsiSegments('```js\nconst z = 3;\n```\n', { trimPartialFences: true });
-  const lines = codeBlockVisibleLines(segments);
-  assert.ok(lines.some((l) => l.includes('const z = 3;')), 'body present');
-  assert.ok(lines.some((l) => l.trim() === 'js'), 'language label present');
-  assert.ok(!lines.some((l) => l.includes('```')), 'no literal fence markers');
-});
-
-test('renderTokenAnsiSegments width matches assistant body width for code pre-wrap', () => {
-  const long = 'z'.repeat(60);
-  const md = `\`\`\`js\n${long}\n\`\`\``;
-  const bodyWidth = assistantBodyWidth(40);
-  const atBody = renderTokenAnsiSegments(md, { width: bodyWidth });
-  const atDefault = renderTokenAnsiSegments(md, { width: 80 });
-  const bodyLines = (seg) => stripAnsi(seg.find((s) => s.token?.type === 'code').ansi)
-    .split('\n')
-    .filter((l) => l.startsWith('  '));
-  assert.ok(bodyLines(atBody).length > bodyLines(atDefault).length,
-    'narrow body width produces more wrapped code rows than width 80');
-});
-
-const PLAIN_PREFIX = 'x'.repeat(501);
-
-test('hasMarkdownSyntax detects strong markers after a 500+ char plain prefix', () => {
-  assert.ok(hasMarkdownSyntax(`${PLAIN_PREFIX}**late bold**`));
-});
-test('hasMarkdownSyntax detects inline code after a 500+ char plain prefix', () => {
-  assert.ok(hasMarkdownSyntax(`${PLAIN_PREFIX}\`late code\``));
-});
-
-test('render path parses fenced code after a 500+ char plain prefix', () => {
-  const input = `${PLAIN_PREFIX}\n\`\`\`js\nconst late = true;\n\`\`\``;
-  const tokens = lexMarkdown(input);
-  assert.ok(
-    tokens.some((t) => t.type === 'code' && String(t.text).includes('const late = true;')),
-    'lexer emits a code token with the fenced body',
-  );
-  const segments = renderTokenAnsiSegments(input);
-  const lines = codeBlockVisibleLines(segments);
-  assert.ok(lines.some((l) => l.includes('const late = true;')), 'code block body is rendered');
-  const visible = segments.map((s) => stripAnsi(s.ansi ?? '')).join('\n');
-  assert.ok(!visible.includes(`${PLAIN_PREFIX}\`\`\`js`), 'prefix is not glued to raw fence markers');
-});
-
-test('render path parses strong after a 500+ char plain prefix (no raw **)', () => {
-  const segments = renderTokenAnsiSegments(`${PLAIN_PREFIX}**rendered**`);
-  const visible = segments.map((s) => stripAnsi(s.ansi ?? '')).join('');
-  assert.ok(visible.includes('rendered'), 'bold text is present');
-  assert.ok(!visible.includes('**'), 'markdown strong markers are not leaked');
-});
-
-test('render path parses inline code after a 500+ char plain prefix (no raw backticks)', () => {
-  const segments = renderTokenAnsiSegments(`${PLAIN_PREFIX}\`snippet\``);
-  const visible = segments.map((s) => stripAnsi(s.ansi ?? '')).join('');
-  assert.ok(visible.includes('snippet'), 'codespan text is present');
-  assert.ok(!visible.includes('`'), 'inline code backticks are not leaked');
-});

package/src/tui/markdown/stream-fence.test.mjs

@@ -1,26 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { marked } from 'marked';
-import { trimPartialClosingFences } from './stream-fence.mjs';
-
-test('trims a partial closing fence (single backtick) from open code block', () => {
-  const tokens = marked.lexer('```js\nconst x = 1;\n`');
-  trimPartialClosingFences(tokens);
-  const code = tokens.find((t) => t.type === 'code');
-  assert.ok(code, 'code token exists');
-  assert.ok(!code.text.endsWith('`'), 'partial fence trimmed from text');
-  assert.ok(code.text.includes('const x = 1;'), 'real body preserved');
-});
-
-test('leaves a complete closing fence intact', () => {
-  const tokens = marked.lexer('```js\nconst x = 1;\n```\n');
-  const code = tokens.find((t) => t.type === 'code');
-  const before = code.text;
-  trimPartialClosingFences(tokens);
-  assert.equal(code.text, before, 'closed block unchanged');
-});
-
-test('no-op on non-code trailing token', () => {
-  const tokens = marked.lexer('hello world\n');
-  assert.doesNotThrow(() => trimPartialClosingFences(tokens));
-});

package/src/tui/markdown/streaming-markdown.test.mjs

@@ -1,70 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { assistantBodyWidth } from './table-layout.mjs';
-import {
-  measureMarkdownRenderedRows,
-  measureStreamingMarkdownRenderedRows,
-} from './measure-rendered-rows.mjs';
-import { resolveStreamingMarkdownParts, streamingLayoutText } from './streaming-markdown.mjs';
-import { setThemeSetting } from '../theme.mjs';
-
-setThemeSetting('basic', { persist: false });
-
-function measureStreamingLayoutFromParts(text, columns, streamKey) {
-  const parts = resolveStreamingMarkdownParts(text, streamKey);
-  if (parts.plain) {
-    return measureMarkdownRenderedRows(text, columns);
-  }
-  let rows = 0;
-  let childCount = 0;
-  if (parts.stablePrefix) {
-    rows += measureMarkdownRenderedRows(parts.stablePrefix, columns);
-    childCount += 1;
-  }
-  if (parts.unstableSuffix) {
-    rows += measureMarkdownRenderedRows(parts.unstableForRender, columns, { trimPartialFences: true });
-    childCount += 1;
-  }
-  if (childCount === 2) rows += 1;
-  return Math.max(1, rows);
-}
-
-test('streaming row estimate matches shared layout parts at body width', () => {
-  const columns = 40;
-  const bodyWidth = assistantBodyWidth(columns);
-  const cases = [
-    { key: 'bold-wrap', text: `**${'m'.repeat(bodyWidth + 12)}` },
-    { key: 'partial-fence', text: `\`\`\`js\n${'w'.repeat(bodyWidth + 6)}\n\`` },
-  ];
-  for (const { key, text } of cases) {
-    const estimate = measureStreamingMarkdownRenderedRows(text, columns, key);
-    const layout = measureStreamingLayoutFromParts(text, columns, key);
-    assert.strictEqual(estimate, layout, `${key}: estimate must match render layout parts`);
-  }
-});
-
-test('partial code fence streaming measure uses trimPartialFences on unstable suffix', () => {
-  const columns = 48;
-  const bodyWidth = assistantBodyWidth(columns);
-  const streamKey = 'test-stream-fence';
-  const text = `\`\`\`js\n${'n'.repeat(bodyWidth + 8)}\n\``;
-  const estimate = measureStreamingMarkdownRenderedRows(text, columns, streamKey);
-  const parts = resolveStreamingMarkdownParts(text, streamKey);
-  const manual = measureMarkdownRenderedRows(parts.unstableForRender, columns, { trimPartialFences: true });
-  assert.strictEqual(estimate, Math.max(1, manual));
-});
-
-test('leading blank lines do not create an empty stable child or extra gap row', () => {
-  const columns = 40;
-  const streamKey = 'test-leading-blank';
-  const raw = '\n\n**streaming body**';
-  const trimmed = streamingLayoutText(raw);
-  const parts = resolveStreamingMarkdownParts(raw, streamKey);
-  assert.strictEqual(parts.stablePrefix, '', 'leading newlines must not promote whitespace-only stable');
-  assert.ok(parts.unstableSuffix.includes('streaming body'));
-  const estimate = measureStreamingMarkdownRenderedRows(raw, columns, streamKey);
-  const trimmedEstimate = measureStreamingMarkdownRenderedRows(trimmed, columns, streamKey);
-  assert.strictEqual(estimate, trimmedEstimate, 'raw vs trimmed leading newlines must match');
-  const layout = measureStreamingLayoutFromParts(raw, columns, streamKey);
-  assert.strictEqual(estimate, layout);
-});

package/src/tui/paste-fix.test.mjs

@@ -1,119 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import stringWidth from 'string-width';
-import {
-  shouldFoldPastedText,
-  formatPastedTextRef,
-  pastedTextReferenceIds,
-  expandPastedTextTokens,
-} from './paste-attachments.mjs';
-import { caretPosition } from './input-editing.mjs';
-
-// --- Part 1: pasted-text token folding ----------------------------------
-
-test('shouldFoldPastedText fires on >=3 lines or >200 chars', () => {
-  assert.equal(shouldFoldPastedText('a\nb\nc'), true);        // 3 lines
-  assert.equal(shouldFoldPastedText('a\nb'), false);          // 2 lines, short
-  assert.equal(shouldFoldPastedText('x'.repeat(201)), true);  // > 200 chars
-  assert.equal(shouldFoldPastedText('x'.repeat(200)), false); // == 200, not over
-  assert.equal(shouldFoldPastedText(''), false);
-});
-
-test('token round-trips through format + expand', () => {
-  const original = 'line1\nline2\nline3';
-  const token = formatPastedTextRef(7, original);
-  assert.equal(token, '[Pasted text #7 +3 lines]');
-  const refs = pastedTextReferenceIds(`before ${token} after`);
-  assert.deepEqual([...refs], [7]);
-  const map = { 7: { id: 7, text: original } };
-  assert.equal(
-    expandPastedTextTokens(`before ${token} after`, map),
-    `before ${original} after`,
-  );
-});
-
-test('broken / partially-deleted tokens do not expand', () => {
-  const map = { 3: { id: 3, text: 'HIDDEN' } };
-  // Missing the "+N lines" tail — not a valid token, left verbatim.
-  assert.equal(expandPastedTextTokens('[Pasted text #3]', map), '[Pasted text #3]');
-  // Truncated bracket.
-  assert.equal(expandPastedTextTokens('[Pasted text #3 +2 lines', map), '[Pasted text #3 +2 lines');
-  // Unknown id stays as-is.
-  assert.equal(expandPastedTextTokens('[Pasted text #9 +2 lines]', map), '[Pasted text #9 +2 lines]');
-});
-
-// --- Part 2: caret row math vs ink wrap-ansi (hard, wordWrap:false) -------
-
-// Faithful re-implementation of wrap-ansi's wrapWord loop for a single
-// space-free line (the prompt caret math walks graphemes the same way). ink
-// renders <Text wrap="hard"> which calls wrapAnsi(text, w, {hard,wordWrap:false}).
-// For a run with no spaces the whole line goes through wrapWord, so the visual
-// row count is what this produces.
-function inkWrapWordRows(line, columns) {
-  const chars = Array.from(new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(line), (s) => s.segment);
-  let rows = 1;
-  let visible = 0;
-  for (let i = 0; i < chars.length; i += 1) {
-    const cw = stringWidth(chars[i]);
-    if (visible + cw <= columns) {
-      // stays on current row
-    } else {
-      rows += 1;
-      visible = 0;
-    }
-    visible += cw;
-    if (visible === columns && i < chars.length - 1) {
-      rows += 1;
-      visible = 0;
-    }
-  }
-  return rows;
-}
-
-// caretPosition row for the END of the string == (visual row count - 1).
-function caretRowsForWholeString(text, w) {
-  return caretPosition(text, text.length, w).row + 1;
-}
-
-test('caret rows agree with ink wrap for wide-char lines at odd widths', () => {
-  // A width where a width-2 glyph cannot sit flush on the last column exposes
-  // the mismatch: caretPosition must NOT advance an extra row when the char is
-  // simply pushed to the next line (ink does the same — it never leaves a
-  // half-column then over-counts).
-  const cases = [
-    { text: '가'.repeat(30), w: 41 },
-    { text: '가'.repeat(30), w: 40 },
-    { text: '가나다'.repeat(10) + 'ascii', w: 13 },
-    { text: '한글'.repeat(8), w: 7 },
-    { text: '가'.repeat(5), w: 2 },
-  ];
-  for (const { text, w } of cases) {
-    assert.equal(
-      caretRowsForWholeString(text, w),
-      inkWrapWordRows(text, w),
-      `width ${w} on ${JSON.stringify(text.slice(0, 6))}…`,
-    );
-  }
-});
-
-// Cursor exactly at a soft-wrap boundary MID-text: ink renders the following
-// glyph on the next row, so the caret must report {row N+1, col 0}, never
-// {row N, col == w} (which would sit outside the box).
-test('caret at mid-text wrap boundary rolls to next row (col 0)', () => {
-  const value = '가나다라마';        // 5 wide glyphs, width 2 each
-  const w = 4;                        // 2 glyphs per row
-  // offset 2 = after '나' (each glyph is ONE UTF-16 unit) = end of visual
-  // row 0; content ('다라마') follows, so the caret rolls to the next row.
-  const at = caretPosition(value, 2, w);
-  assert.deepEqual(at, { row: 1, col: 0 }, 'boundary caret must sit on next row');
-  // offset 4 = after '라' = end of visual row 1 (rows 0-1 are full).
-  assert.deepEqual(caretPosition(value, 4, w), { row: 2, col: 0 }, 'second boundary rolls too');
-  // Cursor at the very end of a FLUSH-ending text ('가나다라' fills rows 0-1
-  // exactly) with a trailing cell (PromptInput appends one) also rolls.
-  const flush = '가나다라';
-  const end = caretPosition(flush, flush.length, w, true);
-  assert.deepEqual(end, { row: 2, col: 0 }, 'flush end with trailing cell rolls to next row');
-  // Non-flush end ('마' leaves col 2) must NOT roll even with a trailing cell.
-  const nonFlush = caretPosition(value, value.length, w, true);
-  assert.deepEqual(nonFlush, { row: 2, col: 2 }, 'non-flush end stays on its row');
-});

package/src/tui/prompt-history-store.test.mjs

@@ -1,52 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import {
-  appendPromptHistory,
-  buildMergedPromptHistory,
-  loadPromptHistory,
-  pushSessionPromptHistory,
-  promptHistoryKey,
-} from './prompt-history-store.mjs';
-
-test('promptHistoryKey normalizes whitespace', () => {
-  assert.equal(promptHistoryKey('  hello   world  '), 'hello world');
-  assert.equal(promptHistoryKey('   '), '');
-});
-
-test('buildMergedPromptHistory prefers session order and dedupes', () => {
-  const merged = buildMergedPromptHistory(
-    ['newest', 'older'],
-    ['stale', 'newest', 'from-disk'],
-    50,
-  );
-  assert.deepEqual(merged, ['newest', 'older', 'from-disk', 'stale']);
-});
-
-test('appendPromptHistory persists per cwd across reload', () => {
-  const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-prompt-history-'));
-  const previous = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = dataDir;
-  try {
-    const cwd = join(dataDir, 'project-a');
-    assert.deepEqual(appendPromptHistory(cwd, 'first prompt'), ['first prompt']);
-    assert.deepEqual(appendPromptHistory(cwd, 'second prompt'), ['first prompt', 'second prompt']);
-    assert.deepEqual(appendPromptHistory(cwd, 'first   prompt'), ['second prompt', 'first   prompt']);
-    const loaded = loadPromptHistory(cwd);
-    assert.deepEqual(loaded, ['second prompt', 'first   prompt']);
-  } finally {
-    if (previous === undefined) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previous;
-    rmSync(dataDir, { recursive: true, force: true });
-  }
-});
-
-test('pushSessionPromptHistory is cwd-session newest-first with dedupe', () => {
-  let session = pushSessionPromptHistory([], 'alpha');
-  session = pushSessionPromptHistory(session, 'beta');
-  session = pushSessionPromptHistory(session, 'alpha');
-  assert.deepEqual(session, ['alpha', 'beta']);
-});
-

package/src/tui/statusline-ansi-bridge.test.mjs

@@ -1,159 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  remapCanonicalStatuslineTruecolor,
-  normalizeStatuslineAnsi,
-  statuslineFooterCacheKey,
-  statuslineFooterIdentityChanged,
-  isResetStatsState,
-  STATUSLINE_CANONICAL_TRUECOLOR,
-} from './statusline-ansi-bridge.mjs';
-import { theme, setThemeSetting } from './theme.mjs';
-
-function sgr38(r, g, b) {
-  return `\x1b[38;2;${r};${g};${b}m`;
-}
-
-function statusColorsFromTheme() {
-  const ansiRgb = (value, fallback) => {
-    const match = /^rgb\((\d+),(\d+),(\d+)\)$/.exec(String(value || '').replace(/\s+/g, ''));
-    if (!match) return fallback;
-    return sgr38(match[1], match[2], match[3]);
-  };
-  return {
-    STATUS: ansiRgb(theme.statusText, sgr38(198, 198, 198)),
-    SUBTLE: ansiRgb(theme.statusSubtle, sgr38(136, 136, 136)),
-    SUCCESS: ansiRgb(theme.success, sgr38(0, 170, 75)),
-    WARNING: ansiRgb(theme.warning, sgr38(255, 193, 7)),
-    ERROR: ansiRgb(theme.error, sgr38(220, 70, 88)),
-  };
-}
-
-test('remaps canonical truecolor sequences from ui/statusline.mjs', () => {
-  const colors = statusColorsFromTheme();
-  const subtle = sgr38(...STATUSLINE_CANONICAL_TRUECOLOR.subtle);
-  const success = sgr38(...STATUSLINE_CANONICAL_TRUECOLOR.success);
-  const raw = `${subtle}│\x1b[0m ${success}42%`;
-  const out = remapCanonicalStatuslineTruecolor(raw, colors);
-  assert.ok(!out.includes('38;2;136;136;136'), 'subtle canonical RGB should be replaced');
-  assert.ok(!out.includes('38;2;0;170;75'), 'success canonical RGB should be replaced');
-  assert.ok(out.includes(colors.SUBTLE));
-  assert.ok(out.includes(colors.SUCCESS));
-});
-
-test('normalizeStatuslineAnsi maps bold and legacy SGR plus truecolor', () => {
-  const colors = statusColorsFromTheme();
-  const raw = `\x1b[1mmodel\x1b[0m \x1b[33m5H\x1b[0m ${sgr38(...STATUSLINE_CANONICAL_TRUECOLOR.error)}quota`;
-  const out = normalizeStatuslineAnsi(raw, colors);
-  assert.ok(out.includes(colors.STATUS));
-  assert.ok(out.includes(colors.WARNING));
-  assert.ok(out.includes(colors.ERROR));
-  assert.ok(!out.includes('\x1b[33m'));
-  assert.ok(!out.includes('38;2;220;70;88'));
-});
-
-test('normalizeStatuslineAnsi preserves leading diamond glyph', () => {
-  const colors = statusColorsFromTheme();
-  const subtle = sgr38(...STATUSLINE_CANONICAL_TRUECOLOR.subtle);
-  const raw = `${subtle}◆\x1b[0m \x1b[1mgpt-4o\x1b[0m`;
-  const out = normalizeStatuslineAnsi(raw, colors);
-  assert.ok(out.includes('◆'), 'visible ◆ must remain');
-  assert.ok(out.includes('gpt-4o'));
-  assert.ok(out.indexOf('◆') < out.indexOf('gpt-4o'));
-});
-
-test('retimes bare values after reset without clobbering explicit segment colors', () => {
-  const colors = statusColorsFromTheme();
-  const subtle = colors.SUBTLE;
-  const success = colors.SUCCESS;
-  const warning = colors.WARNING;
-  const reset = '\x1b[0m';
-  const creditSeg = `${subtle}Credit${reset} $12.34`;
-  const outCredit = normalizeStatuslineAnsi(creditSeg, colors, { reset });
-  assert.ok(outCredit.includes('$12.34'));
-  const moneyIdx = outCredit.indexOf('$12.34');
-  assert.ok(moneyIdx > 0);
-  assert.ok(outCredit.slice(0, moneyIdx).includes(colors.STATUS), 'bare credit amount uses status text');
-
-  const usedLimit = `${subtle}5H${reset} $3.00/$10.00`;
-  const outUsed = normalizeStatuslineAnsi(usedLimit, colors, { reset });
-  assert.ok(outUsed.includes('$3.00/$10.00'));
-  assert.ok(outUsed.slice(0, outUsed.indexOf('$3.00')).includes(colors.STATUS));
-
-  const colored = `${subtle}5H${reset} ${warning}est $5.00${reset}`;
-  const outColored = normalizeStatuslineAnsi(colored, colors, { reset });
-  assert.ok(outColored.includes(warning), 'warning color on value must remain');
-  const estIdx = outColored.indexOf('est');
-  assert.ok(estIdx > 0);
-  assert.ok(outColored.slice(0, estIdx).includes(warning));
-});
-
-test('statuslineFooterCacheKey changes when session or route identity changes', () => {
-  const a = statuslineFooterCacheKey({ sessionId: 's1', provider: 'p', model: 'm1' });
-  const b = statuslineFooterCacheKey({ sessionId: 's2', provider: 'p', model: 'm1' });
-  const c = statuslineFooterCacheKey({ sessionId: 's1', provider: 'p', model: 'm2' });
-  assert.notEqual(a, b);
-  assert.notEqual(a, c);
-});
-
-test('statusline footer identity tracks context display boundary fields', () => {
-  const base = {
-    sessionId: 's1',
-    provider: 'p',
-    model: 'm',
-    contextWindow: 1_000_000,
-    displayContextWindow: 900_000,
-    rawContextWindow: 1_000_000,
-    compactBoundaryTokens: 900_000,
-    autoCompactTokenLimit: 810_000,
-    stats: { currentEstimatedContextTokens: 10_000 },
-  };
-  const changedDisplay = { ...base, displayContextWindow: 800_000 };
-  const changedBoundary = { ...base, compactBoundaryTokens: 800_000 };
-  const changedTrigger = { ...base, autoCompactTokenLimit: 720_000 };
-
-  assert.notEqual(statuslineFooterCacheKey(base), statuslineFooterCacheKey(changedDisplay));
-  assert.notEqual(statuslineFooterCacheKey(base), statuslineFooterCacheKey(changedBoundary));
-  assert.notEqual(statuslineFooterCacheKey(base), statuslineFooterCacheKey(changedTrigger));
-  assert.equal(statuslineFooterIdentityChanged(changedDisplay, base), true);
-  assert.equal(statuslineFooterIdentityChanged(changedBoundary, base), true);
-  assert.equal(statuslineFooterIdentityChanged(changedTrigger, base), true);
-});
-
-test('stats reset transition is footer identity change (cache must not reuse on /theme)', () => {
-  const activeStats = {
-    currentContextTokens: 1200,
-    inputTokens: 800,
-    turns: 2,
-  };
-  const resetStats = {
-    currentContextTokens: 0,
-    currentEstimatedContextTokens: 0,
-    inputTokens: 0,
-    latestInputTokens: 0,
-    promptTokens: 0,
-    turns: 0,
-  };
-  assert.equal(isResetStatsState(resetStats), true);
-  assert.equal(isResetStatsState(activeStats), false);
-  const sameRoute = { sessionId: 's1', provider: 'p', model: 'm', stats: resetStats };
-  const lastRoute = { sessionId: 's1', provider: 'p', model: 'm', stats: activeStats };
-  assert.equal(statuslineFooterCacheKey(sameRoute), statuslineFooterCacheKey(lastRoute));
-  assert.equal(statuslineFooterIdentityChanged(sameRoute, lastRoute), true);
-});
-
-test('theme switch changes normalized output when raw line is canonical', () => {
-  setThemeSetting('basic', { persist: false });
-  const colorsA = statusColorsFromTheme();
-  const raw = `${sgr38(...STATUSLINE_CANONICAL_TRUECOLOR.success)}▓▓\x1b[0m ${sgr38(...STATUSLINE_CANONICAL_TRUECOLOR.subtle)}░░`;
-  const tonedA = normalizeStatuslineAnsi(raw, colorsA);
-
-  setThemeSetting('teal', { persist: false });
-  const colorsB = statusColorsFromTheme();
-  const tonedB = normalizeStatuslineAnsi(raw, colorsB);
-
-  assert.notEqual(tonedA, tonedB);
-  assert.ok(tonedB.includes(colorsB.SUCCESS));
-  assert.ok(tonedB.includes(colorsB.SUBTLE));
-  setThemeSetting('basic', { persist: false });
-});

package/src/tui/transcript-tool-failures.test.mjs

@@ -1,111 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  formatHookDenialDetail,
-  hasUsefulFailedToolResultBody,
-  isFullyFailedToolBatch,
-  isHookApprovalDenialToolItem,
-  isHookApprovalDenialToolResult,
-  shouldSuppressFullyFailedToolItem,
-} from './transcript-tool-failures.mjs';
-
-const hookDeniedItem = {
-  kind: 'tool',
-  name: 'shell',
-  args: { command: 'rm -rf /' },
-  result: 'Error: tool "shell" denied by hook: approval required but no approval UI is available (policy)',
-  isError: true,
-  count: 1,
-  completedCount: 1,
-};
-
-const noisyFailedItem = {
-  kind: 'tool',
-  name: 'grep',
-  args: { pattern: 'foo' },
-  result: 'no matches',
-  isError: true,
-  count: 1,
-  completedCount: 1,
-};
-
-const emptyFailedItem = {
-  kind: 'tool',
-  name: 'grep',
-  args: { pattern: 'foo' },
-  result: null,
-  rawResult: null,
-  isError: true,
-  count: 1,
-  completedCount: 1,
-};
-
-const failedTaskJsonStringArgs = {
-  kind: 'tool',
-  name: 'shell',
-  args: '{"task_id":"t1","status":"failed","error":"boom"}',
-  result: null,
-  rawResult: null,
-  isError: true,
-  count: 1,
-  completedCount: 1,
-};
-
-const failedTaskInputWrapperArgs = {
-  kind: 'tool',
-  name: 'shell',
-  args: { input: { task_id: 't2', status: 'timeout' } },
-  result: null,
-  rawResult: null,
-  isError: true,
-  count: 1,
-  completedCount: 1,
-};
-
-test('detects hook denial result text', () => {
-  assert.equal(
-    isHookApprovalDenialToolResult('Error: tool "read" denied by hook: blocked'),
-    true,
-  );
-  assert.equal(
-    isHookApprovalDenialToolResult('Error: tool "shell" denied by hook: approval required but no approval UI is available'),
-    true,
-  );
-  assert.equal(isHookApprovalDenialToolResult('grep: no matches'), false);
-});
-
-test('fully-failed hook denials are not suppressed', () => {
-  assert.equal(isFullyFailedToolBatch(hookDeniedItem), true);
-  assert.equal(isHookApprovalDenialToolItem(hookDeniedItem), true);
-  assert.equal(shouldSuppressFullyFailedToolItem(hookDeniedItem), false);
-});
-
-test('fully-failed non-hook errors with visible body stay visible', () => {
-  assert.equal(isFullyFailedToolBatch(noisyFailedItem), true);
-  assert.equal(hasUsefulFailedToolResultBody(noisyFailedItem), true);
-  assert.equal(shouldSuppressFullyFailedToolItem(noisyFailedItem), false);
-});
-
-test('fully-failed non-hook errors without useful body stay suppressed', () => {
-  assert.equal(isFullyFailedToolBatch(emptyFailedItem), true);
-  assert.equal(hasUsefulFailedToolResultBody(emptyFailedItem), false);
-  assert.equal(shouldSuppressFullyFailedToolItem(emptyFailedItem), true);
-});
-
-test('failed background task with JSON-string args is not suppressed', () => {
-  assert.equal(isFullyFailedToolBatch(failedTaskJsonStringArgs), false);
-  assert.equal(shouldSuppressFullyFailedToolItem(failedTaskJsonStringArgs), false);
-});
-
-test('failed background task with input-wrapped args is not suppressed', () => {
-  assert.equal(isFullyFailedToolBatch(failedTaskInputWrapperArgs), false);
-  assert.equal(shouldSuppressFullyFailedToolItem(failedTaskInputWrapperArgs), false);
-});
-
-test('formatHookDenialDetail strips tool prefix', () => {
-  assert.equal(
-    formatHookDenialDetail(hookDeniedItem.result),
-    'denied by hook: approval required but no approval UI is available (policy)',
-  );
-});
-