@north-light/crouter 0.3.170 → 0.3.172

package/dist/clients/inbox/review/state.d.ts

@@ -0,0 +1,143 @@
+import type { AnchoredComment } from './comments-client.js';
+import type { RenderedDoc } from '../../../core/termrender/termrender.js';
+import { type AnchorDoc, type AnchorUnit } from './anchors.js';
+export interface ComposeState {
+    buffer: string;
+    cursor: number;
+    /** Id of the comment being edited, or null when composing a new comment. */
+    editingId: string | null;
+    /** Submode to return to once compose closes (Escape or a successful save). */
+    returnMode: 'view' | 'list';
+    anchor: {
+        line: number;
+        endLine: number;
+    };
+}
+export interface ReviewState {
+    sourceLines: string[];
+    /** Ordered leaf anchor units. Never empty. */
+    units: AnchorUnit[];
+    /** Per rendered row: owning unit index, or null for separator rows. */
+    rowUnits: (number | null)[];
+    /** Current comment projection supplied by the daemon. */
+    comments: AnchoredComment[];
+    /** Revision of the live source snapshot the rendered units came from. */
+    sourceRevision: number;
+    /** Original ranges for comments whose current source range no longer survives. */
+    detached: Record<string, {
+        line: number;
+        endLine: number;
+    }>;
+    /** 0-based index of the anchored unit. */
+    activeUnit: number;
+    /** Set while a Shift+j/k range is being extended from this unit. */
+    selectionAnchor: number | null;
+    /** Scroll offset into the rendered (termrender) lines. */
+    scroll: number;
+    /** Horizontal pan offset, in display cells, for rows wider than the body
+     *  rectangle (diagrams). Rows that fit never move. */
+    hscroll: number;
+    mode: 'view' | 'list' | 'compose' | 'help';
+    compose: ComposeState | null;
+    listIndex: number;
+}
+/** Best unit for a source line: the NARROWEST unit containing it — code/table
+ *  chrome units carry their whole block's range and sit before the per-line
+ *  content units in rendered order, so "first whose end reaches the line"
+ *  would wrongly pick the chrome over the exact code line. A line no unit
+ *  contains (a blank separator) snaps forward to the next unit; past the end
+ *  clamps to the last. */
+export declare function initReviewState(sourceLines: string[], anchor: AnchorDoc, comments: AnchoredComment[], sourceRevision: number): ReviewState;
+export declare function selectedUnitBounds(state: ReviewState): {
+    lo: number;
+    hi: number;
+};
+/** Source-line anchor of the current unit selection — what a committed
+ *  comment records as `line`/`endLine`. Whole-block chrome units can carry a
+ *  wider range than their neighbors, so take the min/max over the selection
+ *  rather than trusting the endpoints alone. */
+export declare function currentAnchor(state: ReviewState): {
+    line: number;
+    endLine: number;
+};
+export declare function moveActiveUnit(state: ReviewState, delta: number, extend: boolean): ReviewState;
+/** Unit indices overlapped by any existing comment's source range. A projected
+ *  range lying wholly past the last unit (the file shrank before its range was
+ *  remapped) still gets a marker on its clamped unit, so every comment is
+ *  visible somewhere in the document. */
+export declare function commentedUnitSet(state: ReviewState): Set<number>;
+/** First/last rendered-row indices spanned by units `lo..hi`, or null when
+ *  the indices fall outside the unit list. */
+export declare function anchorRowRange(units: AnchorUnit[], lo: number, hi: number): {
+    first: number;
+    last: number;
+} | null;
+/** Minimal scroll adjustment that keeps rows `first..last` visible with
+ *  `margin` rows of context (the margin yields whenever honoring it would push
+ *  either edge of the span out of view); a taller-than-view span pins `first`
+ *  at the top — one row down when scrolled, so the `↑ more above` indicator
+ *  overwrites the preceding row, never the pinned one. Always returns a scroll
+ *  clamped to the document. */
+export declare function scrollToReveal(scroll: number, first: number, last: number, bodyHeight: number, total: number, margin?: number): number;
+/** Auto-scroll so the active unit (the moving edge of a selection) is
+ *  visible. Free-scrolling (`u`/`d`) is untouched until the next anchor move. */
+export declare function ensureAnchorVisible(state: ReviewState, doc: RenderedDoc, bodyHeight: number): ReviewState;
+export declare function scrollBy(state: ReviewState, delta: number, bodyHeight: number, totalLines: number): ReviewState;
+export declare function openComposeNew(state: ReviewState): ReviewState;
+export declare function openComposeEdit(state: ReviewState, index: number): ReviewState;
+export declare function closeCompose(state: ReviewState): ReviewState;
+export interface ComposeCommit {
+    editingId: string | null;
+    anchor: {
+        line: number;
+        endLine: number;
+    };
+    text: string;
+}
+/** Closes compose and returns the daemon mutation payload. The daemon projection, not this reducer, repaints comments. */
+export declare function commitCompose(state: ReviewState): {
+    state: ReviewState;
+    commit: ComposeCommit | null;
+};
+export declare function openList(state: ReviewState): ReviewState;
+export declare function closeList(state: ReviewState): ReviewState;
+export declare function moveListIndex(state: ReviewState, delta: number): ReviewState;
+export declare function deleteAtListIndex(state: ReviewState): {
+    state: ReviewState;
+    id: string | null;
+};
+export declare function undoLast(state: ReviewState): {
+    state: ReviewState;
+    id: string | null;
+};
+export declare function openHelp(state: ReviewState): ReviewState;
+export declare function closeHelp(state: ReviewState): ReviewState;
+export declare function cleanPastedText(input: string): string;
+export declare function textInsert(buffer: string, cursor: number, text: string): {
+    buffer: string;
+    cursor: number;
+};
+export declare function textBackspace(buffer: string, cursor: number): {
+    buffer: string;
+    cursor: number;
+};
+export declare function textDelete(buffer: string, cursor: number): {
+    buffer: string;
+    cursor: number;
+};
+export declare function textHome(buffer: string, cursor: number): number;
+export declare function textEnd(buffer: string, cursor: number): number;
+export declare function textVertical(buffer: string, cursor: number, delta: number): number;
+/** Vertical motion by *visual* row (what up/down mean in a wrapped compose box):
+ *  a long soft-wrapped comment has many rows even though it is one logical
+ *  line. Shares `verticalCursor` with the frame renderer's own wrap. */
+export declare function textVerticalWrapped(buffer: string, cursor: number, delta: number, width: number): number;
+/** Start of the word before the cursor (readline alt-b / alt+left). */
+export declare function textWordLeft(buffer: string, cursor: number): number;
+/** Just past the end of the word after the cursor (readline alt-f / alt+right). */
+export declare function textWordRight(buffer: string, cursor: number): number;
+/** Delete back to the start of the previous word (alt+backspace / ctrl+w). */
+export declare function textWordBackspace(buffer: string, cursor: number): {
+    buffer: string;
+    cursor: number;
+};

package/dist/clients/inbox/review/state.js

@@ -0,0 +1,282 @@
+import { verticalCursor } from '../tui/render.js';
+import { unitIndexForLine, unitRangeForSpan } from './anchors.js';
+/** Best unit for a source line: the NARROWEST unit containing it — code/table
+ *  chrome units carry their whole block's range and sit before the per-line
+ *  content units in rendered order, so "first whose end reaches the line"
+ *  would wrongly pick the chrome over the exact code line. A line no unit
+ *  contains (a blank separator) snaps forward to the next unit; past the end
+ *  clamps to the last. */
+export function initReviewState(sourceLines, anchor, comments, sourceRevision) {
+    const safe = anchor.units.length > 0
+        ? anchor
+        : { units: [{ start: 1, end: Math.max(1, sourceLines.length), firstRow: 0, lastRow: 0 }], rowUnits: anchor.rowUnits };
+    return {
+        sourceLines,
+        units: safe.units,
+        rowUnits: safe.rowUnits,
+        comments: [...comments],
+        sourceRevision,
+        detached: Object.fromEntries(comments.flatMap((comment) => comment.anchorStatus === 'detached'
+            ? [[comment.id, comment.originalRange ?? { line: comment.line, endLine: comment.endLine }]]
+            : [])),
+        activeUnit: comments.length > 0 ? unitIndexForLine(safe.units, comments[0].line) : 0,
+        selectionAnchor: null,
+        scroll: 0,
+        hscroll: 0,
+        mode: 'view',
+        compose: null,
+        listIndex: 0,
+    };
+}
+export function selectedUnitBounds(state) {
+    const sel = state.selectionAnchor ?? state.activeUnit;
+    return { lo: Math.min(state.activeUnit, sel), hi: Math.max(state.activeUnit, sel) };
+}
+/** Source-line anchor of the current unit selection — what a committed
+ *  comment records as `line`/`endLine`. Whole-block chrome units can carry a
+ *  wider range than their neighbors, so take the min/max over the selection
+ *  rather than trusting the endpoints alone. */
+export function currentAnchor(state) {
+    const { lo, hi } = selectedUnitBounds(state);
+    let line = Number.POSITIVE_INFINITY;
+    let endLine = 0;
+    for (let i = lo; i <= hi; i++) {
+        const u = state.units[i];
+        if (u === undefined)
+            continue;
+        line = Math.min(line, u.start);
+        endLine = Math.max(endLine, u.end);
+    }
+    if (!Number.isFinite(line))
+        return { line: 1, endLine: Math.max(1, state.sourceLines.length) };
+    return { line, endLine: Math.max(line, endLine) };
+}
+export function moveActiveUnit(state, delta, extend) {
+    const last = Math.max(0, state.units.length - 1);
+    const next = Math.max(0, Math.min(last, state.activeUnit + delta));
+    if (!extend)
+        return { ...state, activeUnit: next, selectionAnchor: null };
+    return { ...state, activeUnit: next, selectionAnchor: state.selectionAnchor ?? state.activeUnit };
+}
+/** Unit indices overlapped by any existing comment's source range. A projected
+ *  range lying wholly past the last unit (the file shrank before its range was
+ *  remapped) still gets a marker on its clamped unit, so every comment is
+ *  visible somewhere in the document. */
+export function commentedUnitSet(state) {
+    const out = new Set();
+    for (const c of state.comments) {
+        if (c.status === 'deleted' || c.anchorStatus === 'detached')
+            continue;
+        let hit = false;
+        state.units.forEach((u, i) => {
+            if (u.start <= c.endLine && u.end >= c.line) {
+                out.add(i);
+                hit = true;
+            }
+        });
+        if (!hit)
+            out.add(unitIndexForLine(state.units, c.line));
+    }
+    return out;
+}
+/** First/last rendered-row indices spanned by units `lo..hi`, or null when
+ *  the indices fall outside the unit list. */
+export function anchorRowRange(units, lo, hi) {
+    const a = units[lo];
+    const b = units[hi];
+    if (a === undefined || b === undefined)
+        return null;
+    return { first: a.firstRow, last: b.lastRow };
+}
+/** Minimal scroll adjustment that keeps rows `first..last` visible with
+ *  `margin` rows of context (the margin yields whenever honoring it would push
+ *  either edge of the span out of view); a taller-than-view span pins `first`
+ *  at the top — one row down when scrolled, so the `↑ more above` indicator
+ *  overwrites the preceding row, never the pinned one. Always returns a scroll
+ *  clamped to the document. */
+export function scrollToReveal(scroll, first, last, bodyHeight, total, margin = 2) {
+    const maxScroll = Math.max(0, total - bodyHeight);
+    let next = Math.max(0, Math.min(scroll, maxScroll));
+    if (last - first + 1 >= bodyHeight)
+        return Math.max(0, Math.min(Math.max(0, first - 1), maxScroll));
+    if (first - margin < next)
+        next = Math.max(first - margin, last - (bodyHeight - 1));
+    else if (last + margin > next + bodyHeight - 1)
+        next = Math.min(last + margin - (bodyHeight - 1), first);
+    return Math.max(0, Math.min(next, maxScroll));
+}
+/** Auto-scroll so the active unit (the moving edge of a selection) is
+ *  visible. Free-scrolling (`u`/`d`) is untouched until the next anchor move. */
+export function ensureAnchorVisible(state, doc, bodyHeight) {
+    const range = anchorRowRange(state.units, state.activeUnit, state.activeUnit);
+    if (range === null)
+        return state;
+    const scroll = scrollToReveal(state.scroll, range.first, range.last, bodyHeight, doc.lines.length);
+    return scroll === state.scroll ? state : { ...state, scroll };
+}
+export function scrollBy(state, delta, bodyHeight, totalLines) {
+    const maxScroll = Math.max(0, totalLines - bodyHeight);
+    return { ...state, scroll: Math.max(0, Math.min(state.scroll + delta, maxScroll)) };
+}
+export function openComposeNew(state) {
+    return { ...state, mode: 'compose', compose: { buffer: '', cursor: 0, editingId: null, returnMode: 'view', anchor: currentAnchor(state) } };
+}
+export function openComposeEdit(state, index) {
+    const comment = state.comments[index];
+    if (comment === undefined)
+        return state;
+    const buffer = comment.comment;
+    const { lo, hi } = unitRangeForSpan(state.units, comment.line, comment.endLine);
+    return {
+        ...state,
+        activeUnit: hi,
+        selectionAnchor: lo === hi ? null : lo,
+        mode: 'compose',
+        compose: { buffer, cursor: [...buffer].length, editingId: comment.id, returnMode: 'list', anchor: { line: comment.line, endLine: comment.endLine } },
+    };
+}
+export function closeCompose(state) {
+    const returnMode = state.compose?.returnMode ?? 'view';
+    return { ...state, mode: returnMode, compose: null };
+}
+/** Closes compose and returns the daemon mutation payload. The daemon projection, not this reducer, repaints comments. */
+export function commitCompose(state) {
+    const c = state.compose;
+    if (c === null || c === undefined)
+        return { state, commit: null };
+    const text = c.buffer.trim();
+    if (text.length === 0)
+        return { state: closeCompose(state), commit: null };
+    return {
+        state: closeCompose(state),
+        commit: { editingId: c.editingId, anchor: c.anchor, text },
+    };
+}
+export function openList(state) {
+    return { ...state, mode: 'list', listIndex: Math.max(0, Math.min(state.listIndex, state.comments.length - 1)) };
+}
+export function closeList(state) {
+    return { ...state, mode: 'view' };
+}
+export function moveListIndex(state, delta) {
+    if (state.comments.length === 0)
+        return state;
+    const next = Math.max(0, Math.min(state.comments.length - 1, state.listIndex + delta));
+    return { ...state, listIndex: next };
+}
+export function deleteAtListIndex(state) {
+    const comment = state.comments[state.listIndex];
+    return { state, id: comment?.id ?? null };
+}
+export function undoLast(state) {
+    return { state, id: state.comments.at(-1)?.id ?? null };
+}
+export function openHelp(state) {
+    return { ...state, mode: 'help' };
+}
+export function closeHelp(state) {
+    return { ...state, mode: 'view' };
+}
+// ── Multi-line text-buffer helpers (flat string + code-point cursor) ────────
+function codePoints(s) {
+    return [...s];
+}
+// A single physical keypress (including Enter) almost always arrives as its
+// own 'data' event, so parseKeypress's per-event key flags cover the normal
+// typing path. A chunk longer than one character is a paste (or, rarely,
+// several keystrokes the OS coalesced into one read) and is never re-parsed
+// for key semantics — an embedded CR there means a pasted newline, not a
+// commit. Mirrors tui/input.ts's paste cleaning: strip escape sequences,
+// normalize CR/CRLF to LF, drop remaining control bytes, keep LF.
+export function cleanPastedText(input) {
+    return input
+        .replace(/\x1b\[20[01]~/g, '')
+        .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '')
+        .replace(/\r\n?/g, '\n')
+        .replace(/[\x00-\x09\x0B-\x1F\x7F]/g, '');
+}
+export function textInsert(buffer, cursor, text) {
+    const chars = codePoints(buffer);
+    const at = Math.max(0, Math.min(cursor, chars.length));
+    const next = [...chars.slice(0, at), ...codePoints(text), ...chars.slice(at)].join('');
+    return { buffer: next, cursor: at + codePoints(text).length };
+}
+export function textBackspace(buffer, cursor) {
+    if (cursor <= 0)
+        return { buffer, cursor };
+    const chars = codePoints(buffer);
+    return { buffer: [...chars.slice(0, cursor - 1), ...chars.slice(cursor)].join(''), cursor: cursor - 1 };
+}
+export function textDelete(buffer, cursor) {
+    const chars = codePoints(buffer);
+    if (cursor >= chars.length)
+        return { buffer, cursor };
+    return { buffer: [...chars.slice(0, cursor), ...chars.slice(cursor + 1)].join(''), cursor };
+}
+function lineBoundsAt(chars, cursor) {
+    let start = cursor;
+    while (start > 0 && chars[start - 1] !== '\n')
+        start--;
+    let end = cursor;
+    while (end < chars.length && chars[end] !== '\n')
+        end++;
+    return { start, end };
+}
+export function textHome(buffer, cursor) {
+    return lineBoundsAt(codePoints(buffer), cursor).start;
+}
+export function textEnd(buffer, cursor) {
+    return lineBoundsAt(codePoints(buffer), cursor).end;
+}
+export function textVertical(buffer, cursor, delta) {
+    const chars = codePoints(buffer);
+    const { start, end } = lineBoundsAt(chars, cursor);
+    const col = cursor - start;
+    if (delta < 0) {
+        if (start === 0)
+            return cursor;
+        const prevEnd = start - 1; // the '\n' just before this line
+        const prevStart = lineBoundsAt(chars, prevEnd).start;
+        return Math.min(prevEnd, prevStart + col);
+    }
+    if (end >= chars.length)
+        return cursor;
+    const nextStart = end + 1;
+    const nextEnd = lineBoundsAt(chars, nextStart).end;
+    return Math.min(nextEnd, nextStart + col);
+}
+/** Vertical motion by *visual* row (what up/down mean in a wrapped compose box):
+ *  a long soft-wrapped comment has many rows even though it is one logical
+ *  line. Shares `verticalCursor` with the frame renderer's own wrap. */
+export function textVerticalWrapped(buffer, cursor, delta, width) {
+    return verticalCursor(buffer, cursor, delta, width);
+}
+/** Start of the word before the cursor (readline alt-b / alt+left). */
+export function textWordLeft(buffer, cursor) {
+    const chars = codePoints(buffer);
+    let i = Math.max(0, Math.min(cursor, chars.length));
+    while (i > 0 && /\s/.test(chars[i - 1]))
+        i--;
+    while (i > 0 && !/\s/.test(chars[i - 1]))
+        i--;
+    return i;
+}
+/** Just past the end of the word after the cursor (readline alt-f / alt+right). */
+export function textWordRight(buffer, cursor) {
+    const chars = codePoints(buffer);
+    let i = Math.max(0, Math.min(cursor, chars.length));
+    while (i < chars.length && /\s/.test(chars[i]))
+        i++;
+    while (i < chars.length && !/\s/.test(chars[i]))
+        i++;
+    return i;
+}
+/** Delete back to the start of the previous word (alt+backspace / ctrl+w). */
+export function textWordBackspace(buffer, cursor) {
+    const chars = codePoints(buffer);
+    const at = Math.max(0, Math.min(cursor, chars.length));
+    const to = textWordLeft(buffer, at);
+    if (to === at)
+        return { buffer, cursor: at };
+    return { buffer: [...chars.slice(0, to), ...chars.slice(at)].join(''), cursor: to };
+}

package/dist/clients/inbox/review-adapter.d.ts

@@ -0,0 +1,29 @@
+import type { TUI } from '@earendil-works/pi-tui';
+import type { CanvasSource } from '../../core/canvas/source.js';
+import type { SurfaceHost } from '../surfaces/host.js';
+export interface ReviewAdapterOptions {
+    host: SurfaceHost;
+    dir: string;
+    /** Threaded from the attach session so the composed surface can attach the
+     *  companion's transcript through the same terminal and canvas read authority
+     *  the outer viewer already holds. */
+    tui: TUI;
+    canvasSource: CanvasSource;
+}
+/**
+ * Resolves a durable review ticket to its canonical daemon review and mounts
+ * the one composed terminal review surface. Approval flows entirely through
+ * `reviewClient.submit` inside that composition — this adapter owns only the
+ * bridge lookup and the mounted surface's lifecycle.
+ */
+export declare class ReviewAdapter {
+    private readonly opts;
+    private running;
+    private stopped;
+    private mountedHandle;
+    constructor(opts: ReviewAdapterOptions);
+    start(): Promise<void>;
+    /** Toggle, cancellation, and controller teardown all take this same path. */
+    stop(): Promise<void>;
+    private run;
+}

package/dist/clients/inbox/review-adapter.js

@@ -0,0 +1,92 @@
+import { basename } from 'node:path';
+import { ApiError } from '../../api/errors.js';
+import { openComposedReview } from './review/launch.js';
+import { createReviewClient } from './review/review-client.js';
+/**
+ * Resolves a durable review ticket to its canonical daemon review and mounts
+ * the one composed terminal review surface. Approval flows entirely through
+ * `reviewClient.submit` inside that composition — this adapter owns only the
+ * bridge lookup and the mounted surface's lifecycle.
+ */
+export class ReviewAdapter {
+    opts;
+    running = null;
+    stopped = false;
+    mountedHandle;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    start() {
+        if (this.running !== null)
+            return this.running;
+        this.running = this.run();
+        return this.running;
+    }
+    /** Toggle, cancellation, and controller teardown all take this same path. */
+    async stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        this.mountedHandle?.close();
+        if (this.running !== null)
+            await this.running;
+    }
+    async run() {
+        const bridgeNodeId = basename(this.opts.dir);
+        let reviewId;
+        try {
+            ({ reviewId } = await createReviewClient().byBridge(bridgeNodeId));
+        }
+        catch (error) {
+            if (!isReviewPredatesSystem(error))
+                throw error;
+            this.opts.host.notice('This review predates canonical review records — cancel it and re-file the review.');
+            return;
+        }
+        if (this.stopped)
+            return;
+        let resolveClosed;
+        const closed = new Promise((resolve) => { resolveClosed = resolve; });
+        const host = wrapHostForMount(this.opts.host, (handle) => {
+            this.mountedHandle = handle;
+            handle.onClose(() => {
+                this.mountedHandle = undefined;
+                resolveClosed();
+            });
+        });
+        await openComposedReview(host, {
+            reviewId,
+            tui: this.opts.tui,
+            canvasSource: this.opts.canvasSource,
+        });
+        // A remote refusal, a terminal-review notice, or a live-source failure
+        // reports through `host.notice` and returns without ever mounting.
+        if (this.mountedHandle === undefined)
+            return;
+        if (this.stopped) {
+            this.mountedHandle.close();
+            return;
+        }
+        await closed;
+    }
+}
+/** Observes the one surface `openComposedReview` mounts so this adapter can
+ *  await its close and close it itself from `stop()`, without widening
+ *  `SurfaceHost` or reaching into the real host's internals. */
+function wrapHostForMount(host, onMount) {
+    return {
+        capabilities: host.capabilities,
+        mount: (component, opts) => {
+            const handle = host.mount(component, opts);
+            onMount(handle);
+            return handle;
+        },
+        notice: (text) => host.notice(text),
+        suspendForChild: () => host.suspendForChild(),
+        focusNode: (nodeId) => host.focusNode(nodeId),
+        pickReviewFile: (spec) => host.pickReviewFile(spec),
+    };
+}
+function isReviewPredatesSystem(error) {
+    return error instanceof ApiError && error.status === 409 && error.code === 'review_predates_system';
+}

package/dist/clients/inbox/review-visibility.d.ts

@@ -0,0 +1,5 @@
+import type { TicketSummary } from '../../core/human/types.js';
+/** Match the daemon's opaque inbox id: canonical tickets root, NUL, bridge id. */
+export declare function opaqueTicketId(canonicalTicketsRoot: string, bridgeNodeId: string): string;
+/** Retain local deck rows and only daemon-visible review rows. */
+export declare function filterVisibleReviewTickets(tickets: readonly TicketSummary[], visibleIds: ReadonlySet<string>): TicketSummary[];

package/dist/clients/inbox/review-visibility.js

@@ -0,0 +1,19 @@
+import { createHash } from 'node:crypto';
+import { realpathSync } from 'node:fs';
+import { basename } from 'node:path';
+import { ticketsRoot } from '../../core/human/root.js';
+/** Match the daemon's opaque inbox id: canonical tickets root, NUL, bridge id. */
+export function opaqueTicketId(canonicalTicketsRoot, bridgeNodeId) {
+    return createHash('sha256').update(`${canonicalTicketsRoot}\0${bridgeNodeId}`, 'utf8').digest('hex');
+}
+/** Retain local deck rows and only daemon-visible review rows. */
+export function filterVisibleReviewTickets(tickets, visibleIds) {
+    let canonicalTicketsRoot;
+    try {
+        canonicalTicketsRoot = realpathSync(ticketsRoot());
+    }
+    catch {
+        return tickets.filter((ticket) => ticket.kind !== 'review');
+    }
+    return tickets.filter((ticket) => ticket.kind !== 'review' || visibleIds.has(opaqueTicketId(canonicalTicketsRoot, basename(ticket.dir))));
+}

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

@@ -0,0 +1,19 @@
+import type { TUI } from '@earendil-works/pi-tui';
+import type { SurfaceHost } from '../surfaces/host.js';
+import type { TicketSummary } from '../../core/human/types.js';
+import type { CanvasSource } from '../../core/canvas/source.js';
+export interface InboxSurfaceOptions {
+    host: SurfaceHost;
+    tui: TUI;
+    canvasSource: CanvasSource;
+    /** Injection seams for tests; production passes none. */
+    scan?: () => TicketSummary[];
+}
+export interface InboxSurfaceOwner {
+    /** Mount when closed and close when open. */
+    toggle(): void;
+    /** Idempotent surface and controller teardown. */
+    close(): void;
+    isOpen(): boolean;
+}
+export declare function createInboxSurface(opts: InboxSurfaceOptions): InboxSurfaceOwner;