@crouton-kit/crouter 0.3.33 → 0.3.34

package/dist/clients/attach/__tests__/titled-editor.test.js

@@ -1,60 +0,0 @@
-// Regression: TitledEditor's top border dropped the git-info chip only when the
-// title chip left fewer than 4 free columns — when BOTH chips fit individually
-// but their sum exceeded the terminal width, the fill clamped to 0 and the line
-// came out chipW+infoW wide. pi-tui hard-crashes on any over-wide line:
-//   "Error: Rendered line 3192 exceeds terminal width (75 > 70)"
-// (title chip " ⬢ general (base) continue-crouter-development 0 " = 50 cols,
-// info "crouter · ⎇ main · ●⇡5⇣1" = 25 cols, terminal 70). The fix truncates
-// the info chip to the space the title leaves instead of all-or-nothing.
-// See composeTopBorder in src/clients/attach/titled-editor.ts.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { visibleWidth } from '@earendil-works/pi-tui';
-import { composeTopBorder, thinkingBorderColor, thinkingTitleStyle } from '../titled-editor.js';
-const titleStyle = (s) => `\x1b[7m ${s} \x1b[27m`;
-const borderColor = (s) => `\x1b[38;2;128;128;128m${s}\x1b[39m`;
-const compose = (width, title, info) => composeTopBorder(width, title, info, titleStyle, borderColor);
-test('crash scenario: chip + info that each fit but overflow together stays at width', () => {
-    const title = '⬢ general (base) continue-crouter-development 0'; // chip = 50 cols
-    const info = `\x1b[38;2;128;128;128mcrouter · \x1b[39m\x1b[38;2;129;162;190m⎇ main\x1b[39m\x1b[38;2;128;128;128m · \x1b[39m\x1b[33m●\x1b[39m⇡5⇣1`; // 25 cols
-    const line = compose(70, title, info);
-    assert.equal(visibleWidth(line), 70, 'line must be exactly terminal width, not 75');
-});
-test('top border never exceeds width across title/info length combinations', () => {
-    const longInfo = `\x1b[33m${'status-info-'.repeat(8)}\x1b[39m`;
-    for (const width of [20, 40, 70, 120]) {
-        for (const title of ['', 'a', 'session', 'x'.repeat(200)]) {
-            for (const info of ['', 'crouter · main', longInfo]) {
-                const line = compose(width, title, info);
-                assert.ok(visibleWidth(line) <= width, `overflow at width=${width} titleLen=${title.length} infoW=${visibleWidth(info)}: got ${visibleWidth(line)}`);
-            }
-        }
-    }
-});
-test('info chip survives intact when there is room for it', () => {
-    const info = 'crouter · main';
-    const line = compose(80, 'sess', info);
-    assert.ok(line.includes(info), 'fitting info must not be truncated or dropped');
-    assert.equal(visibleWidth(line), 80);
-});
-test('thinking levels use an evenly spaced blue→orange scale', () => {
-    const cases = [
-        ['minimal', '38;2;68;120;228', '48;2;68;120;228'],
-        ['low', '38;2;108;128;188', '48;2;108;128;188'],
-        ['medium', '38;2;148;136;148', '48;2;148;136;148'],
-        ['high', '38;2;188;144;108', '48;2;188;144;108'],
-        ['xhigh', '38;2;228;152;68', '48;2;228;152;68'],
-    ];
-    const borderRgb = new Set();
-    const titleRgb = new Set();
-    for (const [level, border, title] of cases) {
-        const borderColor = thinkingBorderColor(level, (s) => s);
-        const titleStyle = thinkingTitleStyle(level, (s) => s);
-        assert.match(composeTopBorder(24, 'sess', '', (s) => s, borderColor), new RegExp(`\\x1b\\[${border}m`), `${level} border should use ${border}`);
-        assert.match(titleStyle('sess'), new RegExp(`\\x1b\\[${title}m`), `${level} title should use ${title}`);
-        borderRgb.add(border);
-        titleRgb.add(title);
-    }
-    assert.equal(borderRgb.size, cases.length, 'every thinking level needs its own border step');
-    assert.equal(titleRgb.size, cases.length, 'every thinking level needs its own title step');
-});

package/dist/commands/memory/__tests__/lint-schema.test.js

@@ -1,52 +0,0 @@
-// Bug-regression: guards the hard cut that merged the substrate's `when`/`why`
-// frontmatter pair into the single `when-and-why-to-read` read-routing field.
-// The CTO ruling (taste/why-field-means-why-to-read) requires the migration be
-// a hard cut: an old-shape doc must FAIL at `crtr memory lint`, never be read at
-// runtime. `lintSubstrateSchema` is that enforcement seam — these lock it.
-//
-// Run: node --import tsx/esm --test src/commands/memory/__tests__/lint-schema.test.ts
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { lintSubstrateSchema } from '../lint.js';
-const ROUTING = 'When you are X, this reference should be read because Y';
-const RUNGS = { 'system-prompt-visibility': 'name', 'file-read-visibility': 'none' };
-test('lint rejects a doc still carrying the retired `when` key', () => {
-    const err = lintSubstrateSchema({ kind: 'knowledge', when: 'when X' });
-    assert.ok(err !== null, 'old-shape `when` must produce a finding');
-    assert.match(err, /when-and-why-to-read/, 'the message points at the new field');
-});
-test('lint rejects a doc still carrying the retired `why` key', () => {
-    const err = lintSubstrateSchema({ kind: 'knowledge', why: 'because Y' });
-    assert.ok(err !== null, 'old-shape `why` must produce a finding');
-    assert.match(err, /when-and-why-to-read/, 'the message points at the new field');
-});
-test('lint rejects a substrate doc missing the merged routing field', () => {
-    const err = lintSubstrateSchema({ kind: 'knowledge' });
-    assert.ok(err !== null, 'a substrate doc must carry when-and-why-to-read');
-    assert.match(err, /when-and-why-to-read/);
-});
-test('lint accepts the merged new-shape frontmatter', () => {
-    assert.equal(lintSubstrateSchema({ kind: 'knowledge', 'when-and-why-to-read': ROUTING, ...RUNGS }), null);
-});
-// Visibility is a required, case-by-case authoring call — there is no kind
-// default. lint must reject a doc that omits either rung (the runtime parser
-// silently floors a missing rung to `none`, which is exactly the tolerance this
-// gate exists to catch at authoring time).
-test('lint rejects a substrate doc missing system-prompt-visibility', () => {
-    const err = lintSubstrateSchema({
-        kind: 'knowledge',
-        'when-and-why-to-read': ROUTING,
-        'file-read-visibility': 'none',
-    });
-    assert.ok(err !== null, 'a missing rung must produce a finding');
-    assert.match(err, /missing system-prompt-visibility/);
-});
-test('lint rejects a substrate doc missing file-read-visibility', () => {
-    const err = lintSubstrateSchema({
-        kind: 'knowledge',
-        'when-and-why-to-read': ROUTING,
-        'system-prompt-visibility': 'name',
-    });
-    assert.ok(err !== null, 'a missing rung must produce a finding');
-    assert.match(err, /missing file-read-visibility/);
-});

package/dist/core/__tests__/argv-parser.test.js

@@ -1,217 +0,0 @@
-// Framework tests for the argv parser and help renderer (inputModel: 'argv').
-// Run with: node --import tsx/esm --test src/core/__tests__/argv-parser.test.ts
-// These tests exercise parseArgv and renderLeafArgv directly — no process.argv
-// mutation, no subprocess spawning.
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import { parseArgv } from '../command.js';
-import { renderLeafArgv } from '../help.js';
-import { defineLeaf } from '../command.js';
-// ---------------------------------------------------------------------------
-// parseArgv — flags
-// ---------------------------------------------------------------------------
-describe('parseArgv: flags', () => {
-    const params = [
-        { kind: 'flag', name: 'plan-id', type: 'string', required: true, constraint: 'Plan id.' },
-        { kind: 'flag', name: 'limit', type: 'int', required: false, constraint: 'Max results.', default: 20 },
-        { kind: 'flag', name: 'follow', type: 'bool', required: false, constraint: 'Stream.' },
-        { kind: 'flag', name: 'status', type: 'enum', choices: ['draft', 'done'], required: false, constraint: 'Filter.' },
-    ];
-    test('parses --flag value form', async () => {
-        const result = await parseArgv(params, ['--plan-id', 'abc123']);
-        assert.equal(result['planId'], 'abc123');
-    });
-    test('parses --flag=value form', async () => {
-        const result = await parseArgv(params, ['--plan-id=abc123']);
-        assert.equal(result['planId'], 'abc123');
-    });
-    test('parses int flag', async () => {
-        const result = await parseArgv(params, ['--plan-id', 'x', '--limit', '42']);
-        assert.equal(result['limit'], 42);
-    });
-    test('rejects non-integer for int flag', async () => {
-        await assert.rejects(() => parseArgv(params, ['--plan-id', 'x', '--limit', 'notanint']), (err) => { assert.match(err.message, /must be an integer/); return true; });
-    });
-    test('bool flag: presence = true', async () => {
-        const result = await parseArgv(params, ['--plan-id', 'x', '--follow']);
-        assert.equal(result['follow'], true);
-    });
-    test('bool flag: absence = default false', async () => {
-        const result = await parseArgv(params, ['--plan-id', 'x']);
-        assert.equal(result['follow'], false);
-    });
-    test('bool flag rejects --flag=value', async () => {
-        await assert.rejects(() => parseArgv(params, ['--plan-id', 'x', '--follow=true']), (err) => { assert.match(err.message, /takes no value/); return true; });
-    });
-    test('enum flag: valid value passes', async () => {
-        const result = await parseArgv(params, ['--plan-id', 'x', '--status', 'draft']);
-        assert.equal(result['status'], 'draft');
-    });
-    test('enum flag: invalid value throws invalid_type', async () => {
-        await assert.rejects(() => parseArgv(params, ['--plan-id', 'x', '--status', 'unknown']), (err) => { assert.match(err.message, /must be one of/); return true; });
-    });
-    test('int flag default applied when absent', async () => {
-        const result = await parseArgv(params, ['--plan-id', 'x']);
-        assert.equal(result['limit'], 20);
-    });
-    test('unknown flag throws unknown_flag', async () => {
-        await assert.rejects(() => parseArgv(params, ['--plan-id', 'x', '--bogus', 'y']), (err) => { assert.match(err.message, /unknown flag/); return true; });
-    });
-    test('missing required flag throws missing_parameter', async () => {
-        await assert.rejects(() => parseArgv(params, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('kebab-case flag name becomes camelCase key', async () => {
-        const result = await parseArgv(params, ['--plan-id', 'abc']);
-        assert.ok('planId' in result);
-        assert.ok(!('plan-id' in result));
-    });
-});
-// ---------------------------------------------------------------------------
-// parseArgv — positional
-// ---------------------------------------------------------------------------
-describe('parseArgv: positional', () => {
-    const params = [
-        { kind: 'positional', name: 'job-id', required: true, constraint: 'Job id.' },
-        { kind: 'flag', name: 'follow', type: 'bool', required: false, constraint: '' },
-    ];
-    test('parses single positional before flags', async () => {
-        const result = await parseArgv(params, ['job-abc', '--follow']);
-        assert.equal(result['jobId'], 'job-abc');
-        assert.equal(result['follow'], true);
-    });
-    test('parses single positional after flags', async () => {
-        const result = await parseArgv(params, ['--follow', 'job-abc']);
-        assert.equal(result['jobId'], 'job-abc');
-    });
-    test('parses positional after bare --', async () => {
-        const result = await parseArgv(params, ['--', 'job-abc']);
-        assert.equal(result['jobId'], 'job-abc');
-    });
-    test('two positionals throws bad_invocation', async () => {
-        await assert.rejects(() => parseArgv(params, ['job-abc', 'extra']), (err) => { assert.match(err.message, /unexpected extra positional/); return true; });
-    });
-    test('missing required positional throws missing_parameter', async () => {
-        await assert.rejects(() => parseArgv(params, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('positional when none declared throws bad_invocation', async () => {
-        const noPos = [
-            { kind: 'flag', name: 'name', type: 'string', required: false, constraint: '' },
-        ];
-        await assert.rejects(() => parseArgv(noPos, ['somevalue']), (err) => { assert.match(err.message, /takes no positional/); return true; });
-    });
-});
-// ---------------------------------------------------------------------------
-// parseArgv — stdin satisfied by a positional argument
-// ---------------------------------------------------------------------------
-describe('parseArgv: stdin-as-positional', () => {
-    const params = [
-        { kind: 'stdin', name: 'prompt', required: true, constraint: 'Task.' },
-        { kind: 'flag', name: 'agent', type: 'string', required: false, default: 'general', constraint: '' },
-    ];
-    test('a positional token satisfies a stdin param', async () => {
-        const result = await parseArgv(params, ['--agent', 'general', 'Say hi']);
-        assert.equal(result['prompt'], 'Say hi');
-        assert.equal(result['agent'], 'general');
-    });
-    test('positional-as-stdin works with the positional before flags', async () => {
-        const result = await parseArgv(params, ['Say hi', '--agent', 'general']);
-        assert.equal(result['prompt'], 'Say hi');
-    });
-});
-// ---------------------------------------------------------------------------
-// parseArgv — context-file
-// ---------------------------------------------------------------------------
-describe('parseArgv: context-file', () => {
-    test('unknown --context-file when not declared throws unknown_flag', async () => {
-        const params = [];
-        await assert.rejects(() => parseArgv(params, ['--context-file', '/some/path']), (err) => { assert.match(err.message, /unknown flag: --context-file/); return true; });
-    });
-    test('--context-file missing PATH throws missing_parameter', async () => {
-        const params = [
-            { kind: 'context-file', name: 'context', required: false, constraint: '' },
-        ];
-        await assert.rejects(() => parseArgv(params, ['--context-file']), (err) => { assert.match(err.message, /requires a PATH/); return true; });
-    });
-    test('--context-file with nonexistent file throws invalid_type', async () => {
-        const params = [
-            { kind: 'context-file', name: 'context', required: false, constraint: '' },
-        ];
-        await assert.rejects(() => parseArgv(params, ['--context-file', '/no/such/file/xyz.json']), (err) => { assert.match(err.message, /cannot read file/); return true; });
-    });
-});
-// ---------------------------------------------------------------------------
-// renderLeafArgv — help format
-// ---------------------------------------------------------------------------
-describe('renderLeafArgv: help format', () => {
-    const help = {
-        name: 'task claim',
-        summary: 'claim a draft task and spawn a worker',
-        params: [
-            { kind: 'positional', name: 'task-id', required: true, constraint: 'Task in draft state.' },
-            { kind: 'flag', name: 'worker', type: 'string', required: false, constraint: 'Worker template.' },
-            { kind: 'flag', name: 'follow', type: 'bool', required: false, constraint: 'Stream output.' },
-            { kind: 'context-file', name: 'context', required: false, constraint: 'Extra facts for the worker.', shape: '{key: string}' },
-        ],
-        output: [
-            { name: 'job_id', type: 'string', required: true, constraint: 'Use with crtr job logs.' },
-        ],
-        outputKind: 'object',
-        effects: ['Marks task claimed.'],
-    };
-    test('starts with name: summary', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.startsWith('task claim: claim a draft task and spawn a worker.'));
-    });
-    test('contains Input section', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.includes('Input'));
-    });
-    test('positional shown as TASK_ID', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.includes('TASK-ID'));
-    });
-    test('bool flag shown without VALUE placeholder', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.includes('--follow'));
-        assert.ok(!out.includes('--follow FOLLOW'));
-    });
-    test('string flag shown with VALUE placeholder', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.includes('--worker WORKER'));
-    });
-    test('context-file shown as --context-file PATH', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.includes('--context-file PATH'));
-    });
-    test('contains Output section', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.includes('Output (fields carried in the rendered result)'));
-    });
-    test('contains Effects section', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.includes('Effects'));
-        assert.ok(out.includes('Marks task claimed.'));
-    });
-});
-// ---------------------------------------------------------------------------
-// defineLeaf
-// ---------------------------------------------------------------------------
-describe('defineLeaf', () => {
-    test('builds a leaf with the declared params', () => {
-        const leaf = defineLeaf({
-            name: 'test',
-            help: {
-                name: 'test',
-                summary: 'test leaf',
-                params: [],
-                output: [],
-                outputKind: 'object',
-                effects: [],
-            },
-            run: async () => { },
-        });
-        assert.equal(leaf.kind, 'leaf');
-        assert.equal(leaf.name, 'test');
-        assert.deepEqual(leaf.help.params, []);
-    });
-});

package/dist/core/__tests__/artifact-paths.test.js

@@ -1,44 +0,0 @@
-import { test, before, beforeEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, mkdirSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { interactionsRoot, migrateLegacyWorkspaceDirs, workspaceRoot } from '../artifact.js';
-let home;
-let origHome;
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-workspaces-'));
-    origHome = process.env['HOME'];
-    process.env['HOME'] = home;
-});
-beforeEach(() => {
-    rmSync(home, { recursive: true, force: true });
-    mkdirSync(join(home, '.crouter'), { recursive: true });
-});
-after(() => {
-    rmSync(home, { recursive: true, force: true });
-    if (origHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = origHome;
-});
-test('workspace roots live under ~/.crouter/workspaces/<mangled-cwd>', () => {
-    const cwd = '/Users/silasrhyneer/Code/cli/crouter';
-    const root = join(home, '.crouter', 'workspaces', '-Users-silasrhyneer-Code-cli-crouter');
-    assert.equal(workspaceRoot(cwd), root);
-    assert.equal(interactionsRoot(cwd), join(root, 'interactions'));
-});
-test('migrateLegacyWorkspaceDirs moves only legacy mangled cwd dirs', () => {
-    const legacy = join(home, '.crouter', '-Users-silasrhyneer-Code-cli-crouter');
-    const workspace = join(home, '.crouter', 'workspaces', '-Users-silasrhyneer-Code-cli-crouter');
-    const memory = join(home, '.crouter', 'memory');
-    const canvas = join(home, '.crouter', 'canvas');
-    mkdirSync(legacy, { recursive: true });
-    mkdirSync(memory, { recursive: true });
-    mkdirSync(canvas, { recursive: true });
-    migrateLegacyWorkspaceDirs();
-    assert.ok(!existsSync(legacy));
-    assert.ok(existsSync(workspace));
-    assert.ok(existsSync(memory));
-    assert.ok(existsSync(canvas));
-});

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