@north-light/crouter 0.3.317 → 0.3.319

package/dist/clients/__tests__/helpers/human-daemon.d.ts

@@ -1,11 +0,0 @@
-export interface HumanDaemon {
-    /** The isolated canvas home, and the value of both `CRTR_HOME` and `HOME`. */
-    home: string;
-    /** A scratch directory for the page sources a fixture authors. */
-    sources: string;
-    dispose(): Promise<void>;
-}
-/** Bind the human routes on an isolated home's socket. Every environment
- *  change is undone by `dispose`, so a fixture can run beside the developer's
- *  own canvas without touching it. */
-export declare function startHumanDaemon(prefix: string): Promise<HumanDaemon>;

package/dist/clients/__tests__/helpers/human-daemon.js

@@ -1,60 +0,0 @@
-// A crtrd the human client surfaces can actually talk to.
-//
-// The inbox and the attach viewer now read every page and request over the
-// daemon's human routes, so a fixture that exercises them needs a daemon on the
-// socket `cliClient()` resolves. It gets the REAL route tables rather than a
-// re-implementation: the projections under test are the daemon's, and a second
-// copy of them in a fixture would pass while the shipped ones drifted.
-//
-// The routes read an on-disk canvas, so the helper also stands up an isolated
-// home with the canvas schema and the scope store crtrd installs at startup —
-// opening a page resolves its components from scope settings rooted at HOME.
-import { createServer } from 'node:http';
-import { mkdtempSync, realpathSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { migrate, openDb } from '#core/canvas/db';
-import { resetScopeCache } from '#core/scope';
-import { initializeFreshScopedStore } from '#core/scoped-state/migrate';
-import { Router } from '#daemon/api/router';
-import { humanRequestRoutes } from '#daemon/api/handlers/human-requests';
-import { inboxRoutes } from '#daemon/api/handlers/inbox';
-/** Bind the human routes on an isolated home's socket. Every environment
- *  change is undone by `dispose`, so a fixture can run beside the developer's
- *  own canvas without touching it. */
-export async function startHumanDaemon(prefix) {
-    // Canonical, because a request row stores its directory as given while every
-    // read path resolves one first: a home behind a symlink (every macOS tmpdir)
-    // would make the two disagree.
-    const home = realpathSync(mkdtempSync(join(tmpdir(), `${prefix}-`)));
-    const sources = mkdtempSync(join(tmpdir(), `${prefix}-src-`));
-    const previousHome = process.env['HOME'];
-    const previousCrtrHome = process.env['CRTR_HOME'];
-    process.env['HOME'] = home;
-    process.env['CRTR_HOME'] = home;
-    resetScopeCache();
-    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
-    migrate(openDb());
-    const router = new Router().registerAll(inboxRoutes).registerAll(humanRequestRoutes);
-    const server = createServer((req, res) => { void router.handle(req, res); });
-    await new Promise((resolve) => server.listen(join(home, 'crtrd.sock'), resolve));
-    return {
-        home,
-        sources,
-        async dispose() {
-            server.closeAllConnections();
-            await new Promise((resolve) => server.close(() => resolve()));
-            rmSync(home, { recursive: true, force: true });
-            rmSync(sources, { recursive: true, force: true });
-            if (previousCrtrHome === undefined)
-                delete process.env['CRTR_HOME'];
-            else
-                process.env['CRTR_HOME'] = previousCrtrHome;
-            if (previousHome === undefined)
-                delete process.env['HOME'];
-            else
-                process.env['HOME'] = previousHome;
-            resetScopeCache();
-        },
-    };
-}

package/dist/clients/attach/__tests__/attach-remote-readonly.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/clients/attach/__tests__/attach-remote-readonly.test.js

@@ -1,97 +0,0 @@
-// attach-remote-readonly.test.ts — a REMOTE attach
-// (`crtr surface attach --canvas <name>`) must be a strictly VIEW-ONLY
-// surface. Two defenses are proven here:
-//
-//   A. input/controller.ts's central `emitCommand` choke point — the REAL
-//      InputController (constructed against fakes, not stubbed out) never
-//      lets a drive frame reach `hooks.onCommand`, for every input path
-//      (submit, `!bash`, Esc-abort, every direct keybinding, and dequeue).
-//      The same paths emit normally when remote is false, proving the guard
-//      is conditional rather than a dead wiring.
-//   B. viewer.ts's `resolveHelloRole` — the hello handshake always claims
-//      'observer' for a remote attach, regardless of `--observer`.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { InputController } from '../input/controller.js';
-import { createViewerCapabilities } from '../input/capabilities.js';
-import { resolveHelloRole } from '../session/connection.js';
-function fakeEditor() {
-    const actions = new Map();
-    let text = '';
-    const history = [];
-    const obj = {
-        onSubmit: undefined,
-        onEscape: undefined,
-        onPasteImage: undefined,
-        onAction: (name, cb) => { actions.set(name, cb); },
-        getText: () => text,
-        setText: (t) => { text = t; },
-        addToHistory: (t) => { history.push(t); },
-        insertTextAtCursor: (t) => { text += t; },
-    };
-    return { obj, actions, setText: (t) => { text = t; } };
-}
-function buildController(remote) {
-    const sent = [];
-    const notices = [];
-    const editor = fakeEditor();
-    const tui = {
-        requestRender: () => { },
-        setFocus: () => { },
-        showOverlay: () => ({ hide: () => { } }),
-        start: () => { },
-        stop: () => { },
-    };
-    const ic = new InputController(tui, editor.obj, {}, {
-        onCommand: (f) => sent.push(f),
-        onDialogResponse: () => { },
-        onNotice: (m) => notices.push(m),
-    }, createViewerCapabilities({ role: 'controller', remote, nodeId: 'test', profileId: undefined }));
-    return { ic, editor, sent, notices };
-}
-/** Drive every input path that can produce a broker frame. */
-function driveEveryInputPath(built) {
-    const { ic, editor } = built;
-    editor.setText('');
-    editor.obj.onSubmit('hello'); // → prompt
-    editor.setText('');
-    editor.obj.onSubmit('!ls'); // → bash
-    ic.setState({ isStreaming: true });
-    editor.obj.onEscape(); // → abort
-    editor.actions.get('app.session.new')();
-    editor.actions.get('app.model.cycleForward')();
-    editor.actions.get('app.model.cycleBackward')();
-    editor.actions.get('app.thinking.cycle')();
-}
-test('InputController never emits a drive frame to onCommand when remote is true — every input path', () => {
-    const built = buildController(true);
-    const { editor, sent, notices } = built;
-    driveEveryInputPath(built);
-    assert.equal(sent.length, 0, `remote InputController must never emit a frame, got: ${JSON.stringify(sent)}`);
-    // The gate must have actually fired — proves the hooks weren't simply never wired.
-    assert.ok(notices.some((n) => /Read-only remote attach/.test(n)), `expected a "Read-only remote attach" notice, got: ${JSON.stringify(notices)}`);
-    // `app.message.dequeue` has its own remote guard for a second frame type.
-    notices.length = 0;
-    editor.actions.get('app.message.dequeue')();
-    assert.equal(sent.length, 0, `remote dequeue must never emit a frame, got: ${JSON.stringify(sent)}`);
-    assert.ok(notices.some((n) => /Read-only remote attach/.test(n)), `expected a "Read-only remote attach" notice from dequeue, got: ${JSON.stringify(notices)}`);
-});
-test('InputController emits the same drive frames normally when remote is false (guard is conditional)', () => {
-    const built = buildController(false);
-    const { editor, sent, notices } = built;
-    driveEveryInputPath(built);
-    notices.length = 0;
-    editor.actions.get('app.message.dequeue')();
-    assert.ok(!notices.some((n) => /Read-only remote attach/.test(n)), `local dequeue must not hit the read-only remote notice, got: ${JSON.stringify(notices)}`);
-    const types = sent.map((f) => f.type);
-    for (const expected of ['prompt', 'bash', 'abort', 'new_session', 'cycle_thinking']) {
-        assert.ok(types.includes(expected), `expected ${expected}, got ${JSON.stringify(types)}`);
-    }
-    assert.equal(types.filter((t) => t === 'cycle_model').length, 2, `expected two cycle_model frames, got ${JSON.stringify(types)}`);
-});
-test('resolveHelloRole always claims observer for remote, regardless of --observer', () => {
-    assert.equal(resolveHelloRole(true, false), 'observer');
-    assert.equal(resolveHelloRole(true, true), 'observer');
-    assert.equal(resolveHelloRole(false, false), 'controller');
-    assert.equal(resolveHelloRole(false, true), 'observer');
-});

package/dist/clients/attach/__tests__/bash-call-width.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/clients/attach/__tests__/bash-call-width.test.js

@@ -1,38 +0,0 @@
-// REGRESSION: ctrl+o (expanded tool output) on a bash call whose command is
-// wider than a narrow pane emitted the command line unclipped, so pi-tui's line
-// accounting desynced from the terminal's own wrapping and the viewer crashed
-// with "Rendered line N exceeds terminal width". Expanded bash now wraps into
-// the pane instead of overhanging it.
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { visibleWidth } from '@earendil-works/pi-tui';
-import { createCrtrPlainBashToolDefinition } from '../render/tool-calls.js';
-const theme = {
-    fg(_name, text) { return text; },
-    bg(_name, text) { return text; },
-    bold(text) { return text; },
-};
-function renderExpanded(command, width, timeout) {
-    const def = createCrtrPlainBashToolDefinition('/tmp');
-    const component = def.renderCall({ command, timeout }, theme, { expanded: true, state: {} });
-    return component.render(width);
-}
-const COMMANDS = [
-    'ls -la /Users/silasrhyneer/Code/cli/crouter',
-    'grep -rn "averyveryverylongtokenwithnospacesatallxxxxxxxxxxxxxxxxxxxxxx" src/',
-    `first\nsecond ${'x'.repeat(120)}`,
-];
-test('expanded bash call never renders a line wider than the pane', () => {
-    for (const width of [80, 42, 20, 3, 2, 1]) {
-        for (const command of COMMANDS) {
-            for (const line of renderExpanded(command, width, 120)) {
-                assert.ok(visibleWidth(line) <= width, `width ${width}: line of ${visibleWidth(line)} cols for ${JSON.stringify(command)}`);
-            }
-        }
-    }
-});
-test('expanded bash wraps rather than clipping — the whole command survives', () => {
-    const command = 'ls -la /Users/silasrhyneer/Code/cli/crouter';
-    const joined = renderExpanded(command, 42).map((line) => line.trim()).join(' ');
-    assert.ok(joined.includes('/Users/silasrhyneer/Code/cli/crouter'), joined);
-});

package/dist/clients/attach/__tests__/chat-view-snapshot-ordering.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/clients/attach/__tests__/chat-view-snapshot-ordering.test.js

@@ -1,175 +0,0 @@
-// Regression coverage for the single-writer snapshot ordering in ChatView
-// (render/chat-view.ts). A large NON-streaming catch-up yields to the event loop
-// mid-build so queued stdin drains; that yield window used to let later broker
-// frames mutate a half-rebuilt transcript. The ordering and render-lifecycle
-// regressions pinned here are:
-//
-//   1. Live turn frames arriving during a yielded welcome must be replayed
-//      AFTER the build finishes (not interleaved), and their live activity state
-//      must survive — the resuming build's stale non-streaming completion must
-//      not overwrite it.
-//   2. A second welcome delivered while the first build is suspended must
-//      supersede it outright: the newest snapshot wins and the stale build
-//      abandons itself instead of appending into the replaced transcript.
-//   3. A tool result landing after a snapshot yield must repaint the tool row;
-//      it used to stay cached in its pending state.
-//   4. Rebuilding from a welcome snapshot must settle any live bash component;
-//      otherwise its unmounted Loader keeps requesting renders every 80 ms.
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { Container, TuiMainScreen } from '@earendil-works/pi-tui';
-import { AssistantMessageComponent, UserMessageComponent, initTheme, } from '@earendil-works/pi-coding-agent';
-import { ChatView } from '../render/chat-view.js';
-/** A headless terminal so TUI.requestRender's scheduled writes are no-ops (the
- *  test only inspects component state, never real output). */
-function fakeTerminal() {
-    return {
-        start() { },
-        stop() { },
-        async drainInput() { },
-        write() { },
-        get columns() { return 80; },
-        get rows() { return 24; },
-        get kittyProtocolActive() { return false; },
-        moveBy() { },
-        hideCursor() { },
-        showCursor() { },
-        clearLine() { },
-        clearFromCursor() { },
-        clearScreen() { },
-        setTitle() { },
-        setProgress() { },
-    };
-}
-function makeChatView() {
-    const tui = new TuiMainScreen(fakeTerminal());
-    const container = new Container();
-    const view = new ChatView(tui, container);
-    const internals = view;
-    return { view, historyChildren: () => internals.historyContainer.children, internals };
-}
-/** A non-streaming snapshot of `count` assistant text messages. Enough messages
- *  (>2× SNAPSHOT_YIELD_EVERY) to guarantee the build suspends at least once. */
-function assistantSnapshot(count, tag) {
-    const messages = Array.from({ length: count }, (_, i) => ({
-        role: 'assistant',
-        content: [{ type: 'text', text: `${tag}-${i}` }],
-        stopReason: 'endTurn',
-    }));
-    return {
-        messages,
-        stats: {},
-        state: { isStreaming: false },
-    };
-}
-const countOf = (children, ctor) => children.filter((c) => c instanceof ctor).length;
-initTheme(undefined, false);
-test('live turn frames arriving during a yielded welcome replay after the build and keep live state', async () => {
-    const { view, historyChildren, internals } = makeChatView();
-    // Start a large non-streaming catch-up: it appends the first chunk of
-    // components synchronously, then suspends at the first event-loop yield.
-    const build = view.applySnapshot(assistantSnapshot(120, 'snap'));
-    assert.equal(internals.applyingSnapshot, true, 'build is in flight after the first synchronous chunk');
-    // Live turn frames arrive while the build is suspended — these must be
-    // deferred, not applied to the half-rebuilt view.
-    view.handleEvent({ type: 'agent_start' });
-    view.handleEvent({ type: 'message_start', message: { role: 'user', content: 'LIVE' } });
-    await build;
-    const children = historyChildren();
-    // All 120 snapshot assistant components are present and precede the one live
-    // user message that was deferred and replayed at the tail.
-    assert.equal(countOf(children, AssistantMessageComponent), 120, 'every snapshot message survived the build');
-    assert.equal(countOf(children, UserMessageComponent), 1, 'exactly the one deferred live user message landed');
-    const lastReal = [...children].reverse().find((c) => c instanceof UserMessageComponent || c instanceof AssistantMessageComponent);
-    assert.ok(lastReal instanceof UserMessageComponent, 'the live message is appended AFTER the whole snapshot, not interleaved');
-    // The replayed agent_start owns the final activity state — the resuming
-    // build's stale non-streaming completion did NOT overwrite it.
-    assert.equal(internals.applyingSnapshot, false, 'gate released after the build');
-    assert.notEqual(internals.activityLoader, undefined, 'the working loader from the live agent_start is present');
-    // Cleanup: the live loader runs a spinner interval that would otherwise hold
-    // the event loop (and the test process) open forever.
-    internals.setActivity(undefined);
-});
-test('a second welcome delivered mid-build supersedes the first and the stale build abandons itself', async () => {
-    const { view, historyChildren, internals } = makeChatView();
-    // First large build suspends at its first yield.
-    const first = view.applySnapshot(assistantSnapshot(120, 'first'));
-    assert.equal(internals.snapshotGeneration, 1);
-    // A newer welcome arrives while the first is suspended — resets and rebuilds
-    // synchronously (small, no yield), bumping the generation.
-    const second = view.applySnapshot(assistantSnapshot(3, 'second'));
-    assert.equal(internals.snapshotGeneration, 2, 'the newer welcome opened a new generation');
-    await Promise.all([first, second]);
-    // Only the second snapshot's transcript remains: the stale first build saw the
-    // generation change after resuming and returned without appending its tail.
-    const children = historyChildren();
-    assert.equal(countOf(children, AssistantMessageComponent), 3, 'newest welcome wins; no interleaved stale tail');
-    assert.equal(internals.applyingSnapshot, false, 'gate released');
-});
-test('a tool result after a snapshot yield repaints the tool row instead of staying pending', async () => {
-    const tui = {
-        requestRender() { },
-        terminal: { rows: 24 },
-    };
-    const container = new Container();
-    const view = new ChatView(tui, container);
-    const messages = [
-        {
-            role: 'assistant',
-            content: [{ type: 'toolCall', id: 'tool-1', name: 'unknown', arguments: {} }],
-            stopReason: 'endTurn',
-        },
-        ...Array.from({ length: 49 }, (_, i) => ({
-            role: 'assistant',
-            content: [{ type: 'text', text: `filler-${i}` }],
-            stopReason: 'endTurn',
-        })),
-        {
-            role: 'toolResult',
-            toolCallId: 'tool-1',
-            toolName: 'unknown',
-            content: [{ type: 'text', text: 'RESULT-LANDED' }],
-            isError: false,
-        },
-    ];
-    const build = view.applySnapshot({
-        messages,
-        stats: {},
-        state: { isStreaming: false },
-    });
-    // Render mid-build so the pending tool row lands in the render cache.
-    const pending = container.render(80).join('\n');
-    assert.doesNotMatch(pending, /RESULT-LANDED/, 'the result has not arrived yet mid-build');
-    await build;
-    assert.match(container.render(80).join('\n'), /RESULT-LANDED/, 'completed tool result remained cached as pending');
-});
-test('live bash animation survives history caching and stops on a welcome snapshot', async () => {
-    let renderRequests = 0;
-    const tui = {
-        requestRender: () => { renderRequests += 1; },
-        terminal: { rows: 24 },
-    };
-    const container = new Container();
-    const view = new ChatView(tui, container);
-    view.bashStart('sleep 999');
-    const component = view.bashComponent;
-    try {
-        const firstFrame = container.render(80).join('\n');
-        await new Promise((resolve) => setTimeout(resolve, 120));
-        const nextFrame = container.render(80).join('\n');
-        assert.notEqual(nextFrame, firstFrame, 'history caching froze the live bash animation');
-        await view.applySnapshot({
-            messages: [],
-            stats: {},
-            state: { isStreaming: false },
-        });
-        const settledRenderRequests = renderRequests;
-        await new Promise((resolve) => setTimeout(resolve, 200));
-        assert.equal(renderRequests, settledRenderRequests, 'the unmounted bash loader kept requesting renders');
-    }
-    finally {
-        // Ensure a regression fails cleanly instead of leaving the loader interval
-        // alive until the test runner timeout.
-        component.setComplete(undefined, true);
-    }
-});

package/dist/clients/attach/__tests__/completion-frecency.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/clients/attach/__tests__/completion-frecency.test.js

@@ -1,35 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { CombinedAutocompleteProvider } from '@earendil-works/pi-tui';
-import { RefAwareAutocompleteProvider } from '../input/ref-autocomplete.js';
-const noop = { record() { }, bonus: () => 0 };
-function ref(name) {
-    return { name, kind: 'knowledge', scope: 'user', shortForm: `${name} docs`, gatewayVisible: true };
-}
-const inertDelegate = {
-    async getSuggestions() { return null; },
-    applyCompletion(lines, cursorLine, cursorCol) { return { lines, cursorLine, cursorCol }; },
-    shouldTriggerFileCompletion() { return false; },
-};
-test('acceptance: typing /devnor surfaces northlight:dev via the ref provider', async () => {
-    const refs = [ref('northlight/dev'), ref('northlight/prod'), ref('taste/writing')];
-    const provider = new RefAwareAutocompleteProvider(refs, inertDelegate, noop);
-    const line = 'see /devnor';
-    const caret = line.length;
-    const result = await provider.getSuggestions([line], 0, caret, { signal: new AbortController().signal });
-    assert.ok(result, 'a ref suggestion is returned');
-    const labels = result.items.map((i) => i.label);
-    assert.ok(labels.includes('/northlight:dev'), `expected /northlight:dev, got ${labels.join(', ')}`);
-});
-test('acceptance: typing /devn at the start of the line surfaces the northlight:dev command', async () => {
-    // A memory doc flagged `slash: true` reaches the editor as an ordinary chat
-    // command named with `:` segments. pi-tui filters those by a subsequence over
-    // the raw name, which `devn` cannot satisfy; leaf-first matching can.
-    const commands = [{ name: 'northlight:dev' }, { name: 'reload' }, { name: 'git:pr-loop' }];
-    const provider = new RefAwareAutocompleteProvider([], new CombinedAutocompleteProvider(commands, process.cwd(), null), noop);
-    const line = '/devn';
-    const result = await provider.getSuggestions([line], 0, line.length, { signal: new AbortController().signal });
-    assert.ok(result, 'a command suggestion is returned');
-    assert.equal(result.prefix, line, 'prefix stays the text before the cursor so applyCompletion slices correctly');
-    assert.equal(result.items[0]?.value, 'northlight:dev', `expected northlight:dev first, got ${result.items.map((i) => i.value).join(', ')}`);
-});

package/dist/clients/attach/__tests__/context-message.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/clients/attach/__tests__/context-message.test.js

@@ -1,130 +0,0 @@
-// Regression coverage for the attach viewer's display-only folding of
-// crouter-generated context. Three user-visible hazards are pinned here:
-//
-//   1. A folded row must never leak its body, and Ctrl+O must restore the full
-//      agent-visible content — the fold is display-only, so nothing is lost.
-//   2. A human message that merely reads like runtime recovery prose must NOT
-//      be classified as generated context; folding the user's own message away
-//      is the hazard that misclassification produces.
-//   3. An answer the person typed in their inbox renders as the person
-//      speaking, never as a runtime card.
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { Container } from '@earendil-works/pi-tui';
-import { applyTheme } from '../config.js';
-import { ChatView } from '../render/chat-view.js';
-import { CONTEXT_INTRO_CUSTOM_TYPE, CONTEXT_NUDGE_CUSTOM_TYPE, formatCard, formatInboxCard, formatModelFallbackRecovery, parseCard, } from '../../../shared/generated-context.js';
-applyTheme();
-function chatView(container) {
-    const tui = { requestRender() { }, terminal: { rows: 40 } };
-    return new ChatView(tui, container, { toolOutputExpanded: false });
-}
-test('collapsed generated context never leaks its body; Ctrl+O restores it', async () => {
-    const container = new Container();
-    const view = chatView(container);
-    const internals = view;
-    internals.summarizeToolCalls = true;
-    internals.foldSettledTools = true;
-    internals.showGroupSummaries = true;
-    await view.applySnapshot({
-        messages: [
-            {
-                role: 'custom',
-                customType: CONTEXT_INTRO_CUSTOM_TYPE,
-                display: true,
-                content: formatCard('bearings', {}, '<auto-loaded-context>\nloaded INDEX.md content\n</auto-loaded-context>'),
-            },
-            { role: 'user', content: formatCard('revive', {}, '<yield-message>resume from this note</yield-message>') },
-            { role: 'user', content: formatCard('restart-continuation', {}, 'private restart continuation') },
-            // Pre-envelope custom message from an old session: customType still classifies.
-            {
-                role: 'custom',
-                customType: CONTEXT_NUDGE_CUSTOM_TYPE,
-                display: true,
-                content: '[crtr] Context ~150k. private context reminder',
-            },
-            {
-                role: 'user',
-                content: formatInboxCard([
-                    { id: 'child-node-123', entries: [{ kind: 'update', body: 'private inbox detail' }] },
-                ]),
-            },
-            { role: 'user', content: formatCard('review-approval', {}, 'The human reviewed and approved private-review.md.') },
-        ],
-        stats: {},
-        state: { isStreaming: false },
-    });
-    assert.doesNotMatch(container.render(80).join('\n'), /loaded INDEX\.md content|resume from this note|private restart continuation|private context reminder|private inbox detail|private-review\.md/);
-    assert.deepEqual(view.toggleToolsExpanded(), { kind: 'summaries', shown: false });
-    assert.equal(internals.toolOutputExpanded, true);
-    const expanded = container.render(80).join('\n');
-    assert.match(expanded, /loaded INDEX\.md content/);
-    assert.match(expanded, /resume from this note/);
-    assert.doesNotMatch(expanded, /private restart continuation/, 'a continuation card has no body worth disclosing');
-    assert.match(expanded, /private context reminder/, 'an expanded nudge shows the band it fired at');
-    // The terminal may wrap mid-phrase (ANSI runs land between words), so match
-    // across the wrap instead of requiring the phrase on one line.
-    assert.match(expanded, /private inbox[\s\S]{0,200}detail/, 'an expanded inbox card shows the actual delivered update');
-    assert.match(expanded, /private-review\.md/, 'an expanded review card shows the approval');
-    assert.deepEqual(view.toggleToolsExpanded(), { kind: 'summaries', shown: true });
-    assert.equal(internals.toolOutputExpanded, false);
-    assert.doesNotMatch(container.render(80).join('\n'), /loaded INDEX\.md content|resume from this note|private restart continuation|private context reminder|private inbox/);
-});
-test('an expanded inbox card renders its senders and entries, not its markup', async () => {
-    const container = new Container();
-    const view = chatView(container);
-    await view.applySnapshot({
-        messages: [{
-                role: 'user',
-                content: formatInboxCard([
-                    {
-                        id: 'child-node-123',
-                        entries: [
-                            { kind: 'update', body: 'halfway through the migration' },
-                            { kind: 'final', ref: '/tmp/report.md', body: 'migration landed' },
-                        ],
-                    },
-                ]),
-            }],
-        stats: {},
-        state: { isStreaming: false },
-    });
-    view.toggleToolsExpanded();
-    const expanded = container.render(80).join('\n');
-    assert.match(expanded, /child-node-123/);
-    assert.match(expanded, /migration landed/);
-    assert.match(expanded, /report\.md/, 'a final names the report it points at');
-    assert.doesNotMatch(expanded, /<from|<entry/, 'the digest is rendered, never shown as markup');
-});
-test('a human message that reads like runtime recovery is not folded as generated context', () => {
-    assert.equal(parseCard({ role: 'user', content: 'continue' }), null, 'a human one-word continue is not mistaken for runtime recovery');
-    // The producer's envelope, not the prose, is what classifies a message. Strip
-    // the envelope off a real recovery body and it must read as a human message.
-    const guidance = formatModelFallbackRecovery('custom(provider)/model', 'new/model:high', 'not-found');
-    const recovery = formatCard('recovery', { reason: 'model-fallback' }, guidance);
-    assert.equal(parseCard({ role: 'user', content: recovery })?.kind, 'recovery');
-    assert.equal(parseCard({ role: 'user', content: guidance }), null, 'a human message matching the recovery prose lacks the envelope');
-    assert.equal(parseCard({ role: 'user', content: 'The human reviewed and approved private-review.md.' }), null, 'a human message matching the approval prose lacks the envelope');
-});
-test("a person's inbox answer renders as their own message, not a runtime card", async () => {
-    const container = new Container();
-    const view = chatView(container);
-    await view.applySnapshot({
-        messages: [
-            {
-                role: 'user',
-                content: formatInboxCard([
-                    {
-                        id: 'human-ticket-node',
-                        entries: [{ kind: 'final', disposition: 'human-answer', body: 'ship it on friday' }],
-                    },
-                ]),
-            },
-        ],
-        stats: {},
-        state: { isStreaming: false },
-    });
-    const rendered = container.render(80).join('\n');
-    assert.match(rendered, /ship it on friday/, "the person's words show without expanding anything");
-    assert.doesNotMatch(rendered, /crtr inbox|ctrl\+o/, 'an answer-only digest gets no card');
-});

package/dist/clients/attach/__tests__/crtr-output.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/clients/attach/__tests__/crtr-output.test.js

@@ -1,68 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { visibleWidth } from '@earendil-works/pi-tui';
-import { createCrtrBashToolDefinition, isCrtrBashCommand, isCrtrHelpInvocation, } from '../render/crtr-output.js';
-const theme = {
-    // `text` and `dim` are the preview's base hierarchy roles; leave them
-    // transparent here so assertions can still match the underlying receipt.
-    fg(name, text) { return name === 'text' || name === 'dim' ? text : `<${name}>${text}</${name}>`; },
-    bg(_name, text) { return text; },
-    bold(text) { return `<b>${text}</b>`; },
-};
-/** pi calls tool renderers with a shared state bag; a normal (unfolded) call has an empty one. */
-function renderCall(command) {
-    const definition = createCrtrBashToolDefinition({ command })?.definition;
-    return definition.renderCall({ command }, theme, { state: {} }).render(80).join('\n');
-}
-function renderResult(command, text, expanded) {
-    const definition = createCrtrBashToolDefinition({ command })?.definition;
-    return definition.renderResult({ content: [{ type: 'text', text }] }, { expanded }, theme, {}).render(70);
-}
-test('detects crtr in bash command position, not heredoc body prose', () => {
-    assert.equal(isCrtrBashCommand('crtr node new -h'), true);
-    assert.equal(isCrtrBashCommand('crtr node inspect snapshot --node abc'), true);
-    assert.equal(isCrtrBashCommand('npm test && /usr/local/bin/crouter surface attach to node-1'), true);
-    assert.equal(isCrtrBashCommand("cat <<'EOF'\nask about crtr node new\nEOF\necho done"), false);
-    assert.equal(isCrtrBashCommand('echo crtr node new'), false);
-});
-// Help output is structural schema text, never a command result, so the viewer
-// detects it from the invocation itself. Detection is scoped to the extracted
-// crtr segment's own tokens, with quote boundaries respected and outer shell
-// redirects treated as plumbing — so unrelated siblings, quoted prompt text,
-// and redirect targets neither trip help chrome nor leak into the shown path.
-test('scopes -h/--help detection and the displayed path to the crtr invocation\'s own argv', () => {
-    assert.equal(isCrtrHelpInvocation('crtr node new -h'), true);
-    assert.equal(isCrtrHelpInvocation('crtr node inspect snapshot --node abc --help'), true);
-    assert.equal(isCrtrHelpInvocation('crtr canvas dashboard'), false);
-    assert.equal(isCrtrHelpInvocation('echo crtr node new -h'), false);
-    assert.equal(isCrtrHelpInvocation('echo -h && crtr canvas snapshot'), false);
-    assert.equal(isCrtrHelpInvocation('crtr canvas snapshot && echo --help'), false);
-    assert.equal(isCrtrHelpInvocation('crtr node new "write about -h flags"'), false);
-    assert.equal(isCrtrHelpInvocation('crtr push -h 2>&1'), true);
-    const redirected = renderCall('crtr push -h 2>&1');
-    assert.match(redirected, /<b>push<\/b>/);
-    assert.doesNotMatch(redirected, /2>|>&1/);
-    // Redirect operators glued to their target with no space are plumbing too,
-    // mid-argv as well as trailing.
-    const midArgv = renderCall('crtr node new --name foo >/tmp/log 2>&1');
-    assert.match(midArgv, /node new --name foo/);
-    assert.doesNotMatch(midArgv, /tmp\/log|2>/);
-});
-test('crtr results do not invalidate their owning tool component', () => {
-    let ownerInvalidations = 0;
-    const def = createCrtrBashToolDefinition({ command: 'crtr canvas dashboard' })?.definition;
-    const component = def.renderResult({ content: [{ type: 'text', text: 'dashboard' }] }, { expanded: false }, theme, { invalidate: () => { ownerInvalidations++; } });
-    component.invalidate?.();
-    assert.equal(ownerInvalidations, 0);
-});
-// Pane-overflow invariant: a rendered line wider than the pane breaks the
-// viewer's frame-length guarantee, expanded or collapsed.
-test('crtr output clamps long lines to the terminal width, expanded and collapsed', () => {
-    for (const expanded of [true, false]) {
-        const lines = renderResult('crtr canvas dashboard', 'x'.repeat(442), expanded);
-        assert.ok(lines.length > 0);
-        for (const line of lines) {
-            assert.ok(visibleWidth(line) <= 70, `line exceeded width (expanded=${expanded}): ${visibleWidth(line)} > 70`);
-        }
-    }
-});

package/dist/clients/attach/__tests__/diagram.test.d.ts

@@ -1 +0,0 @@
-export {};