@north-light/crouter 0.3.170 → 0.3.172

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

@@ -0,0 +1,48 @@
+import { fileURLToPath } from 'node:url';
+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';
+initTheme(undefined, false);
+function fakeEditor() {
+    const obj = {
+        onSubmit: undefined,
+        onEscape: undefined,
+        onPasteImage: undefined,
+        onAction: () => { },
+        getText: () => '',
+        setText: () => { },
+        addToHistory: () => { },
+        insertTextAtCursor: () => { },
+    };
+    return obj;
+}
+test('choosing a review file closes the inline picker before the review surface takes focus', () => {
+    const editor = fakeEditor();
+    let focused = null;
+    let mountedPicker;
+    const tui = {
+        requestRender: () => { },
+        setFocus: (component) => { focused = component; },
+        showOverlay: () => ({ hide: () => { } }),
+        start: () => { },
+        stop: () => { },
+    };
+    const reviewSurface = {
+        render: () => [],
+        invalidate: () => { },
+        handleInput: () => { },
+    };
+    const controller = new InputController(tui, editor, {}, {
+        onCommand: () => { },
+        onDialogResponse: () => { },
+        onMountPicker: (component) => { mountedPicker = component; },
+        onUnmountPicker: () => { },
+    });
+    controller.openFileReviewPicker([fileURLToPath(import.meta.url)], process.cwd(), () => {
+        tui.setFocus(reviewSurface);
+    });
+    assert.ok(mountedPicker?.handleInput);
+    mountedPicker.handleInput('\n');
+    assert.equal(focused, reviewSurface, 'picker close must not restore editor focus over the review surface');
+});

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

@@ -0,0 +1,266 @@
+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 { 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() { },
+        get columns() { return 80; }, get rows() { return 24; }, get kittyProtocolActive() { return false; },
+        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;
+    internals.foldSettledTools = true;
+    internals.showGroupSummaries = true;
+    await view.applySnapshot({
+        messages,
+        stats: {},
+        state: { isStreaming: false },
+        toolGroupSummaries: {
+            [key]: { bullets: ['broker recap'], nodesSpawned: 0, filesEdited: 0 },
+        },
+    });
+    const group = internals.groups.find((candidate) => candidate.key === key);
+    assert.ok(group, `missing ${key} group`);
+    return {
+        group,
+        children: internals.historyContainer.children,
+        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('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']);
+});

package/dist/clients/attach/__tests__/input-controller-extension-command.test.js

@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { InputController } from '../input/controller.js';
+function controller(sent) {
+    const editor = {
+        onSubmit: undefined,
+        onEscape: undefined,
+        onPasteImage: undefined,
+        onPasteImagePath: undefined,
+        onAction: () => { },
+        addToHistory: () => { },
+        setText: () => { },
+        getText: () => '',
+        insertTextAtCursor: () => { },
+    };
+    const input = new InputController({}, editor, { matches: () => false }, { onCommand: (frame) => sent.push(frame), onDialogResponse: () => { } });
+    return {
+        submit: (text) => editor.onSubmit(text),
+        setStreaming: (streaming) => input.setState({ isStreaming: streaming }),
+    };
+}
+test('an unrecognized slash command reaches the broker for extension dispatch', () => {
+    const sent = [];
+    const input = controller(sent);
+    input.submit('/recap');
+    input.setStreaming(true);
+    input.submit('/recap refresh');
+    assert.deepEqual(sent, [
+        { type: 'prompt', text: '/recap' },
+        { type: 'steer', text: '/recap refresh' },
+    ]);
+});

package/dist/clients/attach/__tests__/session-identity-refresh.test.js

@@ -0,0 +1,32 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createFrameHandler } from '../session/frames.js';
+test('a regenerated session title refreshes the cached canvas icon', () => {
+    let identityRefreshes = 0;
+    const noop = () => { };
+    const effects = {
+        foldState: noop,
+        chat: {
+            applySnapshot: noop,
+            handleEvent: noop,
+            setWorkingActivity: noop,
+            bashStart: noop,
+            bashOutput: noop,
+            bashEnd: noop,
+            applyToolGroupSummary: noop,
+        },
+        setNotice: noop,
+        renderFooter: noop,
+        setEditorText: noop,
+        attachDialog: noop,
+        dismissDialog: noop,
+        setCommands: noop,
+        resetMemoryRefs: noop,
+        refreshNodeIdentity: () => { identityRefreshes += 1; },
+        reloadBindings: noop,
+        modelThinkingLabel: () => undefined,
+    };
+    const handler = createFrameHandler({ socket: { send: noop } }, effects);
+    handler({ type: 'session_info_changed', name: '\uf14e compass-recap' });
+    assert.equal(identityRefreshes, 1);
+});

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

@@ -134,13 +134,12 @@ test('cursor sweep across a resolved ref decorates outside the cursor cell and s
         }
     }
 });
-test('chrome (loaded-command disclosure, title/info border, mode/context badge) never carries ref decoration', () => {
+test('chrome (loaded-command disclosure, title/info border, context badge) never carries ref decoration', () => {
     const editorA = makeEditor();
     const editorB = makeEditor();
     for (const editor of [editorA, editorB]) {
         editor.title = 'session';
         editor.info = 'cwd-info';
-        editor.mode = 'plan';
         editor.contextBadge = 'node-1';
         editor.loadedCommand = { name: 'dev', content: 'do the thing', inspectHint: 'ctrl+i' };
         editor.setText('please use /dev to continue');

package/dist/clients/attach/chrome/header.d.ts

@@ -0,0 +1,10 @@
+import { Container } from '@earendil-works/pi-tui';
+import type { SessionState } from '../../../core/session-model/session-state.js';
+import type { AttachSession } from '../session/context.js';
+export interface RecapHeader {
+    /** The component ViewerFrame renders as its header region. */
+    readonly component: Container;
+    /** Repaint from the live `crtr-recap` widget state. Empty widget → 0 rows. */
+    render(): void;
+}
+export declare function createRecapHeader(ctx: Pick<AttachSession, 'tui' | 'pal'>, state: () => SessionState): RecapHeader;

package/dist/clients/attach/chrome/header.js

@@ -0,0 +1,30 @@
+// chrome/header.ts — the pinned recap header above the transcript.
+//
+// Only the GOAL line of the broker's retained `crtr-recap` widget is painted
+// here, label stripped, so it stays visible while the transcript scrolls. The
+// state line rides the widget's own cockpit slot (chrome/widgets.ts).
+import { Container, Text, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { DynamicBorder } from '@earendil-works/pi-coding-agent';
+import { splitRecapLines } from './recap.js';
+export function createRecapHeader(ctx, state) {
+    const { tui, pal } = ctx;
+    const component = new Container();
+    const render = () => {
+        component.clear();
+        const widget = state().display.widgets['crtr-recap'];
+        const goal = widget === undefined ? [] : splitRecapLines(widget.lines).goal;
+        if (goal.length > 0) {
+            const span = Math.max(1, (process.stdout.columns ?? 80) - 2);
+            for (const line of goal) {
+                // Styled BEFORE wrapping (wrapTextWithAnsi carries SGR state across
+                // wraps), so a wrapped continuation stays faint.
+                for (const wrapped of wrapTextWithAnsi(pal.faint(line), span)) {
+                    component.addChild(new Text(wrapped, 1, 0));
+                }
+            }
+            component.addChild(new DynamicBorder(pal.border));
+        }
+        tui.requestRender();
+    };
+    return { component, render };
+}

package/dist/clients/attach/chrome/recap.d.ts

@@ -0,0 +1,7 @@
+export interface RecapSplit {
+    /** `Goal:` lines, label stripped — the pinned header's content. */
+    goal: string[];
+    /** The remaining lines, `State:` label stripped — cockpit content. */
+    state: string[];
+}
+export declare function splitRecapLines(lines: readonly string[]): RecapSplit;

package/dist/clients/attach/chrome/recap.js

@@ -0,0 +1,19 @@
+// chrome/recap.ts — how the broker's `crtr-recap` widget divides between the
+// two chrome surfaces: the goal pins to the header above the transcript, and
+// everything else (the state line) rides the widget's own cockpit slot above
+// the editor. The `Goal:`/`State:` prefixes are the widget's transport format,
+// not chrome — both surfaces strip them before painting.
+export function splitRecapLines(lines) {
+    const goal = [];
+    const state = [];
+    for (const line of lines) {
+        const goalMatch = /^Goal:\s*/.exec(line);
+        if (goalMatch !== null) {
+            goal.push(line.slice(goalMatch[0].length));
+            continue;
+        }
+        const stateMatch = /^State:\s*/.exec(line);
+        state.push(stateMatch === null ? line : line.slice(stateMatch[0].length));
+    }
+    return { goal, state };
+}

package/dist/clients/attach/chrome/status-line.d.ts

@@ -20,6 +20,9 @@ export interface StatusLineHooks {
      *  a LOCAL in-tmux attach: a remote attach's local inbox registry cannot open
      *  the remote canvas's filesystem tickets. */
     inboxAffordance: boolean;
+    /** Whether mouse reporting is currently enabled. When false, displays a
+     *  low-priority 'mouse off' indicator in the status bar. */
+    mouseEnabled: () => boolean;
 }
 export interface AttachStatusLine {
     /** Repaint the bar from current state. */

package/dist/clients/attach/chrome/status-line.js

@@ -76,6 +76,11 @@ export function createStatusLine(s, hooks) {
                 segs.push(pal.muted(`⚑ ${total} · ${inboxOpenHint(bindings)}`));
             }
         }
+        // Mouse reporting state: show "mouse off" when reporting is disabled, so
+        // users are aware that tmux drag-select and copy-mode mouse work again.
+        if (!hooks.mouseEnabled()) {
+            segs.push(pal.muted('mouse off'));
+        }
         // Lowest-priority segment (R4): the Alt+C -> b hint, shown only once the
         // oldest still-foreground bash job has crossed the threshold. Read straight
         // off this node's job files rather than tracked from relayed tool-execution

package/dist/clients/attach/chrome/widgets.js

@@ -3,36 +3,26 @@
 // the editor. Both read the folded `SessionState` the orchestrator owns, so it
 // arrives as a getter rather than a captured value.
 import { Text, truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
-import { DynamicBorder } from '@earendil-works/pi-coding-agent';
+import { splitRecapLines } from './recap.js';
 export function createChromeWidgets(ctx, state) {
     const { tui, pal } = ctx;
-    const { chrome, aboveWidgets, belowWidgets, queued } = ctx.containers;
-    /** A recap line is `Goal:`/`State:` + body — bold the label, faint the body.
-     *  Styled BEFORE wrapping (wrapTextWithAnsi carries SGR state across wraps),
-     *  so a wrapped continuation stays faint. Unlabeled lines are all-faint. */
-    const styleRecapLine = (line) => {
-        const m = /^(Goal|State):\s*/.exec(line);
-        if (m === null)
-            return pal.faint(line);
-        return `${pal.bold(m[1] + ':')} ${pal.faint(line.slice(m[0].length))}`;
-    };
-    /** Paint serializable extension widgets into their fixed cockpit slots. The
-     *  recap sits immediately above the editor border and uses the faint palette:
-     *  persistent orientation, but visually a side note rather than primary UI. */
+    const { aboveWidgets, belowWidgets, queued } = ctx.containers;
+    /** Paint serializable extension widgets into their fixed cockpit slots. */
     const renderExtensionWidgets = () => {
         const session = state();
         aboveWidgets.clear();
         belowWidgets.clear();
-        // The brief is an inline annotation, so do not give it the chat/chrome divider
-        // that would make it read as a separate panel.
-        chrome.clear();
-        if (session.display.widgets['crtr-recap'] === undefined)
-            chrome.addChild(new DynamicBorder(pal.border));
+        // The recap widget is split: its goal line is painted by the pinned
+        // header, while its state line lands here in the widget's own cockpit
+        // slot, label stripped and faint.
         const span = Math.max(1, (process.stdout.columns ?? 80) - 2);
         for (const [key, widget] of Object.entries(session.display.widgets)) {
+            const recap = key === 'crtr-recap';
+            const lines = recap ? splitRecapLines(widget.lines).state : widget.lines;
             const target = widget.placement === 'belowEditor' ? belowWidgets : aboveWidgets;
-            for (const line of widget.lines) {
-                const styled = key === 'crtr-recap' ? styleRecapLine(line) : line;
+            for (const line of lines) {
+                // Styled before wrapping so a wrapped continuation stays faint.
+                const styled = recap ? pal.faint(line) : line;
                 for (const wrapped of wrapTextWithAnsi(styled, span)) {
                     target.addChild(new Text(wrapped, 1, 0));
                 }

package/dist/clients/attach/command.js

@@ -2,12 +2,11 @@
 //
 // This module holds only the command metadata (help schema, flags) and the
 // thin `run` entry. It is deliberately kept OFF the heavy pi-coding-agent module
-// graph so that registering the `surface` subtree — for `surface view`,
-// `surface web`, `surface workspace`, `surface tmux-spread`, and every
-// `surface -h` render — costs a cheap command-framework load, not the ~363ms
-// ESM load of the esbuild-bundled attach viewer (`viewer.ts`, which pulls
-// pi-coding-agent's babel/highlight.js). The viewer runtime is dynamically
-// imported inside `run`, so the bundle loads ONLY when a viewer actually opens.
+// graph so registering the `surface` subtree costs a cheap command-framework
+// load, not the ~363ms ESM load of the esbuild-bundled attach viewer (`viewer.ts`,
+// which pulls pi-coding-agent's babel/highlight.js). The viewer runtime is
+// dynamically imported inside `run`, so the bundle loads ONLY when a viewer
+// actually opens.
 import { defineBranch, defineLeaf } from '../../core/command.js';
 import { mark } from '../../core/timing.js';
 const attachToLeaf = defineLeaf({
@@ -74,7 +73,12 @@ const attachToLeaf = defineLeaf({
         const { runAttach } = await import('./viewer.js');
         mark('viewer.bundle_loaded');
         await runAttach(nodeId, observer, canvasName);
-        return;
+        // The session has sent its final broker frame and restored the terminal.
+        // Force this one-shot viewer process out now: pi's bundled UI dependencies
+        // can retain libuv handles after their visible work is finished. The exit
+        // handler registered by teardown still runs, so terminal restoration remains
+        // safe if the normal path raced a signal.
+        process.exit(0);
     },
     render: (result) => (result['note'] !== undefined ? String(result['note']) : ''),
 });

package/dist/clients/attach/config.d.ts

@@ -63,6 +63,10 @@ export interface AttachPalette {
     error: (s: string) => string;
     /** Warning / transient notices. Same constraint as `error` → ANSI yellow. */
     warning: (s: string) => string;
+    /** Added display-diff prefixes/line numbers. pi exposes no foreground role here. */
+    diffAdded: (s: string) => string;
+    /** Removed display-diff prefixes/line numbers. pi exposes no foreground role here. */
+    diffRemoved: (s: string) => string;
     /** Editor border for a SINGLE-`!` bash command (output IS added to the agent's
      *  context). Dull/normal ANSI green — pi paints shell mode from its `bashMode`
      *  theme color (default `green`), which pi does NOT re-export through its public

package/dist/clients/attach/config.js

@@ -207,6 +207,7 @@ const RED = (s) => `\x1b[31m${s}\x1b[39m`;
 const YELLOW = (s) => `\x1b[33m${s}\x1b[39m`;
 const GREEN = (s) => `\x1b[32m${s}\x1b[39m`;
 const BRIGHT_GREEN = (s) => `\x1b[92m${s}\x1b[39m`;
+const DIFF_REMOVED = (s) => `\x1b[91m${s}\x1b[39m`;
 // Terminals do not support alpha. This neutral charcoal is the dark-theme
 // equivalent of a low-opacity gray overlay, without borrowing the purple
 // selection surface used by interactive chrome.
@@ -264,6 +265,8 @@ export function attachPalette() {
         bold: md.bold,
         error: RED,
         warning: YELLOW,
+        diffAdded: GREEN,
+        diffRemoved: DIFF_REMOVED,
         bashMode: GREEN,
         bashModeAlt: BRIGHT_GREEN,
         surface: (line) => `${bgOn}${line.replace(/\x1b\[0m/g, `\x1b[0m${bgOn}`)}\x1b[49m`,