@crouton-kit/crouter 0.3.32 → 0.3.34

package/dist/core/__tests__/draw-style.test.js

@@ -1,258 +0,0 @@
-// Bug-regression test for the crtr TUI Draw style encoding.
-//
-// Observed bug (canvas + linkedin views, 2026-06-07): view code set Style.fg to a
-// color NAME ('green'/'cyan'/'red') instead of an SGR parameter ('32'/'36'/'31').
-// With color ON, styleSpan emitted `\x1b[greenm` — an invalid CSI the terminal
-// eats as a control op, printing the tail ('reenm') as literal garbage. The
-// monitor's status glyphs/flags rendered as garbage on any color terminal (the
-// non-TTY/NO_COLOR path was unaffected because fg is gated behind `color`).
-//
-// Root-cause fix: styleSpan now only emits fg/bg when the value is a valid SGR
-// parameter string (digits + semicolons); a bad value degrades to no-color
-// instead of emitting a broken escape. These tests lock that guarantee.
-//
-// Run: node --import tsx/esm --test src/core/__tests__/draw-style.test.ts
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import { styleSpan, isSgrParams, createDraw } from '../tui/draw.js';
-import { drawChrome } from '../tui/host.js';
-const ESC = '\x1b[';
-const ON = { color: true, color256: true };
-const OFF = { color: false, color256: false };
-const SIZE = { cols: 80, rows: 24 };
-/** Strip the harmless framing CSIs the serializer emits (cursor home / clear),
- *  so any REMAINING `\x1b[` not followed by an SGR param digit/semicolon is a
- *  broken SGR escape — the exact bug class (`\x1b[greenm`). */
-function hasInvalidCsi(frame) {
-    const stripped = frame.replace(/\x1b\[[HJK]/g, '').replace(/[\r\n]/g, '');
-    return /\x1b\[[^0-9;]/.test(stripped);
-}
-/** Any 8-bit color SGR (fg 30-37/90-97, or 256-color bg) present in the frame. */
-function hasColorSgr(frame) {
-    return /\x1b\[(3[0-9]|9[0-7])m/.test(frame) || /\x1b\[48;5;/.test(frame);
-}
-function baseChrome(over = {}) {
-    return { status: null, banner: null, busy: false, loaded: true, lastRefresh: Date.now(), tick: 0, subtitle: null, mode: null, ...over };
-}
-const MANIFEST = {
-    title: 'Test View', subtitle: '3 unread',
-    keymap: [
-        { keys: 'j/k', label: 'move' }, { keys: 'enter', label: 'open' },
-        { keys: 'r', label: 'reply' }, { keys: 'g', label: 'refresh' }, { keys: 'q', label: 'quit' },
-    ],
-};
-describe('styleSpan: SGR encoding (bug-regression)', () => {
-    test('a valid numeric fg emits a well-formed CSI', () => {
-        const out = styleSpan('●', { fg: '32', bold: true }, true, '');
-        assert.ok(out.includes(`${ESC}32m`), 'should contain \\x1b[32m');
-        assert.ok(out.includes(`${ESC}1m`), 'bold still emitted');
-    });
-    test('a color NAME fg degrades to no-color — never emits a broken escape', () => {
-        const out = styleSpan('●', { fg: 'green' }, true, '');
-        // The bug: \x1b[greenm. Assert no CSI is followed by a non-digit/semicolon.
-        assert.ok(!/\x1b\[[^0-9;]/.test(out), 'no invalid CSI introducer');
-        assert.ok(!out.includes('green'), 'the bad token never leaks into output');
-    });
-    test('a color NAME bg degrades to no-color', () => {
-        const out = styleSpan('x', { bg: 'red' }, true, '');
-        assert.ok(!/\x1b\[[^0-9;]/.test(out), 'no invalid CSI introducer');
-        assert.ok(!out.includes('red'), 'the bad token never leaks into output');
-    });
-    test('a valid 256-color bg index emits 48;5;N', () => {
-        const out = styleSpan('x', { bg: '236' }, true, '');
-        assert.ok(out.includes(`${ESC}48;5;236m`), 'should contain \\x1b[48;5;236m');
-    });
-    test('compound SGR params (e.g. "1;36") are valid', () => {
-        assert.equal(isSgrParams('1;36'), true);
-        assert.equal(isSgrParams('236'), true);
-        assert.equal(isSgrParams('green'), false);
-        assert.equal(isSgrParams(''), false);
-    });
-    test('structural styles (bold/dim/reverse) are unaffected by color gating', () => {
-        const out = styleSpan('x', { fg: 'green', dim: true }, true, '');
-        assert.ok(out.includes(`${ESC}2m`), 'dim still emitted even when fg is rejected');
-    });
-});
-// ── New Draw primitives — same bug class (no invalid CSI; bad value degrades) ──
-describe('spansRight: SGR encoding (bug-regression)', () => {
-    test('valid numeric fg → well-formed CSI, no broken escape', () => {
-        const { draw, frame } = createDraw(SIZE, ON);
-        draw.spansRight(0, 80, [{ text: 'ready', style: { fg: '32', bold: true } }]);
-        const f = frame();
-        assert.ok(f.includes(`${ESC}32m`), 'emits \\x1b[32m');
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI');
-    });
-    test('a color NAME fg degrades — no broken escape, name not leaked', () => {
-        const { draw, frame } = createDraw(SIZE, ON);
-        draw.spansRight(0, 80, [{ text: 'x', style: { fg: 'green' } }]);
-        const f = frame();
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI introducer');
-        assert.ok(!f.includes('green'), 'the bad token never leaks');
-    });
-    test('over-maxWidth groups left-clip with a leading … (no overflow, no garbage)', () => {
-        const { draw, frame } = createDraw(SIZE, ON);
-        draw.spansRight(0, 80, [{ text: 'abcdefghij', style: { dim: true } }], 4);
-        const f = frame();
-        assert.ok(f.includes('…'), 'leading ellipsis present');
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI');
-    });
-});
-describe('vline: SGR encoding + mono fallback (bug-regression)', () => {
-    test('renders a dim rule with no invalid CSI (color on)', () => {
-        const { draw, frame } = createDraw(SIZE, ON);
-        draw.vline(40, 0, 10);
-        const f = frame();
-        assert.ok(f.includes('│'), 'default │ glyph present');
-        assert.ok(f.includes(`${ESC}2m`), 'dim emitted');
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI');
-    });
-    test('ASCII fallback ch and mono caps both stay well-formed', () => {
-        const { draw, frame } = createDraw(SIZE, OFF);
-        draw.vline(40, 0, 10, '|');
-        const f = frame();
-        assert.ok(f.includes('|'), 'ASCII fallback | present');
-        assert.ok(!hasColorSgr(f), 'no color SGR when caps.color is off');
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI');
-    });
-});
-describe('ListItemRow.right: SGR encoding (bug-regression)', () => {
-    test('right group + cursor-row base merge → no invalid CSI', () => {
-        const { draw, frame } = createDraw(SIZE, ON);
-        /** @type {ListItemRow[]} */
-        const items = [
-            { spans: [{ text: 'Ada Lovelace', style: { bold: true } }], right: [{ text: '2h', style: { fg: '90' } }] },
-            { spans: [{ text: 'Grace Hopper' }], right: [{ text: '4h', style: { fg: '90' } }] },
-        ];
-        const res = draw.list({ row: 2, col: 0, width: 80, height: 5 }, items, 0, 0);
-        const f = frame();
-        assert.equal(res.scroll, 0);
-        assert.ok(f.includes('2h') && f.includes('4h'), 'right-flushed timestamps drawn');
-        assert.ok(f.includes(`${ESC}48;5;236m`), 'cursor-row 236-bg highlight present');
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI');
-    });
-    test('a color NAME fg in the right group degrades, not leaks', () => {
-        const { draw, frame } = createDraw(SIZE, ON);
-        const items = [{ spans: [{ text: 'x' }], right: [{ text: 'y', style: { fg: 'cyan' } }] }];
-        draw.list({ row: 0, col: 0, width: 80, height: 2 }, items, 0, 0);
-        const f = frame();
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI');
-        assert.ok(!f.includes('cyan'), 'the bad token never leaks');
-    });
-});
-// ── Chrome — every new element survives the bug class + has a mono fallback ──
-describe('drawChrome: SGR encoding + mono fallback (bug-regression)', () => {
-    const states = [
-        ['working', baseChrome({ busy: true, status: 'Loading…' })],
-        ['blocked', baseChrome({ banner: { msg: 'Send rejected', level: 'error' } })],
-        ['attention', baseChrome({ banner: { msg: 'Log in, then press r', level: 'action' } })],
-        ['ready', baseChrome({ status: '5 conversations' })],
-        ['idle', baseChrome({ loaded: false, lastRefresh: 0 })],
-        ['info-banner', baseChrome({ banner: { msg: 'Throttling — waiting', level: 'info' } })],
-    ];
-    for (const [name, chrome] of states) {
-        test(`state "${name}" never emits a broken escape (color on)`, () => {
-            const { draw, frame } = createDraw(SIZE, ON);
-            drawChrome(draw, SIZE, MANIFEST, chrome);
-            assert.ok(!hasInvalidCsi(frame()), 'no invalid CSI');
-        });
-    }
-    test('mono fallback: no color SGR when caps.color is off, glyphs/words still render', () => {
-        const { draw, frame } = createDraw(SIZE, OFF);
-        drawChrome(draw, SIZE, MANIFEST, baseChrome({ busy: true, status: 'Loading…' }));
-        const f = frame();
-        assert.ok(!hasColorSgr(f), 'no color SGR emitted in mono');
-        assert.ok(f.includes('▎'), 'state rail glyph always drawn');
-        assert.ok(f.includes('working'), 'state WORD carries meaning in mono');
-        assert.ok(f.includes(`${ESC}1m`), 'structural bold still emitted');
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI');
-    });
-    test('every banner level renders its glyph with no broken escape', () => {
-        for (const [level, glyph] of [['info', 'ℹ'], ['action', '▸'], ['error', '✗']]) {
-            const { draw, frame } = createDraw(SIZE, ON);
-            drawChrome(draw, SIZE, MANIFEST, baseChrome({ banner: { msg: 'm', level } }));
-            const f = frame();
-            assert.ok(f.includes(glyph), `${level} banner glyph ${glyph} present`);
-            assert.ok(!hasInvalidCsi(f), `${level} banner: no invalid CSI`);
-        }
-    });
-    test('keymap overflow degrades to keys-only on a narrow screen, still well-formed', () => {
-        const narrow = { cols: 28, rows: 24 };
-        const { draw, frame } = createDraw(narrow, ON);
-        drawChrome(draw, narrow, MANIFEST, baseChrome({ status: 'a very long status line here' }));
-        const f = frame();
-        assert.ok(f.includes('q'), 'q quit hint survives overflow');
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI under overflow');
-    });
-});
-// ── Dynamic subtitle (host.setSubtitle) — same bug class + mono fallback ──
-describe('drawChrome subtitle: SGR encoding + mono fallback (bug-regression)', () => {
-    test('a dynamic subtitle overrides manifest.subtitle, dim, no broken escape', () => {
-        const { draw, frame } = createDraw(SIZE, ON);
-        drawChrome(draw, SIZE, MANIFEST, baseChrome({ subtitle: '7 unread' }));
-        const f = frame();
-        assert.ok(f.includes('7 unread'), 'dynamic subtitle rendered');
-        assert.ok(!f.includes('3 unread'), 'dynamic value overrides the static manifest subtitle');
-        assert.ok(f.includes(`${ESC}2m`), 'subtitle is dim (structural)');
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI');
-    });
-    test('null subtitle falls back to the manifest default', () => {
-        const { draw, frame } = createDraw(SIZE, ON);
-        drawChrome(draw, SIZE, MANIFEST, baseChrome({ subtitle: null }));
-        const f = frame();
-        assert.ok(f.includes('3 unread'), 'manifest.subtitle shown when dynamic is null');
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI');
-    });
-    test('mono fallback: subtitle text renders dim with no color SGR', () => {
-        const { draw, frame } = createDraw(SIZE, OFF);
-        drawChrome(draw, SIZE, MANIFEST, baseChrome({ subtitle: '7 unread' }));
-        const f = frame();
-        assert.ok(f.includes('7 unread'), 'subtitle text still renders in mono');
-        assert.ok(!hasColorSgr(f), 'no color SGR emitted for the subtitle in mono');
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI');
-    });
-});
-// ── Mode chip (host.setMode) — same bug class, mono fallback, precedence ──
-describe('drawChrome mode chip: SGR encoding + mono fallback (bug-regression)', () => {
-    test('compose mode → ✎ compose in yellow (33), no broken escape', () => {
-        const { draw, frame } = createDraw(SIZE, ON);
-        drawChrome(draw, SIZE, MANIFEST, baseChrome({ mode: 'compose' }));
-        const f = frame();
-        assert.ok(f.includes('✎') && f.includes('compose'), 'mode glyph + word present');
-        assert.ok(f.includes(`${ESC}33m`), 'compose-accent yellow 33 emitted');
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI');
-    });
-    test('react mode → ☺ react reuses the compose-accent yellow (33)', () => {
-        const { draw, frame } = createDraw(SIZE, ON);
-        drawChrome(draw, SIZE, MANIFEST, baseChrome({ mode: 'react' }));
-        const f = frame();
-        assert.ok(f.includes('☺') && f.includes('react'), 'react glyph + word present');
-        assert.ok(f.includes(`${ESC}33m`), 'react reuses yellow 33');
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI');
-    });
-    test('mono fallback: mode chip is glyph + bold word, no color SGR', () => {
-        const { draw, frame } = createDraw(SIZE, OFF);
-        drawChrome(draw, SIZE, MANIFEST, baseChrome({ mode: 'compose' }));
-        const f = frame();
-        assert.ok(f.includes('✎'), 'glyph carries the mode in mono');
-        assert.ok(f.includes('compose'), 'mode word carries meaning in mono');
-        assert.ok(f.includes(`${ESC}1m`), 'bold still emitted (mono carrier)');
-        assert.ok(!hasColorSgr(f), 'no color SGR emitted in mono');
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI');
-    });
-    test('precedence: an explicit mode WINS the chip over the derived busy/working state', () => {
-        const { draw, frame } = createDraw(SIZE, ON);
-        // busy would derive `working`; the explicit mode must override it.
-        drawChrome(draw, SIZE, MANIFEST, baseChrome({ busy: true, mode: 'compose' }));
-        const f = frame();
-        assert.ok(f.includes('compose'), 'mode word shown');
-        assert.ok(!f.includes('working'), 'derived working chip suppressed by the mode override');
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI');
-    });
-    test('null mode returns to the derived chip (ready when loaded)', () => {
-        const { draw, frame } = createDraw(SIZE, ON);
-        drawChrome(draw, SIZE, MANIFEST, baseChrome({ mode: null }));
-        const f = frame();
-        assert.ok(f.includes('ready'), 'derived ready chip shown when no mode set');
-        assert.ok(!hasInvalidCsi(f), 'no invalid CSI');
-    });
-});

package/dist/core/__tests__/error-stall-recycle.test.js

@@ -1,141 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/error-stall-recycle.test.ts
-//
-// BUG-REGRESSION (§I error-stall; gh issue #4 — node mqaeqzdu-0746b3b7, a 9h
-// zombie). A provider outage exhausted the engine's SDK retry budget mid-task:
-// pi appended trailing stopReason:'error' assistant messages to the session
-// .jsonl and PARKED (the stophook's agent_end returns early on 'error' — "stay
-// alive for re-steering"). A headless node has no human to re-steer it, so the
-// broker stayed alive, status stayed 'active', and the daemon's pid-only
-// liveness check read it healthy for 9 hours while its parent believed it was
-// working. The daemon is the authority: a live, not-busy, intent-null engine
-// whose session file has been quiet past ERROR_STALL_QUIET_MS and whose last
-// assistant message stopped with 'error' is force-killed, so the ordinary
-// dead-pid crash path grace-revives RESUME on the saved session — the exact
-// manual recovery (kill broker + canvas revive) that fixed the zombie by hand.
-//
-// Three legs: the pure truth table (E1 — errorStallVerdict), the tail-signature
-// parser (E2 — trailingEngineError), and the daemon integration over a real
-// live pid the daemon must SIGTERM (E3 — superviseTick with an injected clock).
-// Regression check: drop §I and E3's "engine killed" assert goes RED (the
-// parked error engine lives forever, never recovered).
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawn } from 'node:child_process';
-import { writeFileSync, utimesSync, mkdtempSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { createHeadlessHarness } from './helpers/harness.js';
-import { errorStallVerdict, trailingEngineError, ERROR_STALL_QUIET_MS, isPidAlive, } from '../../daemon/crtrd.js';
-// ---------------------------------------------------------------------------
-// Session-jsonl line builders (the shape pi writes: {type:'message', message}).
-// ---------------------------------------------------------------------------
-function line(message) {
-    return JSON.stringify({ type: 'message', id: 'x', timestamp: new Date().toISOString(), message });
-}
-const assistant = (stopReason, errorMessage) => line({ role: 'assistant', stopReason, ...(errorMessage === undefined ? {} : { errorMessage }) });
-const toolResult = () => line({ role: 'toolResult' });
-const user = () => line({ role: 'user' });
-// ---------------------------------------------------------------------------
-// E1 — the pure error-stall truth table.
-// ---------------------------------------------------------------------------
-test('E1 errorStallVerdict: kill ONLY a live, not-busy, intent-null engine, quiet past grace, with a trailing error', () => {
-    const G = ERROR_STALL_QUIET_MS;
-    // The one 'kill' case.
-    assert.equal(errorStallVerdict(true, null, false, G, true), 'kill', 'alive+no-intent+!busy+quiet>=grace+error → kill');
-    assert.equal(errorStallVerdict(true, null, false, G + 60_000, true), 'kill', 'well past grace → kill');
-    // Recent session activity → leave (something is still making progress).
-    assert.equal(errorStallVerdict(true, null, false, G - 1, true), 'leave', 'within quiet grace → leave');
-    assert.equal(errorStallVerdict(true, null, false, null, true), 'leave', 'unknown quiet span → leave');
-    // No trailing error → a healthy park (attended root, awaiting node) — leave.
-    assert.equal(errorStallVerdict(true, null, false, G + 60_000, false), 'leave', 'last turn not an error → leave');
-    // A working engine is NEVER killed (wedged-on-bash is recovered by killing the
-    // subprocess, not the node).
-    assert.equal(errorStallVerdict(true, null, true, G + 60_000, true), 'leave', 'busy (mid-turn) → leave');
-    // A pending intent belongs to other paths (§H refresh; idle-release dormancy).
-    assert.equal(errorStallVerdict(true, 'refresh', false, G + 60_000, true), 'leave', 'intent=refresh → leave (§H owns it)');
-    assert.equal(errorStallVerdict(true, 'idle-release', false, G + 60_000, true), 'leave', 'intent=idle-release → leave');
-    // A dead/unknown pid is the ordinary revive path's job.
-    assert.equal(errorStallVerdict(false, null, false, G + 60_000, true), 'leave', 'dead pid → leave');
-    assert.equal(errorStallVerdict(null, null, false, G + 60_000, true), 'leave', 'unknown pid → leave');
-});
-// ---------------------------------------------------------------------------
-// E2 — the tail-signature parser.
-// ---------------------------------------------------------------------------
-test('E2 trailingEngineError: only a trailing error assistant turn matches', () => {
-    // The observed zombie shape: trailing zero-token error assistant messages.
-    assert.equal(trailingEngineError([assistant('toolUse'), toolResult(), assistant('error', 'Connection error.')].join('\n')), 'Connection error.', 'trailing error turn → its errorMessage');
-    // Trailing non-assistant lines (toolResults, an injected user message that
-    // never got a response) are walked past to the last assistant turn.
-    assert.equal(trailingEngineError([assistant('error', 'Connection error.'), user()].join('\n')), 'Connection error.', 'trailing injected user line is walked past');
-    // A healthy park / human abort is NOT a wedge.
-    assert.equal(trailingEngineError([assistant('error', 'x'), toolResult(), assistant('stop')].join('\n')), null, 'recovered after an earlier error → null');
-    assert.equal(trailingEngineError(assistant('aborted')), null, 'human Esc → null');
-    // A tail cut mid-line (the 64KB boundary) is skipped, not fatal.
-    assert.equal(trailingEngineError(['ut"}}garbage-fragment', assistant('error', 'boom')].join('\n')), 'boom', 'cut first fragment is skipped');
-    // An error turn with no errorMessage still reads as a wedge.
-    assert.notEqual(trailingEngineError(assistant('error')), null, 'error with no errorMessage still matches');
-    assert.equal(trailingEngineError(null), null, 'no tail → null');
-    assert.equal(trailingEngineError(''), null, 'empty tail → null');
-});
-// ---------------------------------------------------------------------------
-// E3 — daemon integration: a parked trailing-error engine is force-recycled.
-// ---------------------------------------------------------------------------
-const T0 = 9_000_000_000;
-test('E3 daemon force-kills a wedged engine: live, not-busy, intent-null, session quiet past grace with a trailing error turn', { timeout: 30_000 }, async () => {
-    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-e3' });
-    const dir = mkdtempSync(join(tmpdir(), 'crtr-e3-'));
-    // Real live subprocesses standing in for the parked engines; `sleep` dies on
-    // SIGTERM, so the daemon's force-kill is directly observable.
-    const wedged = spawn('sleep', ['300'], { stdio: 'ignore' });
-    const parked = spawn('sleep', ['300'], { stdio: 'ignore' });
-    try {
-        // The WEDGED node: session ends in an error turn, quiet for > the grace.
-        const wedgedFile = join(dir, 'wedged.jsonl');
-        writeFileSync(wedgedFile, [assistant('toolUse'), toolResult(), assistant('error', 'Connection error.')].join('\n') + '\n');
-        const staleSec = (T0 - ERROR_STALL_QUIET_MS - 1) / 1000;
-        utimesSync(wedgedFile, staleSec, staleSec);
-        const wedgedId = h.fabricateBrokerNode({
-            kind: 'developer',
-            status: 'active',
-            pi_pid: wedged.pid,
-            pi_session_id: 'sess-e3-wedged',
-            pi_session_file: wedgedFile,
-        });
-        // The CONTROL node: equally old and quiet, but its last turn is a healthy
-        // 'stop' (an attended root overnight) — must NEVER be killed.
-        const parkedFile = join(dir, 'parked.jsonl');
-        writeFileSync(parkedFile, [assistant('toolUse'), toolResult(), assistant('stop')].join('\n') + '\n');
-        utimesSync(parkedFile, staleSec, staleSec);
-        h.fabricateBrokerNode({
-            kind: 'developer',
-            status: 'active',
-            pi_pid: parked.pid,
-            pi_session_id: 'sess-e3-parked',
-            pi_session_file: parkedFile,
-        });
-        assert.equal(isPidAlive(wedged.pid), true, 'precondition: the wedged engine is alive');
-        // --- TICK @ T0: the session has already been quiet past the grace (the
-        //     file mtime is the clock — no arming tick), so the daemon SIGTERMs
-        //     the wedged engine on sight. ---
-        await h.tick(T0);
-        await h.waitFor(() => (isPidAlive(wedged.pid) ? null : true), {
-            label: 'daemon SIGTERM killed the wedged trailing-error engine (§I)',
-            timeoutMs: 10_000,
-        });
-        assert.equal(isPidAlive(wedged.pid), false, 'the wedged engine was force-killed');
-        assert.equal(isPidAlive(parked.pid), true, 'the healthily-parked engine was NOT touched');
-        assert.equal(h.node(wedgedId).intent ?? null, null, 'intent stays null — the dead-pid CRASH branch owns the revive (resume)');
-    }
-    finally {
-        for (const c of [wedged, parked]) {
-            try {
-                c.kill('SIGKILL');
-            }
-            catch {
-                /* already gone */
-            }
-        }
-        rmSync(dir, { recursive: true, force: true });
-        await h.dispose();
-    }
-});

package/dist/core/__tests__/frame-decoder-perf.test.js

@@ -1,224 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/frame-decoder-perf.test.ts
-//
-// Bug-regression suite for the FrameDecoder O(n²) typing-lag bug (2026-06-09).
-//
-// OBSERVED BUG: typing in `crtr attach` lagged after the headless-broker change.
-// Root cause #1: FrameDecoder.push() did `this.buf += str` and re-scanned the
-// WHOLE accumulated buffer (`this.buf.indexOf('\n')` + Buffer.byteLength over
-// the consumed prefix) on every ~64 KiB socket chunk, so one large frame (the
-// multi-MiB `welcome` snapshot, a big tool result) cost O(frame × chunks) —
-// measured ~254 ms of event-loop stall decoding a 16 MiB frame, with the stall
-// growing ~5× per size doubling. The decoder runs on BOTH the viewer and broker
-// read paths, so the stall blocked keystroke handling directly.
-//
-// The fix holds the carried partial line as an array of chunk strings and scans
-// each incoming chunk exactly once — amortized O(total bytes). Same 16 MiB frame:
-// ~12 ms.
-//
-// These tests lock in (a) behavioral equivalence with the old decoder across
-// randomized chunkings — frames, blank-line skip, malformed-JSON drop, multibyte
-// splits, and both FrameOverflowError caps with identical byte accounting — and
-// (b) the linear growth curve via a SCALING-RATIO assertion (per-MiB decode cost
-// at 4 MiB vs 16 MiB must stay ~flat), so the quadratic shape cannot silently
-// return. The ratio is measured with min-of-reps and interleaved sizes so it is
-// robust to CPU contention from parallel `test:full` workers — see the perf test
-// for the full rationale.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { StringDecoder } from 'node:string_decoder';
-import { FrameDecoder, FrameOverflowError, CLIENT_READ_CAPS, } from '../runtime/broker-protocol.js';
-// ---------------------------------------------------------------------------
-// The PRE-FIX decoder, verbatim (git ed49e60), as the equivalence oracle.
-// ---------------------------------------------------------------------------
-class ReferenceFrameDecoder {
-    caps;
-    buf = '';
-    bufBytes = 0;
-    utf8 = new StringDecoder('utf8');
-    constructor(caps) {
-        this.caps = caps;
-    }
-    push(chunk) {
-        const str = typeof chunk === 'string' ? chunk : this.utf8.write(chunk);
-        this.buf += str;
-        this.bufBytes += Buffer.byteLength(str);
-        if (this.bufBytes > this.caps.maxTotalBytes) {
-            throw new FrameOverflowError('total', this.bufBytes, this.caps.maxTotalBytes);
-        }
-        const out = [];
-        let nl;
-        while ((nl = this.buf.indexOf('\n')) >= 0) {
-            const consumed = this.buf.slice(0, nl + 1);
-            this.bufBytes -= Buffer.byteLength(consumed);
-            const line = this.buf.slice(0, nl).trim();
-            this.buf = this.buf.slice(nl + 1);
-            if (line === '')
-                continue;
-            try {
-                out.push(JSON.parse(line));
-            }
-            catch {
-                /* drop malformed */
-            }
-        }
-        if (this.bufBytes > this.caps.maxLineBytes) {
-            throw new FrameOverflowError('line', this.bufBytes, this.caps.maxLineBytes);
-        }
-        return out;
-    }
-}
-// Deterministic PRNG so a failure reproduces.
-let seed = 0xc0ffee;
-const rnd = () => {
-    seed = (seed * 1103515245 + 12345) & 0x7fffffff;
-    return seed / 0x7fffffff;
-};
-const randInt = (lo, hi) => lo + Math.floor(rnd() * (hi - lo + 1));
-const MULTIBYTE = ['é', '漢', '🎉', '𝕏', 'ü', '한'];
-const randText = (len) => {
-    let s = '';
-    while (s.length < len) {
-        s += rnd() < 0.2 ? MULTIBYTE[randInt(0, MULTIBYTE.length - 1)] : String.fromCharCode(randInt(97, 122));
-    }
-    return s;
-};
-function run(dec, stream, cuts) {
-    const frames = [];
-    let prev = 0;
-    try {
-        for (const cut of [...cuts, stream.length]) {
-            if (cut <= prev)
-                continue;
-            frames.push(...dec.push(stream.subarray(prev, cut)));
-            prev = cut;
-        }
-        return { frames, err: null };
-    }
-    catch (e) {
-        if (e instanceof FrameOverflowError)
-            return { frames, err: `${e.kind}:${e.bytes}:${e.cap}` };
-        throw e;
-    }
-}
-test('FrameDecoder — behavior-equivalent to the pre-fix decoder across randomized chunkings (frames, blank lines, malformed JSON, multibyte splits, both overflow caps)', () => {
-    for (let t = 0; t < 1500; t++) {
-        // Small caps in ~30% of trials exercise both FrameOverflowError kinds with
-        // identical byte accounting; generous caps exercise the happy path.
-        const caps = rnd() < 0.3
-            ? { maxLineBytes: randInt(50, 1500), maxTotalBytes: randInt(100, 4000) }
-            : { maxLineBytes: 1 << 20, maxTotalBytes: 1 << 21 };
-        const pieces = [];
-        for (let i = 0, n = randInt(1, 12); i < n; i++) {
-            const kind = rnd();
-            if (kind < 0.55)
-                pieces.push(JSON.stringify({ type: 'x', t: randText(randInt(0, 2000)) }) + '\n');
-            else if (kind < 0.7)
-                pieces.push('\n'); // blank-line skip
-            else if (kind < 0.8)
-                pieces.push('   \n'); // whitespace-only skip
-            else if (kind < 0.9)
-                pieces.push('{not json' + randText(randInt(0, 50)) + '\n'); // malformed drop
-            else
-                pieces.push(randText(randInt(0, 300))); // trailing partial, no newline
-        }
-        const stream = Buffer.from(pieces.join(''));
-        // Byte-level cut points — these can and do split multibyte chars.
-        const cuts = Array.from({ length: randInt(0, 20) }, () => randInt(0, stream.length)).sort((a, b) => a - b);
-        const expected = run(new ReferenceFrameDecoder(caps), stream, cuts);
-        const actual = run(new FrameDecoder(caps), stream, cuts);
-        assert.deepEqual(actual, expected, `trial ${t}: caps=${JSON.stringify(caps)} cuts=${JSON.stringify(cuts)} stream=${JSON.stringify(stream.toString('utf8').slice(0, 300))}`);
-    }
-});
-test('FrameDecoder — mixed string/Buffer pushes stay equivalent', () => {
-    for (let t = 0; t < 300; t++) {
-        const caps = { maxLineBytes: 1 << 20, maxTotalBytes: 1 << 21 };
-        const ref = new ReferenceFrameDecoder(caps);
-        const dec = new FrameDecoder(caps);
-        const refF = [];
-        const decF = [];
-        for (let i = 0, n = randInt(1, 10); i < n; i++) {
-            const s = rnd() < 0.5 ? JSON.stringify({ i, t: randText(randInt(0, 200)) }) + '\n' : randText(randInt(0, 100));
-            const input = rnd() < 0.5 ? s : Buffer.from(s);
-            refF.push(...ref.push(input));
-            decF.push(...dec.push(input));
-        }
-        assert.deepEqual(decF, refF, `mixed trial ${t}`);
-    }
-});
-test('FrameDecoder — a frame exactly AT each cap passes; one byte over throws (cap accounting exact)', () => {
-    // line cap: an unterminated partial exactly at maxLineBytes is fine…
-    {
-        const caps = { maxLineBytes: 100, maxTotalBytes: 1000 };
-        const dec = new FrameDecoder(caps);
-        assert.deepEqual(dec.push('x'.repeat(100)), []);
-        // …and the 101st byte trips it, reporting the full buffered size.
-        assert.throws(() => dec.push('x'), (e) => e instanceof FrameOverflowError && e.kind === 'line' && e.bytes === 101 && e.cap === 100);
-    }
-    // total cap: carry + chunk exactly at maxTotalBytes is fine; one over throws.
-    {
-        const caps = { maxLineBytes: 1000, maxTotalBytes: 100 };
-        const dec = new FrameDecoder(caps);
-        assert.deepEqual(dec.push('x'.repeat(60)), []);
-        assert.deepEqual(dec.push('x'.repeat(40 - 60 > 0 ? 0 : 40)), []); // 60 + 40 = 100, at cap
-        assert.throws(() => dec.push('x'), (e) => e instanceof FrameOverflowError && e.kind === 'total' && e.bytes === 101 && e.cap === 100);
-    }
-    // multibyte accounting: bytes, not chars (é = 2 bytes).
-    {
-        const caps = { maxLineBytes: 10, maxTotalBytes: 1000 };
-        const dec = new FrameDecoder(caps);
-        assert.throws(() => dec.push('é'.repeat(6)), // 12 bytes > 10, only 6 chars
-        (e) => e instanceof FrameOverflowError && e.kind === 'line' && e.bytes === 12);
-    }
-});
-test('FrameDecoder — large-frame decode is linear, not quadratic (the observed attach-lag regression)', () => {
-    // STRATEGY (contention-robust SCALING assertion): decode a single frame in
-    // 64 KiB socket-sized chunks at two sizes 4× apart (4 MiB vs 16 MiB) and assert
-    // the per-MiB cost stays ~flat. A linear decoder has per-MiB cost independent of
-    // size (ratio ≈ 1); the O(n²) bug makes per-MiB cost grow with size, so over a 4×
-    // size jump it grows ~4× (measured 5.5×+ pre-fix). Threshold 3× sits cleanly
-    // between the two signatures: well above linear noise, well below the quadratic
-    // signature.
-    //
-    // Why a RATIO, not an absolute wall-clock budget: an absolute budget is fragile
-    // under the parallel `test:full` workers — CPU contention scales every
-    // measurement up, so a tight budget flakes red on a loaded box without any code
-    // regression. A ratio of two contention-scaled measurements cancels whole-box
-    // slowdown, leaving only the algorithmic shape. Two further guards keep the
-    // minima clean under load: (1) MIN across REPS — contention only ADDS time, so
-    // the minimum approximates the uncontended cost; (2) the two sizes are timed
-    // INTERLEAVED within each rep, so a contention burst inflates both numerator and
-    // denominator alike instead of skewing the ratio. This fails ONLY on a
-    // complexity regression, not on a slow/busy CI box.
-    const CHUNK = 64 * 1024;
-    const SMALL_MIB = 4;
-    const LARGE_MIB = 16; // 4× SMALL — quadratic ⇒ per-MiB ~4×; linear ⇒ ~1×
-    const REPS = 7;
-    const makeFrame = (mib) => {
-        const overhead = Buffer.byteLength('{"type":"welcome","blob":""}\n');
-        return Buffer.from(`{"type":"welcome","blob":"${'x'.repeat(mib * 1024 * 1024 - overhead)}"}\n`);
-    };
-    const smallFrame = makeFrame(SMALL_MIB);
-    const largeFrame = makeFrame(LARGE_MIB);
-    const decodeMs = (frame) => {
-        const dec = new FrameDecoder(CLIENT_READ_CAPS);
-        const t0 = performance.now();
-        let n = 0;
-        for (let off = 0; off < frame.length; off += CHUNK) {
-            n += dec.push(frame.subarray(off, Math.min(off + CHUNK, frame.length))).length;
-        }
-        const ms = performance.now() - t0;
-        assert.equal(n, 1, 'decoded exactly one frame');
-        return ms;
-    };
-    decodeMs(smallFrame); // warm JIT on both paths before timing
-    decodeMs(largeFrame);
-    let bestSmall = Infinity;
-    let bestLarge = Infinity;
-    for (let rep = 0; rep < REPS; rep++) {
-        bestSmall = Math.min(bestSmall, decodeMs(smallFrame));
-        bestLarge = Math.min(bestLarge, decodeMs(largeFrame));
-    }
-    const perMibSmall = bestSmall / SMALL_MIB;
-    const perMibLarge = bestLarge / LARGE_MIB;
-    assert.ok(perMibLarge < perMibSmall * 3, `per-MiB decode cost grew superlinearly: ${perMibSmall.toFixed(2)}ms/MiB @${SMALL_MIB}MiB → ${perMibLarge.toFixed(2)}ms/MiB @${LARGE_MIB}MiB (ratio ${(perMibLarge / perMibSmall).toFixed(2)}×; quadratic regression)`);
-});