@north-light/crouter 0.3.172 → 0.3.174

package/dist/clients/inbox/__tests__/serial/mount-panel.test.js

@@ -0,0 +1,151 @@
+import { mountPanel } from '../../tui/panel.js';
+import assert from 'node:assert/strict';
+// Answer-integrity regressions: every case below is a way the panel once lost or
+// invented an answer on the user's behalf.
+function mkKey(partial) {
+    return {
+        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,
+        ...partial,
+    };
+}
+const RETURN = mkKey({ return: true });
+// ── An empty Enter in freetext-only mode records the response ─────────────────
+// Regression: an empty buffer failed a truthy guard, so the response was never
+// recorded, the deck could never reach a full response set, and onComplete
+// never fired — leaving the deck permanently unfinishable.
+const freetextOnlyDeck = {
+    title: 'Test deck',
+    interactions: [
+        { id: 'q1', title: 'Optional notes', subtitle: 'Optional notes requires your attention.', options: [], allowFreetext: true },
+    ],
+};
+let capturedFreetextEmpty = [];
+const ftPanel = mountPanel({
+    deck: freetextOnlyDeck,
+    cols: 80,
+    rows: 24,
+    onComplete: (responses) => { capturedFreetextEmpty = responses; },
+});
+// Single-item deck starts directly in item-review (no overview). 'r' opens freetext.
+ftPanel.handleKey('r', mkKey({}));
+ftPanel.handleKey('', RETURN); // submit with an empty buffer
+ftPanel.handleKey('', RETURN); // final phase → complete
+assert.deepEqual(capturedFreetextEmpty, [{ id: 'q1', freetext: '' }], 'empty freetext Enter must record response and fire onComplete');
+ftPanel.unmount();
+// ── An empty Enter in comment mode records the response ───────────────────────
+const commentDeck = {
+    title: 'Test deck',
+    interactions: [
+        {
+            id: 'c1', title: 'Approve deploy?', subtitle: 'Approve deploy? requires your attention.',
+            options: [{ id: 'yes', label: 'Yes', shortcut: 'y' }],
+            allowFreetext: true,
+        },
+    ],
+};
+let capturedCommentEmpty = [];
+const cmPanel = mountPanel({
+    deck: commentDeck,
+    cols: 80,
+    rows: 24,
+    onComplete: (responses) => { capturedCommentEmpty = responses; },
+});
+// Navigate to the [c] row WITHOUT pre-attaching an option, then comment.
+cmPanel.handleKey('j', mkKey({}));
+cmPanel.handleKey('c', mkKey({}));
+cmPanel.handleKey('', RETURN); // submit an empty comment, no option selected
+cmPanel.handleKey('', RETURN); // final phase → complete
+assert.deepEqual(capturedCommentEmpty, [{ id: 'c1', freetext: '' }], 'empty Enter in comment mode must record response and fire onComplete');
+cmPanel.unmount();
+// ── Option-shortcut letters typed in comment mode are text, never a choice ────
+// Regression: pressing an option's shortcut while commenting submitted that
+// option for the user instead of appending the character to the buffer.
+const shortcutTypingDeck = {
+    title: 'Test deck',
+    interactions: [
+        {
+            id: 'q1', title: 'Approve?', subtitle: 'Approve? requires your attention.',
+            options: [
+                { id: 'yes', label: 'Yes', shortcut: 'y' },
+                { id: 'no', label: 'No', shortcut: 'n' },
+            ],
+            allowFreetext: true,
+        },
+    ],
+};
+let capturedShortcutTyping = [];
+const stPanel = mountPanel({
+    deck: shortcutTypingDeck,
+    cols: 80,
+    rows: 24,
+    onComplete: (responses) => { capturedShortcutTyping = responses; },
+});
+stPanel.handleKey('j', mkKey({}));
+stPanel.handleKey('j', mkKey({}));
+stPanel.handleKey('c', mkKey({}));
+// 'y' and 'n' are both option shortcuts; every character must reach the buffer.
+for (const ch of 'yes no')
+    stPanel.handleKey(ch, mkKey({}));
+stPanel.handleKey('', RETURN); // submit the comment — must carry no selectedOptionId
+stPanel.handleKey('', RETURN); // final → complete
+assert.deepEqual(capturedShortcutTyping, [{ id: 'q1', freetext: 'yes no' }], 'option-shortcut letters typed in comment mode must append to buffer, not select option');
+stPanel.unmount();
+// ── Multi-select needs an explicit confirm, and an empty Enter does nothing ───
+// Two regressions on one deck: Enter with nothing toggled committed an empty
+// set and finalized, and a confirmed set auto-finalized with no chance to
+// review it.
+const multiDeck = {
+    title: 'Test deck',
+    interactions: [
+        {
+            id: 'cs1', title: 'Pick toppings', subtitle: 'Pick toppings requires your attention.', multiSelect: true,
+            options: [
+                { id: 'mush', label: 'Mushroom', shortcut: 'a' },
+                { id: 'onion', label: 'Onion', shortcut: 'b' },
+            ],
+        },
+    ],
+};
+let multiFired = false;
+let multiResponses = [];
+const multiPanel = mountPanel({
+    deck: multiDeck,
+    cols: 80,
+    rows: 24,
+    onComplete: (responses) => { multiFired = true; multiResponses = responses; },
+});
+// Nothing toggled: Enter must be an inert no-op, not an empty answer.
+multiPanel.handleKey('', RETURN);
+assert.equal(multiFired, false, 'Enter with an empty multi-select set must NOT finalize');
+const stillReview = multiPanel.render().join('\n');
+assert.ok(stillReview.includes('Pick toppings'), 'after empty Enter, still on the interaction (no advance)');
+assert.ok(!stillReview.includes('Summary'), 'after empty Enter, the deck did NOT advance to the Summary screen');
+assert.ok(stillReview.toLowerCase().includes('select at least one'), 'empty multi-select Enter surfaces an inline hint');
+// Toggle an option and confirm the set: the first Enter reviews, never submits.
+multiPanel.handleKey(' ', mkKey({}));
+multiPanel.handleKey('', RETURN);
+assert.equal(multiFired, false, 'multi-select first Enter must NOT auto-finalize (lands on the confirm screen)');
+assert.ok(multiPanel.render().join('\n').includes('Summary'), 'after confirming a multi-select set, the deck shows the Summary/confirm screen');
+// A second deliberate Enter submits exactly the toggled set.
+multiPanel.handleKey('', RETURN);
+assert.equal(multiFired, true, 'second Enter on the Summary screen finalizes the multi-select deck');
+assert.deepEqual(multiResponses, [{ id: 'cs1', selectedOptionIds: ['mush'] }], 'confirmed multi-select set returned on finalize');
+multiPanel.unmount();
+console.log('OK');

package/dist/clients/inbox/controller.d.ts

@@ -1,12 +1,8 @@
-import type { TUI } from '@earendil-works/pi-tui';
 import type { TicketSummary } from '../../core/human/types.js';
-import type { CanvasSource } from '../../core/canvas/source.js';
 import type { Key } from './tui/keys.js';
 import type { SurfaceHost } from '../surfaces/host.js';
 export interface InboxControllerOptions {
     host: SurfaceHost;
-    tui: TUI;
-    canvasSource: CanvasSource;
     /** Called whenever the rendered frame may have changed. */
     onDirty: () => void;
     /** Called after the controller has finished closing itself. */

package/dist/clients/inbox/controller.js

@@ -230,8 +230,6 @@ export class InboxController {
         this.reviewAdapter = new ReviewAdapter({
             dir: item.dir,
             host: this.host,
-            tui: this.options.tui,
-            canvasSource: this.options.canvasSource,
         });
         try {
             await this.reviewAdapter.start();

package/dist/clients/inbox/review/__tests__/review-core.test.js

@@ -1,298 +1,8 @@
 import assert from 'node:assert/strict';
 import stringWidth from 'string-width';
-import { deriveAnchorUnits, remapUnitIndex, unitIndexForLine, unitRangeForSpan, } from '../anchors.js';
-import { closeList, commentedUnitSet, commitCompose, currentAnchor, deleteAtListIndex, ensureAnchorVisible, anchorRowRange, initReviewState, moveActiveUnit, moveListIndex, openComposeEdit, openComposeNew, openList, scrollBy, scrollToReveal, textBackspace, textEnd, textHome, textInsert, textVertical, textVerticalWrapped, textWordBackspace, textWordLeft, textWordRight, undoLast, } from '../state.js';
-import { maxHScroll, panBy, renderReviewFrame, } from '../frame.js';
-import { matchReviewKey } from '../keys.js';
-assert.equal(matchReviewKey('\x1bR'), null, 'legacy Alt+Shift+R remains viewer-global');
-assert.equal(matchReviewKey('\x1b[82;4u'), null, 'Kitty Alt+Shift+R remains viewer-global');
-assert.equal(matchReviewKey('\x1bi'), null, 'Alt+I remains owned outside the review surface');
-// A small doc: a heading, a two-bullet list, a paragraph. The list is ONE
-// top-level block but each bullet carries its own leaf span — so anchoring
-// steps bullet-to-bullet, not list-to-list.
-const sourceLines = ['# Title', '', '- line three', '- line four', '', 'line six'];
-const existingComment = {
-    id: 'c1',
-    revision: 1,
-    line: 6,
-    endLine: 6,
-    lineText: 'line six',
-    comment: 'note',
-    status: 'open',
-    authorKind: 'human',
-    createdAt: 'now',
-    anchorStatus: 'live',
-};
-const doc = {
-    lines: ['TITLE', '', '• row three', '• row four', '', 'row six'],
-    rows: [0, null, 1, 1, null, 2],
-    spans: [[1, 1], null, [3, 3], [4, 4], null, [6, 6]],
-    blocks: [
-        { type: 'paragraph', start: 1, end: 1 },
-        { type: 'paragraph', start: 3, end: 4 },
-        { type: 'paragraph', start: 6, end: 6 },
-    ],
-};
-const anchor = deriveAnchorUnits(doc);
-const { units } = anchor;
-// deriveAnchorUnits: one unit per leaf span run; rowUnits keys the painter.
-{
-    assert.equal(units.length, 4, 'each bullet is its own unit — the list block splits');
-    assert.deepEqual(units[0], { start: 1, end: 1, firstRow: 0, lastRow: 0 });
-    assert.deepEqual(units[1], { start: 3, end: 3, firstRow: 2, lastRow: 2 });
-    assert.deepEqual(units[2], { start: 4, end: 4, firstRow: 3, lastRow: 3 });
-    assert.deepEqual(units[3], { start: 6, end: 6, firstRow: 5, lastRow: 5 });
-    assert.deepEqual(anchor.rowUnits, [0, null, 1, 2, null, 3]);
-}
-// deriveAnchorUnits: consecutive rows sharing a span (a wrapped bullet)
-// collapse into one unit; a mapped row with no leaf span (an unmapped block)
-// anchors at its whole block's range; a separator between identical spans
-// still splits units.
-{
-    const d = {
-        lines: ['a1', 'a2 (wrapped)', '', 'chrome'],
-        rows: [0, 0, null, 1],
-        spans: [[2, 2], [2, 2], null, null],
-        blocks: [
-            { type: 'paragraph', start: 1, end: 3 },
-            { type: 'paragraph', start: 5, end: 9 },
-        ],
-    };
-    const a = deriveAnchorUnits(d);
-    assert.deepEqual(a.units, [
-        { start: 2, end: 2, firstRow: 0, lastRow: 1 },
-        { start: 5, end: 9, firstRow: 3, lastRow: 3 },
-    ]);
-    assert.deepEqual(a.rowUnits, [0, 0, null, 1]);
-}
-// deriveAnchorUnits: a fully unmapped doc degrades to one whole-doc unit.
-{
-    const d = { lines: ['x', 'y'], rows: [null, null], spans: [null, null], blocks: [{ type: 'paragraph', start: 1, end: 7 }] };
-    const a = deriveAnchorUnits(d);
-    assert.deepEqual(a.units, [{ start: 1, end: 7, firstRow: 0, lastRow: 1 }]);
-    assert.deepEqual(a.rowUnits, [0, 0]);
-}
-// unitIndexForLine: containment, forward snap across gaps, clamp past the end.
-{
-    assert.equal(unitIndexForLine(units, 1), 0);
-    assert.equal(unitIndexForLine(units, 2), 1, 'a gap line snaps forward to the next unit');
-    assert.equal(unitIndexForLine(units, 3), 1);
-    assert.equal(unitIndexForLine(units, 4), 2);
-    assert.equal(unitIndexForLine(units, 6), 3);
-    assert.equal(unitIndexForLine(units, 99), 3, 'past the last unit clamps to the last unit');
-}
-// unitRangeForSpan: all units overlapping a source range (chrome units carry
-// their block's whole range, so a whole-fence comment covers every fence unit).
-{
-    assert.deepEqual(unitRangeForSpan(units, 3, 4), { lo: 1, hi: 2 }, 'a two-bullet comment spans both bullet units');
-    assert.deepEqual(unitRangeForSpan(units, 6, 6), { lo: 3, hi: 3 });
-    assert.deepEqual(unitRangeForSpan(units, 2, 2), { lo: 1, hi: 1 }, 'a gap-only range snaps forward');
-    const fence = deriveAnchorUnits({
-        lines: ['┌─', 'code a', 'code b', '└─'],
-        rows: [0, 0, 0, 0],
-        spans: [[5, 10], [6, 6], [7, 7], [5, 10]],
-        blocks: [{ type: 'paragraph', start: 5, end: 10 }],
-    });
-    assert.equal(fence.units.length, 4, 'fence = top chrome + per-line content + bottom chrome');
-    assert.deepEqual(unitRangeForSpan(fence.units, 5, 10), { lo: 0, hi: 3 }, 'a whole-fence comment highlights every fence unit');
-    // Narrowest-containing lookup: a code line resolves to its own unit even
-    // though the whole-block chrome unit sits earlier in rendered order.
-    assert.equal(unitIndexForLine(fence.units, 6), 1, 'a code line resolves to its leaf unit, not the fence chrome');
-    assert.equal(unitIndexForLine(fence.units, 7), 2);
-    assert.equal(unitIndexForLine(fence.units, 5), 0, 'the fence opener resolves to the chrome unit');
-    // Resize remapping: an exact source-range match is preserved (chrome and
-    // leaf units share source lines), else the narrowest containing unit wins.
-    assert.equal(remapUnitIndex(fence.units, { start: 6, end: 6, firstRow: 9, lastRow: 9 }), 1, 'remap keeps a code-line anchor on its code line');
-    assert.equal(remapUnitIndex(fence.units, { start: 5, end: 10, firstRow: 9, lastRow: 9 }), 0, 'remap keeps a chrome anchor on the identical-range unit');
-    assert.equal(remapUnitIndex(fence.units, { start: 8, end: 9, firstRow: 0, lastRow: 0 }), 0, 'no exact match falls back to the best unit for its first line');
-}
-// Anchor motion: j/k move unit-to-unit; Shift+j/k extends across units.
-{
-    let state = initReviewState(sourceLines, anchor, [], 0);
-    assert.deepEqual(currentAnchor(state), { line: 1, endLine: 1 });
-    state = moveActiveUnit(state, 1, false);
-    assert.deepEqual(currentAnchor(state), { line: 3, endLine: 3 }, 'j moves to a single bullet, not the whole list');
-    state = moveActiveUnit(state, 1, true);
-    assert.deepEqual(currentAnchor(state), { line: 3, endLine: 4 }, 'shift+j extends the selection downward');
-    state = moveActiveUnit(state, 1, true);
-    assert.deepEqual(currentAnchor(state), { line: 3, endLine: 6 }, 'shift+j extends across the block boundary');
-    state = moveActiveUnit(state, -3, true);
-    assert.deepEqual(currentAnchor(state), { line: 1, endLine: 3 }, 'shift+k can extend the selection back past the anchor');
-    state = moveActiveUnit(state, 1, false);
-    assert.deepEqual(currentAnchor(state), { line: 3, endLine: 3 }, 'a plain j/k collapses the selection');
-    // Bounds
-    state = moveActiveUnit(state, -100, false);
-    assert.equal(state.activeUnit, 0, 'anchor cannot move above the first unit');
-    state = moveActiveUnit(state, 100, false);
-    assert.equal(state.activeUnit, units.length - 1, 'anchor cannot move past the last unit');
-}
-// currentAnchor over chrome units takes the min/max across the selection.
-{
-    const fence = deriveAnchorUnits({
-        lines: ['┌─', 'code a', '└─'],
-        rows: [0, 0, 0],
-        spans: [[5, 8], [6, 6], [5, 8]],
-        blocks: [{ type: 'paragraph', start: 5, end: 8 }],
-    });
-    let state = initReviewState(['', '', '', '', '```', 'a', 'b', '```'], fence, [], 0);
-    state = moveActiveUnit(state, 1, false); // content line unit
-    assert.deepEqual(currentAnchor(state), { line: 6, endLine: 6 });
-    state = moveActiveUnit(state, 1, true); // extend onto bottom chrome (5-8)
-    assert.deepEqual(currentAnchor(state), { line: 5, endLine: 8 }, 'chrome in the selection widens to the block range');
-}
-// An existing comment positions the initial anchor on its unit.
-{
-    const state = initReviewState(sourceLines, anchor, [existingComment], 0);
-    assert.equal(state.activeUnit, 3);
-}
-// Compose emits a daemon mutation payload without changing the projection.
-{
-    let state = initReviewState(sourceLines, anchor, [], 0);
-    state = moveActiveUnit(state, 1, false); // bullet unit → L3
-    state = moveActiveUnit(state, 1, true); // extend → L3-4
-    state = openComposeNew(state);
-    assert.equal(state.mode, 'compose');
-    assert.deepEqual(state.compose?.anchor, { line: 3, endLine: 4 });
-    state = { ...state, compose: { ...state.compose, buffer: 'needs a rewrite' } };
-    let committed = commitCompose(state);
-    state = committed.state;
-    assert.equal(state.mode, 'view');
-    assert.deepEqual(committed.commit, { editingId: null, anchor: { line: 3, endLine: 4 }, text: 'needs a rewrite' });
-    assert.deepEqual(state.comments, [], 'the daemon projection remains unchanged until refreshed');
-    // A projection refresh supplies the daemon-created comment before later edits.
-    state = { ...state, comments: [existingComment] };
-    // Empty compose closes without a mutation.
-    state = openComposeNew(state);
-    committed = commitCompose(state);
-    state = committed.state;
-    assert.equal(committed.commit, null);
-    assert.equal(state.mode, 'view');
-    // Editing from the list preserves selection and identifies the comment for the daemon.
-    state = moveActiveUnit(state, -100, false); // move anchor away first
-    state = openList(state);
-    state = openComposeEdit(state, 0);
-    assert.equal(state.compose?.editingId, existingComment.id);
-    assert.equal(state.activeUnit, 3, 'editing re-anchors onto the comment\'s last unit');
-    assert.equal(state.selectionAnchor, null, 'a single-line comment selects one unit');
-    state = { ...state, compose: { ...state.compose, buffer: 'edited note' } };
-    committed = commitCompose(state);
-    state = committed.state;
-    assert.equal(state.mode, 'list', 'editing from the list returns to the list');
-    assert.deepEqual(committed.commit, { editingId: existingComment.id, anchor: { line: 6, endLine: 6 }, text: 'edited note' });
-    assert.deepEqual(state.comments, [existingComment], 'editing does not locally alter the projection');
-    // The commented unit set marks every unit overlapped by the projection.
-    assert.deepEqual([...commentedUnitSet(state)], [3]);
-    state = closeList(state);
-    assert.equal(state.mode, 'view');
-    const undone = undoLast(state);
-    assert.equal(undone.id, existingComment.id, 'undo identifies the daemon comment to remove');
-    assert.deepEqual(undone.state.comments, [existingComment]);
-}
-// List navigation and delete-by-index identify daemon comments without changing the projection.
-{
-    const secondComment = { ...existingComment, id: 'c2', line: 3, endLine: 3, lineText: '- line three', comment: 'second' };
-    let state = initReviewState(sourceLines, anchor, [existingComment, secondComment], 0);
-    state = openList(state);
-    state = moveListIndex(state, 1);
-    assert.equal(state.listIndex, 1);
-    const deleted = deleteAtListIndex(state);
-    assert.equal(deleted.id, secondComment.id);
-    assert.deepEqual(deleted.state.comments, [existingComment, secondComment]);
-    assert.equal(deleted.state.listIndex, 1);
-}
-// anchorRowRange: the rendered rows spanned by a unit range.
-{
-    assert.deepEqual(anchorRowRange(units, 1, 2), { first: 2, last: 3 });
-    assert.deepEqual(anchorRowRange(units, 0, 3), { first: 0, last: 5 });
-    assert.equal(anchorRowRange(units, 9, 9), null);
-}
-// scrollToReveal: margin-aware reveal, top pin for oversize spans, clamping.
-{
-    assert.equal(scrollToReveal(0, 10, 11, 8, 30, 2), 6, 'reveals a below-view anchor with a bottom margin');
-    assert.equal(scrollToReveal(6, 1, 1, 8, 30, 2), 0, 'reveals an above-view anchor, clamped at the top');
-    assert.equal(scrollToReveal(0, 4, 20, 8, 30), 3, 'a taller-than-view span pins its first row one below the indicator row');
-    assert.equal(scrollToReveal(0, 0, 20, 8, 30), 0, 'an oversize span starting at the top pins at zero');
-    assert.equal(scrollToReveal(3, 5, 6, 8, 30), 3, 'an already-visible anchor leaves the scroll untouched');
-    assert.equal(scrollToReveal(50, 25, 25, 8, 30, 2), 22, 'a stale overshoot scroll is clamped into the document');
-    // The margin yields before it may push the span's own edges out of view.
-    assert.equal(scrollToReveal(0, 10, 16, 8, 30, 2), 10, 'down-reveal of a bodyHeight-1 span keeps its first row visible');
-    assert.equal(scrollToReveal(20, 10, 16, 8, 30, 2), 9, 'up-reveal of a bodyHeight-1 span keeps its last row visible');
-    assert.equal(scrollToReveal(0, 10, 10, 2, 30, 2), 10, 'a tiny viewport still shows the anchored row itself');
-}
-// ensureAnchorVisible follows the active unit's rendered rows.
-{
-    let state = initReviewState(sourceLines, anchor, [], 0);
-    state = { ...state, activeUnit: 3, scroll: 0 };
-    state = ensureAnchorVisible(state, doc, 2);
-    assert.equal(state.scroll, 4, 'the anchored unit\'s rows scroll into view');
-}
-// Scroll clamps to [0, totalLines - bodyHeight] and never goes negative.
-{
-    let state = initReviewState(sourceLines, anchor, [], 0);
-    state = scrollBy(state, -50, 10, 30);
-    assert.equal(state.scroll, 0, 'scroll cannot go negative');
-    state = scrollBy(state, 50, 10, 30);
-    assert.equal(state.scroll, 20, 'scroll clamps to the maximum');
-    state = scrollBy(state, 50, 10, 30);
-    assert.equal(state.scroll, 20, 'scroll stays clamped on repeated overshoot');
-}
-// Multi-line text-buffer helpers used by the compose input.
-{
-    let r = textInsert('', 0, 'hello');
-    assert.deepEqual(r, { buffer: 'hello', cursor: 5 });
-    r = textInsert(r.buffer, 5, '\nworld');
-    assert.deepEqual(r, { buffer: 'hello\nworld', cursor: 11 });
-    assert.equal(textHome(r.buffer, 11), 6, 'home jumps to the start of the current line');
-    assert.equal(textEnd(r.buffer, 6), 11, 'end jumps to the end of the current line');
-    assert.equal(textVertical(r.buffer, 8, -1), 2, 'up preserves the column on the previous line');
-    r = textBackspace(r.buffer, 11);
-    assert.deepEqual(r, { buffer: 'hello\nworl', cursor: 10 });
-}
-// Word motion and visual (wrapped) vertical motion in the compose box: alt+arrow
-// steps whole words, and up/down step the rows the box actually paints — a long
-// soft-wrapped comment is many visual rows even though it is one logical line.
-{
-    const b = 'alpha beta gamma';
-    assert.equal(textWordLeft(b, 16), 11, 'alt+left lands on the start of the word before the cursor');
-    assert.equal(textWordLeft(b, 11), 6, 'alt+left from a word start skips to the previous word');
-    assert.equal(textWordRight(b, 0), 5, 'alt+right lands just past the current word');
-    assert.equal(textWordRight(b, 5), 10, 'alt+right skips the space then the next word');
-    assert.deepEqual(textWordBackspace(b, 16), { buffer: 'alpha beta ', cursor: 11 }, 'alt+backspace erases one word');
-    // width 6 wraps into rows 'alpha ' | 'beta g' | 'amma'.
-    assert.equal(textVerticalWrapped(b, 2, 1, 6), 8, 'down moves to the next wrapped row, same column');
-    assert.equal(textVerticalWrapped(b, 8, -1, 6), 2, 'up moves back to the previous wrapped row');
-    assert.equal(textVerticalWrapped(b, 2, -1, 6), 2, 'up on the first row is a no-op');
-    assert.equal(textVerticalWrapped(b, 15, 1, 6), 15, 'down on the last row is a no-op');
-    assert.equal(textVerticalWrapped('ab\ncd', 1, 1, 40), 4, 'hard newlines still separate rows');
-}
-// Render frame: the anchor highlight (gutter bar + tint) covers exactly the
-// active unit's rows — one bullet, not the whole list — plus commented-unit
-// markers and a key-hints-only footer.
-{
-    let state = initReviewState(sourceLines, anchor, [], 0);
-    state = moveActiveUnit(state, 1, false); // first bullet (rendered row 2)
-    const frame = renderReviewFrame(state, 'doc.md', doc, 60, 20);
-    assert.equal(frame.length, 20, 'the frame always fills the requested row count');
-    const joined = frame.join('\n');
-    assert.match(joined, /Review — doc\.md/);
-    assert.match(joined, /0 comments/);
-    assert.ok(!joined.includes('Anchor:'), 'the view footer carries no anchor caption');
-    // Header is 3 rows; body row i shows doc row scroll+i.
-    const bodyRow2 = frame[3 + 2];
-    const bodyRow3 = frame[3 + 3];
-    const bodyRow0 = frame[3];
-    assert.ok(bodyRow2.includes('▌') && bodyRow2.includes('\x1b[48;5;236m'), 'the anchored bullet row gets the gutter bar and tint');
-    assert.ok(!bodyRow3.includes('▌'), 'the sibling bullet in the same list block is NOT highlighted');
-    assert.ok(!bodyRow0.includes('▌'), 'non-anchored rows carry no anchor gutter');
-    // A comment on the paragraph marks its rows with the commented gutter.
-    state = {
-        ...state,
-        comments: [existingComment],
-    };
-    const frame2 = renderReviewFrame(state, 'doc.md', doc, 60, 20);
-    assert.ok(frame2[3 + 5].includes('▎'), 'commented units get the comment gutter marker');
-    assert.ok(!frame2[3 + 3].includes('▎'), 'uncommented sibling units carry no comment marker');
-}
+import { deriveAnchorUnits } from '../anchors.js';
+import { initReviewState } from '../state.js';
+import { maxHScroll, panBy, renderReviewFrame } from '../frame.js';
 // ── Regression: a Mermaid diagram wider than the pane (reported bug) ────────
 // Wide diagram rows used to run past the terminal's right edge; the spillover
 // wrapped and was unreachable. Every emitted row must now fit the frame, and
@@ -313,6 +23,7 @@ const { units } = anchor;
     let s = initReviewState(['# t', '', 'diagram', '', 'tail'], deriveAnchorUnits(wideDoc), [], 0);
     const widths = (frame) => frame.map((line) => stringWidth(line));
     const frame = renderReviewFrame(s, 'doc.md', wideDoc, cols, 20);
+    assert.equal(frame.length, 20, 'the frame always fills the requested row count');
     assert.ok(Math.max(...widths(frame)) <= cols, 'every frame row fits inside the terminal');
     // The readable column stays centered while a full-pane diagram enters and
     // leaves the viewport; only the diagram rows claim the pane.

package/dist/clients/inbox/review/__tests__/teardown-notice.test.js

@@ -0,0 +1,100 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { ReviewDocumentSurface } from '../document-surface.js';
+// The host's restoring close (`closeEntry(entry, restore=true)`) disposes every
+// notice raised over the closing surface. A disposition stated before the close
+// therefore never paints — the regression the E-10b activation rerun caught
+// live. These tests pin the contract: teardown states its disposition only
+// after the handle close, on both the mounted and the pre-mount path.
+function liveSnapshot() {
+    const text = 'one line\n';
+    return {
+        text,
+        lines: ['one line'],
+        revision: 1,
+        status: 'live',
+        sha256: 'abc',
+        loadedAt: new Date().toISOString(),
+    };
+}
+function fakeSource() {
+    const snapshot = liveSnapshot();
+    return {
+        current: () => snapshot,
+        openText: () => snapshot.text,
+        onChange: () => { },
+        refreshNow: () => { },
+        close: () => { },
+    };
+}
+/** `align()` parks on the first await forever; teardown needs none of it. */
+function fakeComments() {
+    return {
+        anchorBase: () => new Promise(() => { }),
+        list: () => new Promise(() => { }),
+        create: () => Promise.reject(new Error('unused')),
+        edit: () => Promise.reject(new Error('unused')),
+        resolve: () => Promise.reject(new Error('unused')),
+        reopen: () => Promise.reject(new Error('unused')),
+        remove: () => Promise.reject(new Error('unused')),
+        remapRanges: () => Promise.reject(new Error('unused')),
+        onChanged: () => () => { },
+    };
+}
+function makeSurface(events) {
+    const services = {
+        notice: (text) => events.push(`notice:${text}`),
+        suspendForChild: () => () => { },
+        requestClose: () => { },
+        submit: () => { },
+        cancel: () => { },
+    };
+    return new ReviewDocumentSurface({
+        review: { reviewId: 'r1', companionNodeId: 'c1', file: '/tmp/x.md', cwd: '/tmp' },
+        source: fakeSource(),
+        comments: fakeComments(),
+        callerPane: undefined,
+        services,
+    });
+}
+function fakeHandle(events) {
+    const onClose = [];
+    let closed = false;
+    return {
+        close: () => {
+            if (closed)
+                return;
+            closed = true;
+            for (const fn of onClose)
+                void fn();
+            events.push('close');
+        },
+        invalidate: () => { },
+        onClose: (fn) => { onClose.push(fn); },
+    };
+}
+describe('review teardown disposition notice', () => {
+    it('states the disposition after the close on the mounted path', () => {
+        const events = [];
+        const surface = makeSurface(events);
+        surface.setHandle(fakeHandle(events));
+        surface.teardown('Review canceled.');
+        assert.deepEqual(events, ['close', 'notice:Review canceled.']);
+    });
+    it('re-states a pre-mount disposition after the deferred close', () => {
+        const events = [];
+        const surface = makeSurface(events);
+        surface.teardown('Review canceled.');
+        assert.deepEqual(events, ['notice:Review canceled.']);
+        surface.setHandle(fakeHandle(events));
+        assert.deepEqual(events, ['notice:Review canceled.', 'close', 'notice:Review canceled.']);
+    });
+    it('is idempotent — a second teardown neither closes nor notices again', () => {
+        const events = [];
+        const surface = makeSurface(events);
+        surface.setHandle(fakeHandle(events));
+        surface.teardown('Review canceled.');
+        surface.teardown('Approved — the document was not modified. Result: /tmp/r');
+        assert.deepEqual(events, ['close', 'notice:Review canceled.']);
+    });
+});

package/dist/clients/inbox/review/comments-client.d.ts

@@ -22,13 +22,14 @@ export declare class ReviewDocumentError extends Error {
 }
 /** The approved document coordinates every stored comment anchor is expressed against. */
 export interface AnchorBase {
-    /** Canonical reviewed file the base was captured from; a region rejects a mismatched target. */
+    /** Canonical reviewed file the base was captured from; the review surface rejects a mismatched target. */
     file: string;
     /** Full base document text, the left side of the base→current remap done before first paint. */
     text: string;
     /** Content hash of `text`, and the `fromDocHash` of that first remap batch. */
     docHash: string;
 }
+export type ReviewRequest = <T>(operation: () => Promise<T>) => Promise<T>;
 export interface CommentAuthority {
     anchorBase(): Promise<AnchorBase>;
     list(): Promise<AnchoredComment[]>;
@@ -63,4 +64,4 @@ export interface CommentAuthority {
     onChanged(fn: () => void): () => void;
 }
 /** The terminal's complete daemon seam for one review's comment projection. */
-export declare function createCommentAuthority(reviewId: string): CommentAuthority;
+export declare function createCommentAuthority(reviewId: string, request: ReviewRequest): CommentAuthority;