@north-light/crouter 0.3.173 → 0.3.175

package/dist/clients/attach/__tests__/diagram.test.js

@@ -3,8 +3,8 @@ import test from 'node:test';
 import { ensureRenderer, isRendererReady } from '../../../core/termrender/termrender.js';
 import { transformDiagramFences } from '../render/diagram.js';
 // This asserts a REAL termrender render (box-drawing glyphs), so it only holds
-// once the managed renderer is provisioned — true in the full tier and on a dev
-// box, but the fast tier is deliberately termrender-free (no uv to provision the
+// once the managed renderer is provisioned — true in the compiled seam and on a dev
+// box, but the ordinary suite is deliberately termrender-free (no uv to provision the
 // venv). Skip cleanly when the renderer is unavailable, exactly as the tmux
 // tests skip when tmux is absent, rather than failing on the environment.
 ensureRenderer();

package/dist/clients/attach/__tests__/edit-diff.test.js

@@ -28,8 +28,4 @@ test('edit cards stream argument diffs, then keep the executed result authoritat
     const settled = definition.renderCall(laterArgs, theme, context).render(80).join('\n');
     assert.match(settled, /executed/);
     assert.doesNotMatch(settled, /stale preview/);
-    fold.setFolded(true);
-    const folded = definition.renderCall(laterArgs, theme, context).render(80).join('\n');
-    assert.match(folded, /\+2/);
-    assert.match(folded, /-1/);
 });

package/dist/clients/attach/__tests__/file-review-focus.test.js

@@ -3,6 +3,7 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { initTheme } from '@earendil-works/pi-coding-agent';
 import { InputController } from '../input/controller.js';
+import { createViewerCapabilities } from '../input/capabilities.js';
 initTheme(undefined, false);
 function fakeEditor() {
     const obj = {
@@ -38,7 +39,7 @@ test('choosing a review file closes the inline picker before the review surface
         onDialogResponse: () => { },
         onMountPicker: (component) => { mountedPicker = component; },
         onUnmountPicker: () => { },
-    });
+    }, createViewerCapabilities({ role: 'controller', remote: false, nodeId: 'test', profileId: undefined }));
     controller.openFileReviewPicker([fileURLToPath(import.meta.url)], process.cwd(), () => {
         tui.setFocus(reviewSurface);
     });

package/dist/clients/attach/__tests__/group-activity.test.js

@@ -1,20 +1,17 @@
+// Two fold-boundary regressions for the attach viewer's summarized tool groups:
+//
+//   1. An aborted or errored assistant ending must stay VISIBLE outside the
+//      folded group. If the recap swallows it, the user never learns the turn
+//      failed — the folded rows just stop.
+//   2. A recap is a digest, never a payload dump: edit diffs and write bodies
+//      must never leak into it.
 import assert from 'node:assert/strict';
-import { homedir } from 'node:os';
-import { resolve } from 'node:path';
 import test from 'node:test';
-import { Container, TUI, getCapabilities, setCapabilities } from '@earendil-works/pi-tui';
+import { Container, TUI } from '@earendil-works/pi-tui';
 import { initTheme } from '@earendil-works/pi-coding-agent';
-import { AUTH_FAULT_RECOVERY_BODY, RUNTIME_RESTART_CONTINUATION, isRuntimeRestartContinuation } from '../../../shared/generated-context.js';
 import { ChatView } from '../render/chat-view.js';
 import { GroupActivityRecorder } from '../render/group-activity.js';
 import { GroupRecapComponent } from '../render/group-recap.js';
-import { TOOL_ICON } from '../../../core/preview-registry.js';
-function memoryRead(name, pathStyle = 'section') {
-    const path = pathStyle === 'field'
-        ? `- path: /tmp/memories/${name}.md`
-        : `**path:** /tmp/memories/${name}.md`;
-    return `- name: ${name}\n- kind: knowledge\n- scope: project\n${pathStyle === 'section' ? '\n' : ''}${path}`;
-}
 function fakeTerminal() {
     return {
         start() { }, stop() { }, async drainInput() { }, write() { },
@@ -22,142 +19,7 @@ function fakeTerminal() {
         moveBy() { }, hideCursor() { }, showCursor() { }, clearLine() { }, clearFromCursor() { }, clearScreen() { }, setTitle() { }, setProgress() { },
     };
 }
-function snapshotWithContinuation(body) {
-    return {
-        messages: [
-            { role: 'assistant', content: [{ type: 'toolCall', id: 'before', name: 'bash', arguments: { command: 'true' } }] },
-            { role: 'toolResult', toolCallId: 'before', toolName: 'bash', content: [{ type: 'text', text: '' }], isError: false },
-            { role: 'user', content: body },
-            { role: 'assistant', content: [{ type: 'toolCall', id: 'after', name: 'bash', arguments: { command: 'true' } }] },
-            { role: 'toolResult', toolCallId: 'after', toolName: 'bash', content: [{ type: 'text', text: '' }], isError: false },
-        ],
-        stats: {},
-        state: { isStreaming: false },
-    };
-}
 initTheme(undefined, false);
-test('group activity aggregates successful file changes and resolved memory reads', () => {
-    const cwd = '/tmp/activity';
-    const recorder = new GroupActivityRecorder(cwd);
-    recorder.noteCall('edit-1', 'edit', { path: 'same.ts' });
-    recorder.settle('edit-1', { details: { diff: '-1 old\n+1 new' } }, false);
-    recorder.noteCall('write', 'write', { path: 'other.ts', content: 'one\ntwo\n' });
-    recorder.settle('write', {}, false);
-    recorder.noteCall('edit-2', 'edit', { path: resolve(cwd, 'same.ts') });
-    recorder.settle('edit-2', { details: { diff: '+2 later' } }, false);
-    recorder.noteCall('home-edit', 'edit', { path: '~/same-home.ts' });
-    recorder.settle('home-edit', { details: { diff: '+1 home' } }, false);
-    recorder.noteCall('home-write', 'write', { path: resolve(homedir(), 'same-home.ts'), content: 'replacement' });
-    recorder.settle('home-write', {}, false);
-    recorder.noteCall('failed', 'edit', { path: 'failed.ts' });
-    recorder.settle('failed', { details: { diff: '+1 never' } }, true);
-    recorder.noteCall('memory', 'bash', { command: 'crtr memory read alpha && crtr memory read beta' });
-    recorder.settle('memory', { content: [{ type: 'text', text: `${memoryRead('alpha')}\n\n${memoryRead('beta', 'field')}` }] }, false);
-    recorder.noteCall('repeat', 'bash', { command: 'crtr memory read alpha' });
-    recorder.settle('repeat', { content: [{ type: 'text', text: memoryRead('alpha') }] }, false);
-    recorder.noteCall('not-a-read', 'bash', { command: 'crtr memory list' });
-    recorder.settle('not-a-read', { content: [{ type: 'text', text: memoryRead('ignored') }] }, false);
-    recorder.noteCall('quoted-not-a-read', 'bash', { command: 'echo "not a command; crtr memory read fabricated"' });
-    recorder.settle('quoted-not-a-read', { content: [{ type: 'text', text: memoryRead('fabricated') }] }, false);
-    const activity = recorder.activity();
-    assert.deepEqual(activity.memories, [
-        { name: 'alpha', path: '/tmp/memories/alpha.md' },
-        { name: 'beta', path: '/tmp/memories/beta.md' },
-    ]);
-    assert.deepEqual(activity.files.map((file) => [file.kind, file.displayPath]), [
-        ['edit', 'same.ts'],
-        ['write', 'other.ts'],
-        ['edit', '~/same-home.ts'],
-        ['write', resolve(homedir(), 'same-home.ts')],
-    ]);
-    assert.deepEqual(activity.files[0], {
-        key: resolve(cwd, 'same.ts'),
-        displayPath: 'same.ts',
-        kind: 'edit',
-        added: 2,
-        removed: 1,
-        hasKnownCounts: true,
-        countsIncomplete: false,
-    });
-    assert.deepEqual(activity.files[1], {
-        key: resolve(cwd, 'other.ts'),
-        displayPath: 'other.ts',
-        kind: 'write',
-        added: 2,
-        removed: 0,
-        hasKnownCounts: true,
-        countsIncomplete: false,
-    });
-    assert.equal(activity.files[2]?.added, 1, 'edits retain their own aggregate');
-    assert.equal(activity.files[3]?.added, 1, 'writes retain their own aggregate');
-});
-test('the detailed folded recap retains paths and counts without diff or payload bodies', () => {
-    const recorder = new GroupActivityRecorder('/tmp/activity');
-    recorder.noteCall('edit', 'edit', { path: 'overwritten.ts' });
-    const addedDiff = Array.from({ length: 11 }, (_, index) => `+${index + 1} sensitive-new-diff`).join('\n');
-    recorder.settle('edit', { details: { diff: `-1 sensitive-old-diff\n${addedDiff}` } }, false);
-    recorder.noteCall('write', 'write', {
-        path: 'overwritten.ts',
-        content: Array.from({ length: 8 }, () => 'sensitive-write-payload').join('\n'),
-    });
-    recorder.settle('write', {}, false);
-    recorder.noteCall('zero', 'edit', { path: 'overwritten.ts' });
-    recorder.settle('zero', { details: { diff: '' } }, false);
-    recorder.noteCall('unavailable', 'edit', { path: 'overwritten.ts' });
-    recorder.settle('unavailable', {}, false);
-    const tone = (key) => (text) => `[${key}]${text}`;
-    const palette = {
-        accent: tone('accent'), active: tone('active'), info: tone('info'), muted: tone('muted'),
-        faint: tone('faint'), border: tone('border'), surface: tone('surface'), bold: tone('bold'),
-        error: tone('error'), warning: tone('warning'), diffAdded: tone('diffAdded'), diffRemoved: tone('diffRemoved'),
-        bashMode: tone('bashMode'), bashModeAlt: tone('bashModeAlt'),
-    };
-    const recap = new GroupRecapComponent();
-    const originalCapabilities = getCapabilities();
-    let lines;
-    try {
-        setCapabilities({ ...originalCapabilities, hyperlinks: true });
-        recap.setRecap({ bullets: ['finished'], nodesSpawned: 1, filesEdited: 3 }, 2, {
-            memories: [
-                { name: 'alpha', path: '/tmp/memories/alpha.md' },
-                { name: 'beta', path: '/tmp/memories/beta.md' },
-            ],
-            files: recorder.activity().files,
-        }, true, palette);
-        lines = recap.render(120);
-    }
-    finally {
-        setCapabilities(originalCapabilities);
-    }
-    const text = lines.join('\n');
-    assert.equal(lines[0], '');
-    assert.equal(lines.at(-1), '');
-    assert.match(text, /2 tool calls/, 'tool-call count remains visible in every recap mode');
-    assert.doesNotMatch(text, /✦/, 'the tool-call count has no decorative prefix');
-    assert.doesNotMatch(text, /files?\s+edited|memory\s+reads/, 'detailed recaps do not duplicate their itemized activity with count chrome');
-    assert.equal(lines.filter((line) => line.includes('[muted]alpha')).length, 1, 'each memory renders on one line');
-    assert.equal(lines.filter((line) => line.includes('[muted]beta')).length, 1, 'each memory renders on one line');
-    assert.match(text, /file:\/\/\/tmp\/memories\/alpha\.md/);
-    assert.match(text, /file:\/\/\/tmp\/memories\/beta\.md/);
-    assert.doesNotMatch(text, /alpha · beta/);
-    const fileLines = lines.filter((line) => line.includes('overwritten.ts'));
-    assert.equal(fileLines.length, 2, 'edits and writes remain independently visible');
-    const editLine = fileLines.find((line) => line.includes(`[warning]${TOOL_ICON.edit}`));
-    const writeLine = fileLines.find((line) => line.includes(`[warning]${TOOL_ICON.write}`));
-    assert.ok(editLine.indexOf(TOOL_ICON.edit) < editLine.indexOf('overwritten.ts'), 'the edit path stays inline with its glyph');
-    assert.ok(writeLine.indexOf(TOOL_ICON.write) < writeLine.indexOf('overwritten.ts'), 'the write path stays inline with its glyph');
-    assert.ok(editLine.endsWith('[diffAdded]+11 [diffRemoved]-1[muted] · counts incomplete'), 'edit counts stay with the edit');
-    assert.ok(writeLine.endsWith('[diffAdded]+8'), 'write counts stay with the write');
-    assert.equal(lines.filter((line) => line.includes('[diffAdded]')).length, 2, 'each action has one count row');
-    const toolCallIndex = lines.findIndex((line) => line.includes('2 tool calls'));
-    const bulletIndex = lines.findIndex((line) => line.includes('finished'));
-    assert.ok(lines.findIndex((line) => line.includes('[muted]alpha')) < toolCallIndex, 'memory reads precede the tool-call count');
-    assert.ok(lines.findIndex((line) => line.includes(`[warning]${TOOL_ICON.edit}`)) < toolCallIndex, 'file actions precede the tool-call count');
-    assert.ok(toolCallIndex < bulletIndex, 'the tool-call count precedes recap bullets');
-    assert.ok(!text.includes('sensitive-old-diff'));
-    assert.ok(!text.includes('sensitive-new-diff'));
-    assert.ok(!text.includes('sensitive-write-payload'));
-});
 async function summarizedGroup(messages, key) {
     const view = new ChatView(new TUI(fakeTerminal()), new Container());
     const internals = view;
@@ -179,88 +41,37 @@ async function summarizedGroup(messages, key) {
         hidden: internals.historyContainer.hiddenChildren,
     };
 }
-test('broker summaries hide every settled call while aborted/error assistant endings remain visible boundaries', async () => {
-    const successful = await summarizedGroup([
-        { role: 'assistant', content: [{ type: 'toolCall', id: 'successful', name: 'bash', arguments: { command: 'true' } }] },
-        { role: 'toolResult', toolCallId: 'successful', toolName: 'bash', content: [{ type: 'text', text: 'ok' }], isError: false },
-    ], 'successful');
-    assert.equal(successful.hidden.has(successful.group.recap), false, 'a settled successful group still folds to its recap');
-    assert.ok(successful.group.members.every((member) => successful.hidden.has(member)), 'successful group members hide behind the recap');
-    const mixed = await summarizedGroup([
-        {
-            role: 'assistant',
-            content: [
-                { type: 'toolCall', id: 'mixed-success', name: 'bash', arguments: { command: 'true' } },
-                { type: 'toolCall', id: 'mixed-failure', name: 'bash', arguments: { command: 'false' } },
-            ],
-        },
-        { role: 'toolResult', toolCallId: 'mixed-success', toolName: 'bash', content: [{ type: 'text', text: 'ok' }], isError: false },
-        { role: 'toolResult', toolCallId: 'mixed-failure', toolName: 'bash', content: [{ type: 'text', text: 'failed' }], isError: true },
-    ], 'mixed-success');
-    assert.equal(mixed.hidden.has(mixed.group.recap), false, 'a failed call does not suppress the valid group recap');
-    assert.ok(mixed.group.members.every((member) => mixed.hidden.has(member)), 'successful and failed calls all hide behind the recap');
-    for (const stopReason of ['aborted', 'error']) {
-        const key = `terminal-${stopReason}`;
-        const terminalMessage = stopReason === 'aborted'
-            ? { role: 'assistant', content: [], stopReason }
-            : { role: 'assistant', content: [{ type: 'text', text: 'partial reply' }], stopReason, errorMessage: 'provider failed' };
-        const terminalMessages = [
-            { role: 'assistant', content: [{ type: 'toolCall', id: key, name: 'bash', arguments: { command: 'true' } }] },
-        ];
-        if (stopReason === 'error') {
-            terminalMessages.push({ role: 'toolResult', toolCallId: key, toolName: 'bash', content: [{ type: 'text', text: 'ok' }], isError: false });
-        }
-        terminalMessages.push(terminalMessage);
-        const terminal = await summarizedGroup(terminalMessages, key);
-        assert.equal(terminal.hidden.has(terminal.group.recap), false, `${stopReason} does not suppress the preceding valid recap`);
-        assert.ok(terminal.group.members.every((member) => terminal.hidden.has(member)), `${stopReason} leaves preceding tool rows folded`);
-        const visibleBoundary = terminal.children
-            .filter((component) => component !== terminal.group.recap && !terminal.hidden.has(component))
-            .flatMap((component) => component.render(80))
-            .join('\n');
-        assert.match(visibleBoundary, stopReason === 'aborted' ? /Operation aborted|Interrupted/ : /partial reply|provider failed/, `${stopReason} assistant ending remains visible outside the folded group`);
-    }
-});
-test('streamed aborted/error endings stay visible while the preceding summarized tools remain folded', () => {
-    for (const stopReason of ['aborted', 'error']) {
-        const view = new ChatView(new TUI(fakeTerminal()), new Container());
-        const internals = view;
-        internals.foldSettledTools = true;
-        internals.showGroupSummaries = true;
-        const key = `live-${stopReason}`;
-        view.handleEvent({ type: 'message_start', message: { role: 'assistant', content: [] } });
-        view.handleEvent({ type: 'tool_execution_start', toolCallId: key, toolName: 'bash', args: { command: 'true' } });
-        if (stopReason === 'error') {
-            view.handleEvent({ type: 'tool_execution_end', toolCallId: key, result: { content: [{ type: 'text', text: 'ok' }] }, isError: false });
-        }
-        view.applyToolGroupSummary(key, { bullets: ['broker recap'], nodesSpawned: 0, filesEdited: 0 });
-        const group = internals.groups.find((candidate) => candidate.key === key);
-        assert.ok(group, `missing ${stopReason} live group`);
-        assert.equal(internals.historyContainer.hiddenChildren.has(group.recap), stopReason === 'aborted', 'only an in-flight call holds back an early recap');
-        const content = stopReason === 'aborted' ? [] : [{ type: 'text', text: 'partial reply' }];
-        if (content.length > 0) {
-            view.handleEvent({ type: 'message_update', message: { role: 'assistant', content } });
-        }
-        view.handleEvent({ type: 'message_end', message: { role: 'assistant', content, stopReason, errorMessage: 'provider failed' } });
-        view.applyToolGroupSummary(key, { bullets: ['broker recap'], nodesSpawned: 0, filesEdited: 0 });
-        assert.equal(internals.historyContainer.hiddenChildren.has(group.recap), false, `${stopReason} does not suppress the preceding streamed recap`);
-        assert.ok(group.members.every((member) => internals.historyContainer.hiddenChildren.has(member)), `${stopReason} leaves preceding streamed tool rows folded`);
-        const visibleBoundary = internals.historyContainer.children
-            .filter((component) => component !== group.recap && !internals.historyContainer.hiddenChildren.has(component))
-            .flatMap((component) => component.render(80))
-            .join('\n');
-        assert.match(visibleBoundary, stopReason === 'aborted' ? /Interrupted/ : /partial reply|provider failed/, `${stopReason} streamed assistant ending remains visible outside the folded group`);
-    }
+test('a summarized group folds its settled calls but never hides an errored assistant ending', async () => {
+    const key = 'terminal-error';
+    const terminal = await summarizedGroup([
+        { role: 'assistant', content: [{ type: 'toolCall', id: key, name: 'bash', arguments: { command: 'true' } }] },
+        { role: 'toolResult', toolCallId: key, toolName: 'bash', content: [{ type: 'text', text: 'ok' }], isError: false },
+        { role: 'assistant', content: [{ type: 'text', text: 'partial reply' }], stopReason: 'error', errorMessage: 'provider failed' },
+    ], key);
+    assert.equal(terminal.hidden.has(terminal.group.recap), false, 'the valid recap is not suppressed by the failed ending');
+    assert.ok(terminal.group.members.every((member) => terminal.hidden.has(member)), 'preceding tool rows stay folded');
+    const visibleBoundary = terminal.children
+        .filter((component) => component !== terminal.group.recap && !terminal.hidden.has(component))
+        .flatMap((component) => component.render(80))
+        .join('\n');
+    assert.match(visibleBoundary, /partial reply|provider failed/, 'the failed assistant ending remains visible outside the folded group');
 });
-test('only the exact runtime-restart continuation closes an attach tool group', async () => {
-    assert.equal(isRuntimeRestartContinuation({ role: 'user', content: RUNTIME_RESTART_CONTINUATION }), true);
-    assert.equal(isRuntimeRestartContinuation({ role: 'user', content: AUTH_FAULT_RECOVERY_BODY }), false);
-    const runtimeView = new ChatView(new TUI(fakeTerminal()), new Container());
-    await runtimeView.applySnapshot(snapshotWithContinuation(RUNTIME_RESTART_CONTINUATION));
-    const runtimeGroups = runtimeView.groups;
-    assert.deepEqual(runtimeGroups.map((group) => group.key), ['before', 'after']);
-    const recoveryView = new ChatView(new TUI(fakeTerminal()), new Container());
-    await recoveryView.applySnapshot(snapshotWithContinuation(AUTH_FAULT_RECOVERY_BODY));
-    const recoveryGroups = recoveryView.groups;
-    assert.deepEqual(recoveryGroups.map((group) => group.key), ['before']);
+test('a folded recap carries paths and counts, never diff or write payload bodies', () => {
+    const recorder = new GroupActivityRecorder('/tmp/activity');
+    recorder.noteCall('edit', 'edit', { path: 'overwritten.ts' });
+    recorder.settle('edit', { details: { diff: '-1 sensitive-old-diff\n+1 sensitive-new-diff' } }, false);
+    recorder.noteCall('write', 'write', { path: 'overwritten.ts', content: 'sensitive-write-payload' });
+    recorder.settle('write', {}, false);
+    const tone = (key) => (text) => `[${key}]${text}`;
+    const palette = {
+        accent: tone('accent'), active: tone('active'), info: tone('info'), muted: tone('muted'),
+        faint: tone('faint'), border: tone('border'), surface: tone('surface'), bold: tone('bold'),
+        error: tone('error'), warning: tone('warning'), diffAdded: tone('diffAdded'), diffRemoved: tone('diffRemoved'),
+        bashMode: tone('bashMode'), bashModeAlt: tone('bashModeAlt'),
+    };
+    const recap = new GroupRecapComponent();
+    recap.setRecap({ bullets: ['finished'], nodesSpawned: 0, filesEdited: 2 }, 2, { memories: [{ action: 'read', name: 'alpha', path: '/tmp/memories/alpha.md' }], files: recorder.activity().files }, true, palette);
+    const text = recap.render(120).join('\n');
+    assert.match(text, /overwritten\.ts/, 'the recap still names what changed');
+    assert.doesNotMatch(text, /sensitive-old-diff|sensitive-new-diff|sensitive-write-payload/, 'payload bodies never leak into a recap');
 });

package/dist/clients/attach/__tests__/oauth-dialog-lifecycle.test.js

@@ -1,44 +1,23 @@
 // oauth-dialog-lifecycle.test.ts — review mrf68z4h (OAuth dialog lifecycle).
 //
-// Two attach-viewer regressions, proven against a REAL InputController built from
-// minimal fakes:
-//
-//   A. An unrelated extension `notify` must NOT tear down a blocking dialog whose
-//      broker request is still pending. (The old code dismissed the active dialog
-//      on ANY notify — leaving the request unanswered in the broker and the user
-//      with no way to answer it.)
-//   B. A broker-driven `extension_ui_dismiss` (the correlated cleanup emitted when
-//      a dialog's request is aborted/timed out out-of-band) tears down ONLY the
-//      overlay whose id matches, never an unrelated one.
-//
-// Plus the same hazard for the display half of pi's uniform envelope: once
-// setStatus/setWidget/setTitle travel as `extension_ui_request`, a chrome paint
-// reaching `attachDialog` would orphan an in-flight dialog the same way (A).
+// The demonstrated regression: an unrelated extension `notify` tore down a
+// blocking dialog whose broker request was still pending, orphaning the request
+// so the user could never finish login. Teardown is correlated — only the
+// `extension_ui_dismiss` carrying this dialog's own request id closes it.
+// Proven against a REAL InputController built from minimal fakes.
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { initTheme } from '@earendil-works/pi-coding-agent';
 import { InputController } from '../input/controller.js';
+import { createViewerCapabilities } from '../input/capabilities.js';
 // pi's ExtensionInputComponent reads the process-global theme in its constructor
 // (the broker calls initTheme() at boot); initialize it once so renderDialog can
 // build a real dialog component here.
 initTheme(undefined, false);
-function fakeEditor() {
-    const actions = new Map();
-    const obj = {
-        onSubmit: undefined,
-        onEscape: undefined,
-        onPasteImage: undefined,
-        onAction: (name, cb) => { actions.set(name, cb); },
-        getText: () => '',
-        setText: () => { },
-        addToHistory: () => { },
-        insertTextAtCursor: () => { },
-    };
-    return { obj };
-}
 /** A TUI fake whose `showOverlay` returns a handle whose `hide()` is observable,
  *  so a test can tell whether a dialog was actually torn down. */
-function fakeTui() {
+function buildController() {
+    const notices = [];
     const hides = [];
     let seq = 0;
     const tui = {
@@ -51,17 +30,21 @@ function fakeTui() {
         start: () => { },
         stop: () => { },
     };
-    return { tui, hides };
-}
-function buildController() {
-    const notices = [];
-    const editor = fakeEditor();
-    const { tui, hides } = fakeTui();
-    const ic = new InputController(tui, editor.obj, {}, {
+    const editor = {
+        onSubmit: undefined,
+        onEscape: undefined,
+        onPasteImage: undefined,
+        onAction: () => { },
+        getText: () => '',
+        setText: () => { },
+        addToHistory: () => { },
+        insertTextAtCursor: () => { },
+    };
+    const ic = new InputController(tui, editor, {}, {
         onCommand: () => { },
         onDialogResponse: () => { },
         onNotice: (m) => notices.push(m),
-    });
+    }, createViewerCapabilities({ role: 'controller', remote: false, nodeId: 'test', profileId: undefined }));
     return { ic, notices, hides };
 }
 const inputDialog = (id) => ({
@@ -71,63 +54,30 @@ const inputDialog = (id) => ({
     title: 'Paste the redirect URL or code',
     placeholder: 'http://localhost/callback?...',
 });
-const notify = (message) => ({
-    type: 'extension_ui_request',
-    id: 'notify-1',
-    method: 'notify',
-    message,
-    notifyType: 'info',
-});
 test('an unrelated notify does NOT dismiss an active blocking dialog (its broker request stays live)', () => {
     const { ic, notices, hides } = buildController();
     ic.attachDialog(inputDialog('oauth-manual-1'));
     assert.equal(hides.length, 0, 'the dialog overlay is up, not torn down');
     // An unrelated extension fires a notify while the blocking dialog is showing.
-    ic.attachDialog(notify('Some unrelated background progress'));
-    assert.equal(hides.length, 0, 'the blocking dialog must remain on screen — a notify is NOT a dismissal signal');
-    assert.ok(notices.some((n) => /unrelated background progress/i.test(n)), `the notify still shows as a notice line, got: ${JSON.stringify(notices)}`);
-});
-test('a display method (setStatus) does NOT dismiss an active blocking dialog', () => {
-    const { ic, hides } = buildController();
-    ic.attachDialog(inputDialog('oauth-manual-1'));
-    assert.equal(hides.length, 0);
-    // setStatus/setWidget/setTitle ride pi's SAME `extension_ui_request` envelope.
-    // The viewer routes them to chrome before attachDialog, but a stray one
-    // reaching here must be inert — never a teardown of a live request.
     ic.attachDialog({
         type: 'extension_ui_request',
-        id: 'status-1',
-        method: 'setStatus',
-        statusKey: 'crtr-provider',
-        statusText: 'anthropic · ok',
+        id: 'notify-1',
+        method: 'notify',
+        message: 'Some unrelated background progress',
+        notifyType: 'info',
     });
-    assert.equal(hides.length, 0, 'a non-blocking display paint must not tear down the pending dialog');
-    // And the dialog is still the one the correlated dismiss addresses.
-    ic.dismissDialog('oauth-manual-1');
-    assert.equal(hides.length, 1, 'the dialog id was not clobbered by the display request');
+    assert.equal(hides.length, 0, 'the blocking dialog must remain on screen — a notify is NOT a dismissal signal');
+    assert.ok(notices.some((n) => /unrelated background progress/i.test(n)), `the notify still shows as a notice line, got: ${JSON.stringify(notices)}`);
 });
 test('extension_ui_dismiss tears down ONLY the overlay whose request id matches', () => {
     const { ic, hides } = buildController();
     ic.attachDialog(inputDialog('oauth-manual-1'));
-    assert.equal(hides.length, 0);
     // A dismiss for a DIFFERENT request id must be a no-op.
     ic.dismissDialog('some-other-request');
     assert.equal(hides.length, 0, 'a non-matching dismiss must not tear down the current dialog');
-    // The correlated dismiss for THIS dialog's id tears it down.
     ic.dismissDialog('oauth-manual-1');
     assert.equal(hides.length, 1, 'the matching correlated dismiss tears down exactly the current overlay');
     // Idempotent: a repeat dismiss (or a late one after teardown) is inert.
     ic.dismissDialog('oauth-manual-1');
     assert.equal(hides.length, 1, 'a repeat dismiss must not double-tear-down');
 });
-test('a new blocking dialog still supersedes the previous one (correlated dismissal remains isolated)', () => {
-    const { ic, hides } = buildController();
-    ic.attachDialog(inputDialog('dialog-a'));
-    ic.attachDialog(inputDialog('dialog-b'));
-    assert.equal(hides.length, 1, 'the first dialog is superseded (dismissed) when a second blocking dialog arrives');
-    // Now a correlated dismiss for the OLD id must not touch the current one.
-    ic.dismissDialog('dialog-a');
-    assert.equal(hides.length, 1, 'a stale dismiss for the superseded dialog does not tear down the current one');
-    ic.dismissDialog('dialog-b');
-    assert.equal(hides.length, 2, 'the current dialog is torn down by its own correlated dismiss');
-});

package/dist/clients/attach/__tests__/prompt-preview.test.js

@@ -1,6 +1,9 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { loadedCommandPreview, parsePreviewableCommands } from '../slash/prompt-preview.js';
+import { loadedCommandPreview } from '../slash/prompt-preview.js';
+// A preview that expands placeholders differently from submission misleads the
+// user about what they are about to send, so the live preview must reproduce
+// pi's expansion exactly — and must not fire for a non-previewable invocation.
 test('live slash prompt preview matches pi placeholder expansion as arguments change', () => {
     const commands = [{
             name: 'author',
@@ -16,72 +19,3 @@ test('live slash prompt preview matches pi placeholder expansion as arguments ch
     assert.equal(loadedCommandPreview('explain /author testing', commands), undefined);
     assert.equal(loadedCommandPreview('/model', commands), undefined);
 });
-test('deterministic extension preview uses the same raw-argument expansion as /dev submission', () => {
-    const commands = [{
-            name: 'dev',
-            source: 'command',
-            description: 'operate the local stack',
-            expansion: {
-                kind: 'memory-slash',
-                commandName: 'dev',
-                body: 'Interpret `$ARGUMENTS` as the requested stack operation.\nThen act.',
-            },
-        }];
-    assert.deepEqual(loadedCommandPreview('/dev   restart:stack --carefully  ', commands), {
-        name: 'dev',
-        invocation: '/dev   restart:stack --carefully  ',
-        content: 'Interpret `restart:stack --carefully` as the requested stack operation.\nThen act.',
-    });
-});
-test('fresh command metadata replaces a pre-reload expansion before preview recomputes', () => {
-    const before = parsePreviewableCommands(JSON.stringify([{
-            name: 'dev', description: 'operate', source: 'command',
-            expansion: { kind: 'memory-slash', commandName: 'dev', body: 'old $ARGUMENTS' },
-        }]));
-    const after = parsePreviewableCommands(JSON.stringify([{
-            name: 'dev', description: 'operate', source: 'command',
-            expansion: { kind: 'memory-slash', commandName: 'dev', body: 'new $ARGUMENTS' },
-        }]));
-    assert.equal(loadedCommandPreview('/dev restart', before)?.content, 'old restart');
-    assert.equal(loadedCommandPreview('/dev restart', after)?.content, 'new restart');
-});
-test('malformed broker command metadata is discarded without breaking valid inventory', () => {
-    const commands = parsePreviewableCommands(JSON.stringify([
-        { name: 'safe', description: 'safe', source: 'command', expansion: { kind: 'memory-slash', commandName: 'safe', body: 'ok' } },
-        { name: 'bad-kind', description: 'bad', source: 'command', expansion: { kind: 'other', commandName: 'bad-kind', body: 'bad' } },
-        { name: 'bad-body', description: 'bad', source: 'command', expansion: { kind: 'memory-slash', commandName: 'bad-body', body: 3 } },
-        { name: 'bad-template', description: 'bad', source: 'template', template: {} },
-    ]));
-    assert.deepEqual(commands.map((command) => command.name), ['safe']);
-    assert.equal(loadedCommandPreview('/safe', commands)?.content.includes('ok'), true);
-});
-test('submission precedence prevents previews for shadowed templates', () => {
-    const template = { name: 'model', source: 'template', template: 'misleading prompt' };
-    assert.equal(loadedCommandPreview('/model', [
-        { name: 'model', source: 'builtin' },
-        template,
-    ]), undefined, 'viewer builtin wins before template');
-    assert.equal(loadedCommandPreview('/dev now', [
-        { name: 'dev', source: 'command' },
-        { name: 'dev', source: 'template', template: 'also misleading' },
-    ]), undefined, 'non-previewable extension command wins before template');
-});
-test('extension previews use pi ASCII-space matching while templates retain whitespace matching', () => {
-    const commands = [{
-            name: 'dev', source: 'command', description: 'extension',
-            expansion: { kind: 'memory-slash', commandName: 'dev', body: 'extension: $ARGUMENTS' },
-        }, {
-            name: 'dev', source: 'template', description: 'template', template: 'template: $ARGUMENTS',
-        }];
-    assert.equal(loadedCommandPreview('/dev literal space', commands)?.content, 'extension: literal space');
-    assert.equal(loadedCommandPreview('/dev\ttab arg', commands)?.content, 'template: tab arg');
-    assert.equal(loadedCommandPreview('/dev\nnewline arg', commands)?.content, 'template: newline arg');
-});
-test('an empty command inventory clears a loaded preview while fresh metadata is pending', () => {
-    const commands = [{
-            name: 'dev', source: 'command', description: 'extension',
-            expansion: { kind: 'memory-slash', commandName: 'dev', body: 'old $ARGUMENTS' },
-        }];
-    assert.equal(loadedCommandPreview('/dev restart', commands)?.content, 'old restart');
-    assert.equal(loadedCommandPreview('/dev restart', []), undefined);
-});