@north-light/crouter 0.3.170 → 0.3.172

package/dist/clients/conversation/region.js

@@ -0,0 +1,265 @@
+// conversation/region.ts — the broker-backed companion region in a composed review.
+//
+// CompanionRegion implements SurfaceRegion to render a companion conversation
+// within a bounded rectangle. It owns a SurfaceConversation (broker connection),
+// an editor, and a transcript viewport. Geometry is pushed; repaint flows only
+// through onDirty.
+import { getSelectListTheme } from '@earendil-works/pi-coding-agent';
+import { CURSOR_MARKER } from '@earendil-works/pi-tui';
+import { attachPalette, createKeybindingsManager } from '../attach/config.js';
+import { TitledEditor } from '../attach/input/titled-editor.js';
+import { cropAroundCursor, MIN_TRANSCRIPT_ROWS } from '../attach/session/frame.js';
+import { clipLine, visibleWidth } from '../inbox/tui/ansi.js';
+import { SurfaceConversation } from './conversation.js';
+const EDITOR_MAX_FRACTION = 0.5;
+/**
+ * A companion conversation region for a composed review. Renders connection
+ * state, editor, and transcript in a bounded viewport. The only repaint channel
+ * is onDirty; geometry is always pushed.
+ */
+export class CompanionRegion {
+    editor;
+    conversation;
+    cols = 0;
+    rows = 0;
+    focused = false;
+    isDirty = true;
+    renderCache = {};
+    unreadCount = 0;
+    connectionState = 'connecting';
+    noticeText;
+    onDirtyCallback;
+    constructor(opts) {
+        // Reuse the attach viewer's initialized theme and full keybinding
+        // definitions. TitledEditor only needs invalidation plus the terminal handle,
+        // so its own repaint requests return through this region's onDirty channel.
+        const pal = attachPalette();
+        const editorTheme = { borderColor: pal.border, selectList: getSelectListTheme() };
+        const keybindings = createKeybindingsManager();
+        const editorTui = {
+            requestRender: () => this.dirty(),
+            terminal: opts.tui.terminal,
+        };
+        this.editor = new TitledEditor(editorTui, editorTheme, keybindings, { paddingX: 1 });
+        this.editor.title = opts.companionNodeId;
+        this.editor.onSubmit = (text) => this.submit(text);
+        // Conversation owns the broker connection and chat state
+        this.conversation = new SurfaceConversation({
+            nodeId: opts.companionNodeId,
+            tui: opts.tui,
+            canvasSource: opts.canvasSource,
+            reopenDormantCompanion: opts.reopenDormantCompanion,
+            onDirty: () => this.dirty(),
+            onConnection: (state) => this.onConnectionChange(state),
+            onMessage: () => this.countUnread(),
+            notice: (text) => this.showNotice(text),
+        });
+    }
+    setViewport(cols, rows) {
+        const cols2 = Math.max(0, Math.floor(cols));
+        const rows2 = Math.max(0, Math.floor(rows));
+        if (this.cols === cols2 && this.rows === rows2)
+            return;
+        const wasHidden = this.isHidden();
+        this.cols = cols2;
+        this.rows = rows2;
+        if (wasHidden && !this.isHidden())
+            this.unreadCount = 0;
+        this.isDirty = true;
+        if (this.onDirtyCallback)
+            this.onDirtyCallback();
+    }
+    render() {
+        const { cols, rows } = this;
+        // Return cached result if geometry hasn't changed
+        if (this.renderCache.cols === cols && this.renderCache.rows === rows && !this.isDirty) {
+            return this.renderCache.lines ?? [];
+        }
+        if (cols === 0 || rows === 0) {
+            this.renderCache = { cols, rows, lines: [] };
+            this.isDirty = false;
+            return [];
+        }
+        const lines = [];
+        // 1. State line at the top (1 row)
+        lines.push(this.renderStateLine());
+        // 2. Editor section
+        const availableRows = rows - 1; // -1 for state line
+        const editorMaxRows = Math.max(1, Math.floor(availableRows * EDITOR_MAX_FRACTION));
+        const transcriptMinRows = MIN_TRANSCRIPT_ROWS;
+        // Calculate actual editor allocation
+        const editorRows = Math.max(1, Math.min(editorMaxRows, availableRows - transcriptMinRows));
+        const transcriptRows = Math.max(0, availableRows - editorRows);
+        // Render and crop editor
+        const editorLines = this.editor.render(cols);
+        const croppedEditor = cropAroundCursor(editorLines, editorRows);
+        // Pad or clip to exact allocation
+        while (croppedEditor.length < editorRows) {
+            croppedEditor.push('');
+        }
+        if (croppedEditor.length > editorRows) {
+            croppedEditor.length = editorRows;
+        }
+        lines.push(...croppedEditor);
+        // 3. Transcript section
+        if (transcriptRows > 0) {
+            const transcriptLines = this.conversation.viewport.renderSlice(cols, transcriptRows);
+            // Pad to exact allocation
+            while (transcriptLines.length < transcriptRows) {
+                transcriptLines.push('');
+            }
+            if (transcriptLines.length > transcriptRows) {
+                transcriptLines.length = transcriptRows;
+            }
+            lines.push(...transcriptLines);
+        }
+        // Ensure we have exactly `rows` lines, each clipped to `cols` display cells
+        while (lines.length < rows) {
+            lines.push('');
+        }
+        if (lines.length > rows) {
+            lines.length = rows;
+        }
+        // Fit each line to the exact column width without splitting ANSI or the
+        // zero-width cursor marker. An unfocused region must emit no marker.
+        const clipped = lines.map((line) => this.fitLine(line, cols));
+        if (!this.focused) {
+            for (let i = 0; i < clipped.length; i++) {
+                clipped[i] = this.stripMarkers(clipped[i]);
+            }
+        }
+        this.renderCache = { cols, rows, lines: clipped };
+        this.isDirty = false;
+        return clipped;
+    }
+    handleInput(data) {
+        if (this.focused) {
+            // TitledEditor's handleInput returns void, so we route all input to it
+            // when focused and assume it was consumed
+            this.editor.handleInput(data);
+            this.dirty();
+            return true;
+        }
+        return false;
+    }
+    handleWheel(direction, lines) {
+        // Scroll the transcript: negative = toward older, positive = toward newer
+        const scrollLines = direction === 'up' ? -lines : lines;
+        this.conversation.viewport.scrollBy(scrollLines);
+        this.dirty();
+        return true;
+    }
+    setFocused(value) {
+        if (this.focused === value && this.editor.focused === value)
+            return;
+        this.focused = value;
+        this.editor.focused = value;
+        if (value)
+            this.unreadCount = 0;
+        this.isDirty = true;
+        if (this.onDirtyCallback)
+            this.onDirtyCallback();
+    }
+    summary() {
+        const parts = [];
+        // A zero viewport is the composition's hidden-region signal in single mode.
+        if (this.isHidden() && this.unreadCount > 0)
+            parts.push(`${this.unreadCount}✉`);
+        // Show connection state
+        if (this.connectionState === 'connecting') {
+            parts.push('connecting…');
+        }
+        else if (this.connectionState === 'reconnecting') {
+            parts.push('reconnecting…');
+        }
+        else if (this.connectionState === 'dormant') {
+            parts.push('dormant');
+        }
+        else if (this.connectionState === 'finished') {
+            parts.push('finished');
+        }
+        else if (this.connectionState === 'gone') {
+            parts.push('gone');
+        }
+        return parts.join(' · ');
+    }
+    onDirty(fn) {
+        this.onDirtyCallback = fn;
+    }
+    close() {
+        this.conversation.close();
+    }
+    /** Open the connection to the companion broker. */
+    async open() {
+        try {
+            await this.conversation.open();
+        }
+        catch (error) {
+            // Already handled by the conversation's notice callback
+        }
+    }
+    /** Submit text to the companion. */
+    submit(text) {
+        this.editor.setText('');
+        this.conversation.submit(text);
+    }
+    renderStateLine() {
+        const parts = [];
+        if (this.connectionState === 'connecting') {
+            parts.push('connecting…');
+        }
+        else if (this.connectionState === 'reconnecting') {
+            parts.push('reconnecting…');
+        }
+        else if (this.connectionState === 'dormant') {
+            parts.push('dormant');
+        }
+        else if (this.connectionState === 'finished') {
+            parts.push('finished');
+        }
+        else if (this.connectionState === 'gone') {
+            parts.push('gone');
+        }
+        if (this.noticeText)
+            parts.push(this.noticeText);
+        return this.fitLine(parts.join(' · '), this.cols);
+    }
+    fitLine(line, cols) {
+        const markerAt = line.indexOf(CURSOR_MARKER);
+        const fitted = this.padLine(clipLine(line, cols), cols);
+        if (markerAt === -1)
+            return fitted;
+        // The shared clipper preserves both ANSI and pi-tui APC sequences whole.
+        // Keep the zero-width marker only when its cursor cell remains inside this
+        // region's rectangle.
+        return visibleWidth(line.slice(0, markerAt)) < cols ? fitted : this.stripMarkers(fitted);
+    }
+    padLine(line, cols) {
+        return line + ' '.repeat(Math.max(0, cols - visibleWidth(this.stripMarkers(line))));
+    }
+    stripMarkers(line) {
+        return line.split(CURSOR_MARKER).join('');
+    }
+    onConnectionChange(state) {
+        this.connectionState = state;
+        this.isDirty = true;
+        if (this.onDirtyCallback)
+            this.onDirtyCallback();
+    }
+    showNotice(text) {
+        this.noticeText = text || undefined;
+    }
+    isHidden() {
+        return this.cols === 0 || this.rows === 0;
+    }
+    /** One arriving message while the composition gives this region no rectangle. */
+    countUnread() {
+        if (this.isHidden())
+            this.unreadCount++;
+    }
+    dirty() {
+        this.isDirty = true;
+        if (this.onDirtyCallback)
+            this.onDirtyCallback();
+    }
+}

package/dist/clients/conversation/submit.d.ts

@@ -0,0 +1,38 @@
+export type SubmitClassification = {
+    kind: 'empty';
+} | {
+    kind: 'slash';
+    trimmed: string;
+} | {
+    kind: 'dormant';
+    text: string;
+    trimmed: string;
+} | {
+    kind: 'bash';
+    command: string;
+    excludeFromContext: boolean;
+    trimmed: string;
+} | {
+    kind: 'steer';
+    text: string;
+    trimmed: string;
+} | {
+    kind: 'prompt';
+    text: string;
+    trimmed: string;
+};
+/**
+ * Classify a text submission to determine the appropriate message kind.
+ *
+ * The branch order is load-bearing and must match the original handleSubmit order exactly:
+ * 1. Empty trim → nothing
+ * 2. Slash command → handled by the viewer caller
+ * 3. Dormant + can wake → dormant wake (if `canWakeDormant`)
+ * 4. Bash (! or !!) → bash
+ * 5. Streaming ? steer : prompt → prompt or steer
+ */
+export declare function classifySubmit(text: string, ctx: {
+    isDormant: boolean;
+    canWakeDormant: boolean;
+    isStreaming: boolean;
+}): SubmitClassification;

package/dist/clients/conversation/submit.js

@@ -0,0 +1,51 @@
+// conversation/submit.ts — classification of text submission intent.
+//
+// Extracted from InputController.handleSubmit (T-A4): classify user input before
+// deciding whether to dispatch a slash command, wake a dormant node, run bash,
+// or send a prompt/steer frame. The load-bearing branch order is preserved exactly:
+// empty-trim → slash → dormant (isDormant && canWakeDormant) → bash (! / !!) →
+// streaming ? steer : prompt.
+//
+// Caller applies slash dispatch, readOnlySlashRefusal, expandImagePlaceholders,
+// addToHistory, setText(''), and clearPastedImages() — this extraction is pure
+// classification, not control flow.
+/**
+ * Classify a text submission to determine the appropriate message kind.
+ *
+ * The branch order is load-bearing and must match the original handleSubmit order exactly:
+ * 1. Empty trim → nothing
+ * 2. Slash command → handled by the viewer caller
+ * 3. Dormant + can wake → dormant wake (if `canWakeDormant`)
+ * 4. Bash (! or !!) → bash
+ * 5. Streaming ? steer : prompt → prompt or steer
+ */
+export function classifySubmit(text, ctx) {
+    const trimmed = text.trim();
+    // Branch 1: empty-trim
+    if (!trimmed) {
+        return { kind: 'empty' };
+    }
+    // Branch 2: slash. Dispatch and read-only refusal remain caller-owned.
+    if (trimmed.startsWith('/')) {
+        return { kind: 'slash', trimmed };
+    }
+    // Branch 3: dormant
+    if (ctx.isDormant && ctx.canWakeDormant) {
+        return { kind: 'dormant', text, trimmed };
+    }
+    // Branch 4: bash
+    if (trimmed.startsWith('!')) {
+        const excludeFromContext = trimmed.startsWith('!!');
+        const command = trimmed.slice(excludeFromContext ? 2 : 1).trim();
+        if (command === '') {
+            // bare `!`/`!!` with no command → empty
+            return { kind: 'empty' };
+        }
+        return { kind: 'bash', command, excludeFromContext, trimmed };
+    }
+    // Branch 5: steer or prompt
+    if (ctx.isStreaming) {
+        return { kind: 'steer', text, trimmed };
+    }
+    return { kind: 'prompt', text, trimmed };
+}

package/dist/clients/inbox/__tests__/inbox-controller.test.js

@@ -0,0 +1,247 @@
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { existsSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { claimExists, claimTicket } from '#core/human/claim';
+import { atomicWriteJson, deckPath } from '#core/human/convention';
+import { ticketDir } from '#core/human/root';
+import { cancelTicket, completeDeck, submitDeck, submitReview, takeoverAndCompleteDeck } from '#core/human/tickets';
+import { inboxLayout } from '../layout.js';
+import { InboxController } from '../controller.js';
+import { buildInboxLines } from '../tui.js';
+const key = (part = {}) => ({ ctrl: false, meta: false, upArrow: false, downArrow: false, leftArrow: false, rightArrow: false, wordLeft: false, wordRight: false, home: false, end: false, pageUp: false, pageDown: false, del: false, return: false, newline: false, escape: false, tab: false, backspace: false, ...part });
+function fakeHost() {
+    let closed = false;
+    const cleanup = [];
+    const handle = {
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            for (const fn of cleanup)
+                void fn();
+            cleanup.length = 0;
+        },
+        invalidate() { },
+        onClose(fn) {
+            if (!closed)
+                cleanup.push(fn);
+        },
+    };
+    return {
+        host: {
+            capabilities: { remote: false, canFocusNode: false },
+            mount() { return handle; },
+            notice() { },
+            suspendForChild() { return () => { }; },
+            focusNode: async () => false,
+            pickReviewFile: async () => null,
+        },
+    };
+}
+const tui = {};
+const canvasSource = {};
+const makeController = (options) => {
+    const harness = fakeHost();
+    const controller = new InboxController({
+        host: harness.host,
+        tui,
+        canvasSource,
+        onDirty: () => { },
+        onClosed: () => { },
+        ...options,
+    });
+    return controller;
+};
+const item = (id) => ({ dir: `/tickets/${id}`, id, kind: 'deck', title: id, subtitle: `${id} requires your attention.`, interactionCount: 1, source: {}, blockedSince: '2025-01-01T00:00:00.000Z' });
+const tick = () => new Promise((resolve) => setImmediate(resolve));
+function select(controller, dir) {
+    const count = controller.snapshot().items.length;
+    const matches = () => {
+        const selected = controller.snapshot().selectedDir;
+        return selected !== undefined && realpathSync(selected) === realpathSync(dir);
+    };
+    for (let i = 0; i < count && !matches(); i++)
+        controller.handleKey('j', key());
+    assert.ok(matches(), `expected ${dir} to be selectable`);
+}
+async function waitFor(predicate, message) {
+    const deadline = Date.now() + 1_000;
+    while (!predicate()) {
+        if (Date.now() >= deadline)
+            throw new Error(message);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+}
+assert.deepEqual(inboxLayout(120, 30), { mode: 'two-column', listWidth: 40, detailWidth: 79, height: 30 });
+assert.equal(inboxLayout(80, 24).mode, 'list');
+assert.equal(inboxLayout(80, 24, 'detail').mode, 'detail');
+assert.equal(inboxLayout(59, 18).mode, 'minimum');
+const crowded = Array.from({ length: 20 }, (_, index) => item(`ticket-${index}`));
+const visibleRows = buildInboxLines(crowded, 40, 10, 8).join('\n');
+assert.ok(visibleRows.includes('ticket-10'), 'list viewport keeps the selected ticket visible');
+assert.ok(visibleRows.includes('↑') && visibleRows.includes('↓'), 'list viewport signals tickets above and below');
+const claimedRows = buildInboxLines([{ ...item('claimed'), subtitle: 'Approve the deployment because production is blocked.', claim: { owner: 'silas', claimedAt: '2025-01-01T00:00:00.000Z', heartbeatAt: '2025-01-01T00:00:00.000Z' } }], 120, 0).join('\n');
+assert.ok(claimedRows.includes('claimed by silas · Approve the deployment because production is blocked.'), 'claimed rows compose claim status with the required subtitle');
+let rows = [item('b'), item('a')];
+const stable = makeController({ cols: 100, rows: 24, scan: () => rows });
+assert.ok(!stable.render().join('\n').includes('unknown source'), 'passive detail omits missing source labels instead of rendering a fallback');
+stable.handleKey('j', key());
+assert.equal(stable.snapshot().selectedDir, '/tickets/a');
+rows = [item('new'), ...rows];
+stable.rescan();
+assert.equal(stable.snapshot().selectedDir, '/tickets/a', 'prepend preserves selected ticket id');
+rows = [item('new'), item('b')];
+stable.rescan();
+assert.equal(stable.snapshot().selectedDir, '/tickets/b', 'removed selection chooses the prior index');
+let mode = 'success';
+async function startDaemon() {
+    const server = createServer(async (req, res) => {
+        if (!req.url?.endsWith('/resolve')) {
+            res.statusCode = 404;
+            res.end(JSON.stringify({ error: { code: 'not_found', message: 'not found' } }));
+            return;
+        }
+        if (mode === 'unreachable') {
+            res.statusCode = 503;
+            res.end(JSON.stringify({ error: { code: 'daemon_unavailable', message: 'offline' } }));
+            return;
+        }
+        const body = await new Promise((resolve) => {
+            let text = '';
+            req.on('data', (chunk) => { text += chunk; });
+            req.on('end', () => resolve(text));
+        });
+        const nodeId = req.url.split('/').at(-2);
+        if (mode === 'already_resolved') {
+            res.statusCode = 409;
+            res.end(JSON.stringify({ error: { code: 'ticket_already_resolved', message: 'ticket already resolved' } }));
+            return;
+        }
+        const request = JSON.parse(body);
+        if (request.responses === undefined)
+            throw new Error('expected a deck resolution');
+        takeoverAndCompleteDeck(ticketDir(nodeId), request.responses, { host: 'daemon', pid: 1 });
+        if (mode === 'delivery_failed') {
+            res.statusCode = 500;
+            res.end(JSON.stringify({ error: { code: 'delivery_failed', message: 'final report delivery failed' } }));
+            return;
+        }
+        res.end(JSON.stringify({ delivered: true, kind: 'deck' }));
+    });
+    await new Promise((resolve) => server.listen(join(process.env['CRTR_HOME'], 'crtrd.sock'), resolve));
+    return server;
+}
+const temp = mkdtempSync(join(tmpdir(), 'crtr-inbox-controller-'));
+process.env['CRTR_HOME'] = temp;
+const server = await startDaemon();
+const deck = (id) => ({ title: id, source: { blockedSince: new Date().toISOString(), sessionName: 'Release planning', nodeId: 'node-private-123' }, interactions: [{ id: 'answer', title: 'Answer', subtitle: 'Answer requires your attention.', options: [{ id: 'yes', label: 'Yes', shortcut: 'y' }] }] });
+try {
+    const first = submitDeck({ dir: ticketDir('first'), deck: deck('first') });
+    const active = makeController({ cols: 100, rows: 24 });
+    const initialInbox = active.render().join('\n');
+    assert.ok(initialInbox.includes('Answer requires your attention.'), 'the selected ticket preview renders its required subtitle');
+    assert.ok(initialInbox.includes('1 question'), 'the selected ticket preview renders its question count');
+    assert.ok(!initialInbox.includes('Release planning') && !initialInbox.includes('node-private-123'), 'the selected ticket preview omits source metadata');
+    active.activate();
+    active.handleKey('y', key());
+    await waitFor(() => existsSync(join(first.dir, 'response.json')), 'a deck resolution crosses the controller daemon seam');
+    assert.equal(existsSync(join(first.dir, 'response.json')), true, 'a deck resolution crosses the controller daemon seam');
+    await waitFor(() => active.snapshot().screen === 'list', 'a successful daemon resolution unmounts the ticket');
+    assert.equal(active.snapshot().screen, 'list', 'a successful daemon resolution unmounts the ticket');
+    active.close();
+    const editing = submitDeck({ dir: ticketDir('editing'), deck: { title: 'Editing', interactions: [{ id: 'note', title: 'Notes', subtitle: 'Notes require your attention.', options: [], allowFreetext: true }] } });
+    const editingController = makeController({ cols: 100, rows: 24 });
+    select(editingController, editing.dir);
+    editingController.activate();
+    editingController.handleKey('r', key());
+    for (const char of 'draft')
+        editingController.handleKey(char, key());
+    submitDeck({ dir: ticketDir('arrival'), deck: deck('arrival') });
+    editingController.rescan();
+    assert.equal(realpathSync(editingController.snapshot().selectedDir), realpathSync(editing.dir), 'arrival does not steal active selection');
+    assert.equal(editingController.snapshot().inputBuffer, 'draft', 'arrival does not alter freetext input');
+    cancelTicket(editing.dir, { reason: 'canceled while editing' });
+    editingController.rescan();
+    assert.equal(editingController.snapshot().screen, 'list', 'cancellation invalidation returns to list');
+    assert.notEqual(editingController.snapshot().selectedDir, editing.dir, 'cancellation moves selection away from the resolved ticket');
+    editingController.close();
+    const reviewSourcePreview = join(temp, 'review-preview.ts');
+    writeFileSync(reviewSourcePreview, 'export const reviewPreview = true;\n');
+    const reviewPreview = submitReview({ dir: ticketDir('review-preview'), review: { file: reviewSourcePreview, title: 'Review source', subtitle: 'Review this source before approving the release.', source: {} } });
+    const reviewPreviewController = makeController({ cols: 100, rows: 24 });
+    select(reviewPreviewController, reviewPreview.dir);
+    const renderedReviewPreview = reviewPreviewController.render().join('\n');
+    assert.ok(renderedReviewPreview.includes('Review this source before approving the release.'), 'passive review detail renders its authored subtitle');
+    assert.ok(renderedReviewPreview.includes('1 file to review'), 'passive review detail identifies the compact review payload');
+    assert.ok(!renderedReviewPreview.includes('reviewPreview = true'), 'passive review detail omits the source document');
+    reviewPreviewController.close();
+    const already = submitDeck({ dir: ticketDir('already'), deck: deck('already') });
+    const alreadyController = makeController({ cols: 100, rows: 24 });
+    alreadyController.activate();
+    cancelTicket(already.dir, { reason: 'resolved elsewhere' });
+    mode = 'already_resolved';
+    alreadyController.handleKey('y', key());
+    await waitFor(() => alreadyController.snapshot().screen === 'list', 'already_resolved unmounts instead of offering a stale resubmit');
+    assert.equal(alreadyController.snapshot().screen, 'list', 'already_resolved unmounts instead of offering a stale resubmit');
+    assert.equal(claimExists(already.dir), true, 'already_resolved retains the daemon-taken claim');
+    alreadyController.close();
+    const delivery = submitDeck({ dir: ticketDir('delivery'), deck: deck('delivery') });
+    mode = 'delivery_failed';
+    const deliveryController = makeController({ cols: 100, rows: 24 });
+    deliveryController.activate();
+    deliveryController.handleKey('y', key());
+    await waitFor(() => deliveryController.snapshot().screen === 'list', 'delivery_failed unmounts because the canonical answer is already recorded');
+    assert.equal(deliveryController.snapshot().screen, 'list', 'delivery_failed unmounts because the canonical answer is already recorded');
+    assert.equal(existsSync(join(delivery.dir, 'response.json')), true, 'delivery_failed still leaves the canonical response on disk');
+    deliveryController.close();
+    const retry = submitDeck({ dir: ticketDir('retry'), deck: deck('retry') });
+    mode = 'unreachable';
+    const retryController = makeController({ cols: 100, rows: 24 });
+    retryController.activate();
+    retryController.handleKey('y', key());
+    await tick();
+    assert.equal(retryController.snapshot().screen, 'detail', 'unreachable keeps the mounted answer available for retry');
+    assert.equal(existsSync(join(retry.dir, 'response.json')), false, 'unreachable does not manufacture a local completion');
+    retryController.close();
+    // Notification acknowledgement remains explicit: opening or abandoning a
+    // notification does not create a response, while its canonical completion
+    // still rejects a missing acknowledgement.
+    mode = 'success';
+    const notification = submitDeck({ dir: ticketDir('notification'), deck: { title: 'Notice', interactions: [{ id: 'notice', title: 'Notice', subtitle: 'Read the complete notice.', kind: 'notify', body: 'Notification body that must be visible before acknowledgement.', options: [{ id: 'ok', label: 'OK' }] }] } });
+    const notificationController = makeController({ cols: 100, rows: 24 });
+    select(notificationController, notification.dir);
+    const renderedNotificationPreview = notificationController.render().join('\n');
+    assert.ok(renderedNotificationPreview.includes('Read the complete notice') && renderedNotificationPreview.includes('1 question'), 'passive deck preview renders only its subtitle and question count');
+    assert.ok(!renderedNotificationPreview.includes('Notification body'), 'passive deck preview omits interaction bodies');
+    assert.ok(renderedNotificationPreview.includes('Enter') && renderedNotificationPreview.includes('c comment'), 'preview keeps full-ticket controls visible');
+    notificationController.activate();
+    notificationController.handleKey('q', key());
+    assert.equal(existsSync(join(notification.dir, 'response.json')), false, 'leaving a notification never acknowledges it');
+    notificationController.close();
+    const notificationClaim = claimTicket(notification.dir);
+    assert.notEqual(notificationClaim, null);
+    assert.throws(() => completeDeck(notification.dir, [], notificationClaim.token), /explicit acknowledgement/, 'canonical completion rejects a notification without acknowledgement');
+    assert.throws(() => completeDeck(notification.dir, [{ id: 'notice' }], notificationClaim.token), /explicit acknowledgement/, 'an empty notification response is not acknowledgement');
+    assert.equal(completeDeck(notification.dir, [{ id: 'notice', selectedOptionId: 'ok' }], notificationClaim.token).won, true, 'an explicit acknowledgement completes the notification');
+    const replacement = submitDeck({ dir: ticketDir('replacement'), deck: { title: 'Replacement', interactions: [
+                { id: 'keep', title: 'Keep', subtitle: 'Keep requires your attention.', options: [{ id: 'yes', label: 'Yes', shortcut: 'y' }] },
+                { id: 'drop', title: 'Drop', subtitle: 'Drop requires your attention.', options: [{ id: 'no', label: 'No', shortcut: 'n' }] },
+            ] } });
+    const replacementController = makeController({ cols: 100, rows: 24 });
+    select(replacementController, replacement.dir);
+    replacementController.activate();
+    replacementController.handleKey('y', key());
+    atomicWriteJson(deckPath(replacement.dir), { title: 'Replacement', interactions: [{ id: 'keep', title: 'Keep', subtitle: 'Keep requires your attention.', options: [{ id: 'yes', label: 'Yes', shortcut: 'y' }] }] });
+    replacementController.reloadSelectedDeck();
+    assert.ok(replacementController.render().join('\n').includes('Current: Yes'), 'deck replacement keeps a surviving answer');
+    replacementController.close();
+}
+finally {
+    server.closeAllConnections();
+    await new Promise((resolve) => server.close(() => resolve()));
+    rmSync(temp, { recursive: true, force: true });
+    delete process.env['CRTR_HOME'];
+}
+console.log('inbox controller tests passed');