@north-light/api 0.3.580 → 0.3.588

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

@@ -0,0 +1,170 @@
+import { basename } from 'node:path';
+import { displayMessage, getPaneOption, openNodeWindow, paneLocation, selectWindow, shellQuote, viewerSplitEnv, windowIndex, } from '../../../core/runtime/placement-tmux.js';
+import { ReviewDocumentSurface } from './document-surface.js';
+import { openLiveSource } from './live-source.js';
+import { createReviewClient, ReviewTerminalError, terminalRefusalNotice, } from './review-client.js';
+const ATTACH_REVIEW_ENV = 'CRTR_ATTACH_REVIEW_ID';
+/** Open a dedicated viewer window for a review without replacing the caller's
+ *  conversation window. The fresh viewer consumes the review id at startup. */
+export function openReviewWindow(host, review) {
+    if (host.capabilities.remote) {
+        host.notice('The review is unavailable in a remote attach — the file and companion live on the host.');
+        return false;
+    }
+    const callerPane = host.capabilities.selfPane;
+    if (callerPane === undefined || callerPane === '') {
+        host.notice('Opening a review needs a local viewer in tmux.');
+        return false;
+    }
+    const location = paneLocation(callerPane);
+    const nodeId = getPaneOption(callerPane, '@crtr_node');
+    if (location === null || nodeId === undefined || nodeId === '') {
+        host.notice('Could not resolve the current viewer for this review.');
+        return false;
+    }
+    const windowName = `review:${basename(review.file)}`;
+    const opened = openNodeWindow({
+        session: location.session,
+        name: windowName,
+        cwd: review.cwd,
+        env: { ...viewerSplitEnv(), [ATTACH_REVIEW_ENV]: review.reviewId },
+        command: `crtr surface attach to ${shellQuote(nodeId)}`,
+    });
+    if (opened === null) {
+        host.notice('tmux could not open the review window.');
+        return false;
+    }
+    const fromIndex = windowIndex(location.window);
+    const toIndex = windowIndex(opened.window);
+    selectWindow(location.session, opened.window);
+    // Tell the person where the review went and how to get back; the caller's
+    // pane targets the client now showing the new window in this session.
+    if (toIndex !== null) {
+        displayMessage(reviewOpenedMessage(toIndex, windowName, fromIndex), callerPane, 5000);
+    }
+    return true;
+}
+/** The status-line toast shown once a review window opens. */
+export function reviewOpenedMessage(toIndex, windowName, fromIndex) {
+    // tmux binds only prefix 0–9 to select-window, so a two-digit window gets no
+    // key hint — just the number to go back to.
+    const back = fromIndex === null
+        ? ''
+        : fromIndex <= 9
+            ? ` — prefix ${fromIndex} returns to window ${fromIndex}`
+            : ` — you were in window ${fromIndex}`;
+    return `Review opened in new window ${toIndex} (${windowName})${back}`;
+}
+/** Consume the review id handed to a dedicated attach viewer. */
+export function takeStartupReviewId() {
+    const reviewId = process.env[ATTACH_REVIEW_ENV];
+    delete process.env[ATTACH_REVIEW_ENV];
+    return reviewId === undefined || reviewId === '' ? undefined : reviewId;
+}
+/** Resolve and mount the review seeded into a dedicated viewer window. */
+export async function openReviewSurfaceById(host, reviewId) {
+    try {
+        const review = await createReviewClient().byId(reviewId);
+        await openReviewSurface(host, { review });
+    }
+    catch (error) {
+        host.notice(error instanceof ReviewTerminalError
+            ? terminalRefusalNotice(error)
+            : `couldn't open review: ${describeError(error)}`);
+    }
+}
+/** Mount the review document inside its dedicated viewer window. */
+export async function openReviewSurface(host, opts) {
+    const review = opts.review;
+    let source;
+    try {
+        source = openLiveSource(review.file);
+    }
+    catch (error) {
+        host.notice(`couldn't open ${review.file}: ${describeError(error)}`);
+        return;
+    }
+    let terminalConflict = false;
+    const reviewClient = createReviewClient({
+        onTerminalConflict: (notice) => {
+            terminalConflict = true;
+            finish(notice);
+        },
+    });
+    const comments = reviewClient.comments(review.reviewId);
+    let handle;
+    let submitting = false;
+    let canceling = false;
+    const surface = new ReviewDocumentSurface({
+        review,
+        source,
+        comments,
+        callerPane: host.capabilities.selfPane,
+        services: {
+            notice: (text, opts) => host.notice(text, opts),
+            suspendForChild: () => host.suspendForChild(),
+            requestClose: () => handle?.close(),
+            submit: () => { void submit(); },
+            cancel: () => { void cancel(); },
+        },
+    });
+    await surface.open();
+    handle = host.mount(surface);
+    surface.setHandle(handle);
+    // The conversation is opened only once the document is standing, so a tmux
+    // refusal costs the person a notice rather than the review. The tmux calls
+    // are blocking subprocesses, so they are deferred past the render tick the
+    // mount just scheduled — a macrotask lands after it, a microtask would not.
+    setImmediate(() => { surface.openCompanion(); });
+    async function submit() {
+        if (submitting)
+            return;
+        submitting = true;
+        try {
+            const disposition = await reviewClient.submit(review.reviewId);
+            if (disposition.outcome === 'approved') {
+                finish(approvalNotice(disposition));
+                return;
+            }
+            // The companion is mid-edit. The review is off the human's hands either
+            // way: the daemon approves the document as it reads once the companion
+            // stops, and the origin has already been told the approval is coming.
+            // Sticky, because the wait outlives a three-second notice — the review's
+            // cockpit row below the editor carries it from there.
+            finish('Review submitted before the companion finished — the agent resumes when the review completes.', { sticky: true });
+        }
+        catch (error) {
+            if (terminalConflict)
+                return;
+            submitting = false;
+            host.notice(`couldn't submit review: ${describeError(error)}`);
+        }
+    }
+    function finish(notice, opts) {
+        surface.teardown(notice, opts);
+    }
+    async function cancel() {
+        if (canceling)
+            return;
+        canceling = true;
+        try {
+            await reviewClient.cancel(review.reviewId, 'canceled from the review surface');
+            finish('Review canceled.');
+        }
+        catch (error) {
+            if (terminalConflict)
+                return;
+            // Nothing moved: the review is still open and both panes stand.
+            canceling = false;
+            host.notice(`couldn't cancel review: ${describeError(error)}`);
+        }
+    }
+}
+function approvalNotice(result) {
+    return result.changed
+        ? `Approved — the document changed during review. Result: ${result.resultPath}`
+        : `Approved — the document was not modified. Result: ${result.resultPath}`;
+}
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/clients/inbox/review/live-source.d.ts

@@ -0,0 +1,24 @@
+/** The trailing delay used to collapse an editor's write/rename burst. */
+export declare const COALESCE_MS = 120;
+export type StaleReason = 'missing' | 'unreadable' | 'too-large' | 'binary';
+export interface SourceSnapshot {
+    text: string;
+    lines: string[];
+    revision: number;
+    status: 'live' | 'stale';
+    staleReason?: StaleReason;
+    sha256: string;
+    loadedAt: string;
+}
+export interface LiveSource {
+    current(): SourceSnapshot;
+    /** The text captured when the surface opened. */
+    openText(): string;
+    /** Fires only when text changes or the live/stale status flips. */
+    onChange(fn: (next: SourceSnapshot, previous: SourceSnapshot) => void): void;
+    /** Read immediately, bypassing the directory watcher and coalescing timer. */
+    refreshNow(): void;
+    close(): void;
+}
+/** Watch the containing directory so atomic replacement of the file remains live. */
+export declare function openLiveSource(absFile: string): LiveSource;

package/dist/clients/inbox/review/live-source.js

@@ -0,0 +1,160 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, statSync, watch } from 'node:fs';
+import { basename, dirname } from 'node:path';
+import { documentLines } from '../../../core/document-lines.js';
+import { checkReviewableFile } from '../../../core/human/visible-paths.js';
+/** The trailing delay used to collapse an editor's write/rename burst. */
+export const COALESCE_MS = 120;
+function hashText(text) {
+    return createHash('sha256').update(text, 'utf8').digest('hex');
+}
+function staleReasonFromCheck(reason) {
+    if (reason.includes('UTF-8'))
+        return 'binary';
+    if (reason.includes('too large') || reason.includes('too long'))
+        return 'too-large';
+    return 'unreadable';
+}
+function readSource(absFile) {
+    try {
+        const stat = statSync(absFile);
+        if (!stat.isFile())
+            return { status: 'stale', reason: 'missing' };
+    }
+    catch (error) {
+        return {
+            status: 'stale',
+            reason: error.code === 'ENOENT' ? 'missing' : 'unreadable',
+        };
+    }
+    const check = checkReviewableFile(absFile);
+    if (!check.ok) {
+        if (check.reason === 'not a file')
+            return { status: 'stale', reason: 'unreadable' };
+        return { status: 'stale', reason: staleReasonFromCheck(check.reason) };
+    }
+    try {
+        const text = readFileSync(absFile, 'utf8');
+        return {
+            status: 'live',
+            text,
+            sha256: hashText(text),
+            loadedAt: new Date().toISOString(),
+        };
+    }
+    catch {
+        return { status: 'stale', reason: 'unreadable' };
+    }
+}
+function initialSnapshot(absFile) {
+    const result = readSource(absFile);
+    if (result.status === 'stale') {
+        throw new Error(`Unable to open live source ${absFile}: ${result.reason}`);
+    }
+    return {
+        text: result.text,
+        lines: documentLines(result.text),
+        revision: 0,
+        status: 'live',
+        sha256: result.sha256,
+        loadedAt: result.loadedAt,
+    };
+}
+/** Watch the containing directory so atomic replacement of the file remains live. */
+export function openLiveSource(absFile) {
+    let snapshot = initialSnapshot(absFile);
+    const openedText = snapshot.text;
+    const listeners = new Set();
+    const target = basename(absFile);
+    let watcher;
+    let timer;
+    let closed = false;
+    const refreshNow = () => {
+        if (closed)
+            return;
+        const result = readSource(absFile);
+        const previous = snapshot;
+        if (result.status === 'stale') {
+            const next = {
+                ...previous,
+                status: 'stale',
+                staleReason: result.reason,
+            };
+            snapshot = next;
+            if (previous.status === next.status)
+                return;
+            for (const listener of listeners) {
+                if (!closed)
+                    listener(next, previous);
+            }
+            return;
+        }
+        const textChanged = result.text !== previous.text;
+        const statusChanged = previous.status !== 'live';
+        const next = {
+            text: result.text,
+            lines: textChanged ? documentLines(result.text) : previous.lines,
+            revision: previous.revision + (textChanged ? 1 : 0),
+            status: 'live',
+            sha256: result.sha256,
+            loadedAt: textChanged || statusChanged ? result.loadedAt : previous.loadedAt,
+        };
+        snapshot = next;
+        if (!textChanged && !statusChanged)
+            return;
+        for (const listener of listeners) {
+            if (!closed)
+                listener(next, previous);
+        }
+    };
+    const scheduleRefresh = () => {
+        if (closed)
+            return;
+        if (timer !== undefined)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = undefined;
+            if (!closed)
+                refreshNow();
+        }, COALESCE_MS);
+    };
+    try {
+        watcher = watch(dirname(absFile), (_event, filename) => {
+            if (!closed && filename !== null && String(filename) === target)
+                scheduleRefresh();
+        });
+        watcher.on('error', () => {
+            // The next explicit refresh remains authoritative; a directory watcher
+            // error must not terminate the viewer process.
+        });
+    }
+    catch {
+        // A source that was readable at open remains usable through refreshNow().
+    }
+    return {
+        current: () => snapshot,
+        openText: () => openedText,
+        onChange: (fn) => {
+            if (!closed)
+                listeners.add(fn);
+        },
+        refreshNow,
+        close: () => {
+            if (closed)
+                return;
+            closed = true;
+            if (timer !== undefined) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+            listeners.clear();
+            try {
+                watcher?.close();
+            }
+            catch {
+                // Teardown is best effort when the watcher has already failed.
+            }
+            watcher = undefined;
+        },
+    };
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Open the reviewed file in the user's configured editor, optionally at a specific line.
+ * Resolves $VISUAL, then $EDITOR, then the first installed of nano/pico/micro/nvim/vim/vi.
+ * The configured value may be a shell fragment such as "code --wait" — it runs whole
+ * through /bin/sh, exactly like the comment-compose round-trip editor.
+ * For vi-family editors (nvim, vim, vi, view), passes the line with the +line syntax.
+ * For other editors, opens the file without line positioning.
+ *
+ * @param absFile - Absolute path to the file to edit
+ * @param line - 1-based line number (only used for vi-family editors)
+ * @returns An object with an optional `error` property if the editor launch or execution failed
+ */
+export declare function openReviewedFileInEditor(absFile: string, line: number): {
+    error?: string;
+};

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

@@ -0,0 +1,43 @@
+import { spawnSync } from 'node:child_process';
+import { announceFallbackEditor, editorBasename, isViFamilyEditor, NO_EDITOR_MESSAGE, resolveEditor } from '../../../core/editor-resolver.js';
+/**
+ * Open the reviewed file in the user's configured editor, optionally at a specific line.
+ * Resolves $VISUAL, then $EDITOR, then the first installed of nano/pico/micro/nvim/vim/vi.
+ * The configured value may be a shell fragment such as "code --wait" — it runs whole
+ * through /bin/sh, exactly like the comment-compose round-trip editor.
+ * For vi-family editors (nvim, vim, vi, view), passes the line with the +line syntax.
+ * For other editors, opens the file without line positioning.
+ *
+ * @param absFile - Absolute path to the file to edit
+ * @param line - 1-based line number (only used for vi-family editors)
+ * @returns An object with an optional `error` property if the editor launch or execution failed
+ */
+export function openReviewedFileInEditor(absFile, line) {
+    const resolved = resolveEditor();
+    if (resolved === null)
+        return { error: NO_EDITOR_MESSAGE };
+    const editor = resolved.command;
+    // vi-family editors take the line as +N; nano takes +N too.
+    const lineArg = isViFamilyEditor(editor) || editorBasename(editor) === 'nano' ? ` "+${line}"` : '';
+    try {
+        announceFallbackEditor(resolved);
+        const result = spawnSync('/bin/sh', ['-c', `${editor}${lineArg} "$1"`, 'sh', absFile], { stdio: 'inherit' });
+        if (result.error) {
+            return { error: `$EDITOR ("${editor}") failed to launch: ${result.error.message}` };
+        }
+        if (result.signal !== null) {
+            return { error: `$EDITOR ("${editor}") was killed by signal ${result.signal}` };
+        }
+        if (result.status === 127 || result.status === 126) {
+            return { error: `$EDITOR ("${editor}") failed to launch (shell exit ${result.status}) — check $VISUAL/$EDITOR` };
+        }
+        if (result.status !== 0) {
+            return { error: `$EDITOR ("${editor}") exited with code ${result.status}` };
+        }
+        return {};
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { error: message };
+    }
+}

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

@@ -0,0 +1,51 @@
+/**
+ * Line-based range remapping with whole-line LCS.
+ *
+ * Normalizes lines, trims common prefix/suffix, applies monotone LCS to the
+ * middle section, and builds a stable mapping from old→new line numbers.
+ * Remapped ranges become detached when no line survives, shifted when partly
+ * deleted, or kept when both endpoints are unmoved.
+ */
+/**
+ * A monotone partial mapping from old line numbers to new ones (both 0-based).
+ * Returns undefined when a line was deleted.
+ */
+export interface LineMap {
+    get(oldLine: number): number | undefined;
+}
+/**
+ * The result of remapping a range: kept (unmoved), shifted (partially survived),
+ * or detached (no lines survived).
+ */
+export type RemapResult = {
+    kind: 'kept';
+    line: number;
+    endLine: number;
+} | {
+    kind: 'shifted';
+    line: number;
+    endLine: number;
+} | {
+    kind: 'detached';
+};
+/**
+ * Build a monotone line-number mapping from old→new using LCS.
+ *
+ * - Normalizes all lines using D14: `line.replace(/\s+/g, ' ').trim()`
+ * - Trims common prefix and suffix before LCS
+ * - Applies whole-line LCS to the middle section
+ * - Returns a map where `get(oldLine)` is the new line number or undefined
+ */
+export declare function buildLineMap(oldLines: readonly string[], newLines: readonly string[]): LineMap;
+/**
+ * Remap a range [line, endLine) using the built LineMap.
+ *
+ * Returns:
+ * - `kept`: both endpoints are unmoved
+ * - `shifted`: the range is partially deleted; maps to the min/max of survivors
+ * - `detached`: no lines from the range survived
+ */
+export declare function remapRange(map: LineMap, range: {
+    line: number;
+    endLine: number;
+}): RemapResult;

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

@@ -0,0 +1,157 @@
+/**
+ * Line-based range remapping with whole-line LCS.
+ *
+ * Normalizes lines, trims common prefix/suffix, applies monotone LCS to the
+ * middle section, and builds a stable mapping from old→new line numbers.
+ * Remapped ranges become detached when no line survives, shifted when partly
+ * deleted, or kept when both endpoints are unmoved.
+ */
+/** Normalize a line for comparison: collapse whitespace and trim. */
+function normalizeLine(line) {
+    return line.replace(/\s+/g, ' ').trim();
+}
+/**
+ * Build a monotone line-number mapping from old→new using LCS.
+ *
+ * - Normalizes all lines using D14: `line.replace(/\s+/g, ' ').trim()`
+ * - Trims common prefix and suffix before LCS
+ * - Applies whole-line LCS to the middle section
+ * - Returns a map where `get(oldLine)` is the new line number or undefined
+ */
+export function buildLineMap(oldLines, newLines) {
+    // Normalize all lines once
+    const oldNorm = oldLines.map(normalizeLine);
+    const newNorm = newLines.map(normalizeLine);
+    // Find common prefix length
+    let prefixLen = 0;
+    const minPrefix = Math.min(oldNorm.length, newNorm.length);
+    while (prefixLen < minPrefix &&
+        oldNorm[prefixLen] === newNorm[prefixLen]) {
+        prefixLen++;
+    }
+    // Find common suffix length
+    let suffixLen = 0;
+    const minSuffix = Math.min(oldNorm.length - prefixLen, newNorm.length - prefixLen);
+    while (suffixLen < minSuffix &&
+        oldNorm[oldNorm.length - 1 - suffixLen] ===
+            newNorm[newNorm.length - 1 - suffixLen]) {
+        suffixLen++;
+    }
+    // Extract middle sections for LCS
+    const oldMiddleEnd = oldNorm.length - suffixLen;
+    const newMiddleEnd = newNorm.length - suffixLen;
+    const oldMiddle = oldNorm.slice(prefixLen, oldMiddleEnd);
+    const newMiddle = newNorm.slice(prefixLen, newMiddleEnd);
+    // Compute LCS on the middle section
+    const lcsMap = computeLCS(oldMiddle, newMiddle);
+    // Build the final map: prefix + lcsMap + suffix
+    const map = new Map();
+    // Common prefix: identity mapping
+    for (let i = 0; i < prefixLen; i++) {
+        map.set(i, i);
+    }
+    // Middle section from LCS
+    lcsMap.forEach((newIdx, oldIdx) => {
+        map.set(prefixLen + oldIdx, prefixLen + newIdx);
+    });
+    // Common suffix: offset identity mapping
+    for (let i = 0; i < suffixLen; i++) {
+        const oldLine = oldMiddleEnd + i;
+        const newLine = newMiddleEnd + i;
+        map.set(oldLine, newLine);
+    }
+    return {
+        get(oldLine) {
+            return map.get(oldLine);
+        },
+    };
+}
+/**
+ * Compute LCS (Longest Common Subsequence) as a monotone mapping of old→new indices.
+ * Uses dynamic programming to find matching lines and returns only the matching pairs.
+ *
+ * For optimal whole-line matching, we want the longest common subsequence
+ * of line indices, preserving the relative order in both sequences.
+ */
+function computeLCS(oldLines, newLines) {
+    const m = oldLines.length;
+    const n = newLines.length;
+    if (m === 0 || n === 0) {
+        return new Map();
+    }
+    // DP table: dp[i][j] = length of LCS for oldLines[0..i-1] and newLines[0..j-1]
+    const dp = Array(m + 1)
+        .fill(null)
+        .map(() => Array(n + 1).fill(0));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (oldLines[i - 1] === newLines[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            }
+            else {
+                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    // Backtrack to find the LCS and build the mapping
+    const matches = new Map();
+    let i = m;
+    let j = n;
+    while (i > 0 && j > 0) {
+        if (oldLines[i - 1] === newLines[j - 1]) {
+            // Match found
+            matches.set(i - 1, j - 1);
+            i--;
+            j--;
+        }
+        else if (dp[i - 1][j] > dp[i][j - 1]) {
+            // oldLines[i-1] was deleted
+            i--;
+        }
+        else {
+            // newLines[j-1] was inserted
+            j--;
+        }
+    }
+    return matches;
+}
+/**
+ * Remap a range [line, endLine) using the built LineMap.
+ *
+ * Returns:
+ * - `kept`: both endpoints are unmoved
+ * - `shifted`: the range is partially deleted; maps to the min/max of survivors
+ * - `detached`: no lines from the range survived
+ */
+export function remapRange(map, range) {
+    const oldStart = range.line;
+    const oldEnd = range.endLine;
+    // Collect all surviving line numbers in the old range
+    let minNew;
+    let maxNew;
+    for (let oldLine = oldStart; oldLine < oldEnd; oldLine++) {
+        const newLine = map.get(oldLine);
+        if (newLine !== undefined) {
+            if (minNew === undefined || newLine < minNew) {
+                minNew = newLine;
+            }
+            if (maxNew === undefined || newLine > maxNew) {
+                maxNew = newLine;
+            }
+        }
+    }
+    if (minNew === undefined) {
+        return { kind: 'detached' };
+    }
+    // Check if both endpoints were preserved in their exact positions
+    const startSurvived = map.get(oldStart);
+    const endSurvived = map.get(oldEnd - 1);
+    if (startSurvived === oldStart && endSurvived === oldEnd - 1) {
+        return { kind: 'kept', line: startSurvived, endLine: endSurvived + 1 };
+    }
+    return {
+        kind: 'shifted',
+        line: minNew,
+        endLine: maxNew + 1,
+    };
+}

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

@@ -0,0 +1,43 @@
+import { type CommentAuthority } from './comments-client.js';
+export declare class ReviewTerminalError extends Error {
+    readonly state: 'approved' | 'canceled';
+    readonly resultPath?: string;
+    readonly reason?: string;
+    constructor(state: 'approved', resultPath: string);
+    constructor(state: 'canceled', reason?: string);
+}
+export interface ResolvedReview {
+    reviewId: string;
+    companionNodeId: string;
+    file: string;
+    cwd: string;
+}
+export interface ReviewClient {
+    byId(reviewId: string): Promise<ResolvedReview>;
+    /** Exactly one of a file path or a document ref. */
+    createInline(p: {
+        originNodeId: string;
+    } & ({
+        file: string;
+    } | {
+        document: string;
+    })): Promise<ResolvedReview>;
+    comments(reviewId: string): CommentAuthority;
+    submit(reviewId: string): Promise<SubmitDisposition>;
+    cancel(reviewId: string, reason: string): Promise<void>;
+}
+/** An approval that landed, or one the daemon is holding for the companion. */
+export type SubmitDisposition = {
+    outcome: 'approved';
+    changed: boolean;
+    resultPath: string;
+} | {
+    outcome: 'awaiting_companion';
+};
+export interface ReviewClientOptions {
+    onTerminalConflict?: (notice: string) => void;
+}
+/** The terminal's complete daemon seam for review lifecycle and comment operations. */
+export declare function createReviewClient(opts?: ReviewClientOptions): ReviewClient;
+export declare function terminalRefusalNotice(error: ReviewTerminalError): string;
+export declare function terminalConflictNotice(error: unknown): string | undefined;