@wrongstack/tui 1.0.24 → 1.0.26

package/dist/app-action-type.d.ts

@@ -44,6 +44,24 @@ export type Action = {
     provider?: string | undefined;
     cwd?: string | undefined;
     sessionId?: string | undefined;
+    /**
+     * Tells the reducer the boot-time restored transcript source has been
+     * discarded (e.g. by `/clear`). When explicitly `null` (not just
+     * omitted), the reducer resets the resume-derived state slice to the
+     * fresh values `createInitialState` would have produced with no
+     * restored entries: `historyBudget = undefined`, `autoProceedHold = false`,
+     * and `nextId` re-seeded from the surviving banner only. Pass
+     * `undefined` to leave the resume slice intact (existing behavior for
+     * `session.rewound` / `project.switched`).
+     */
+    restoredMessages?: readonly unknown[] | null | undefined;
+    restoredToolCalls?: readonly unknown[] | null | undefined;
+    restoredEvents?: readonly unknown[] | null | undefined;
+    /**
+     * Keep the checkpoint list. A rewind clears the screen but the
+     * checkpoints up to its target still belong to this conversation.
+     */
+    keepCheckpoints?: boolean | undefined;
 } | {
     type: 'streamDelta';
     delta: string;
@@ -85,6 +103,31 @@ export type Action = {
 } | {
     type: 'inspectOverlayScroll';
     delta: number;
+}
+/** Open the transcript search bar, optionally with a prefilled query. */
+ | {
+    type: 'chatSearchOpen';
+    query?: string | undefined;
+    includeReasoning: boolean;
+} | {
+    type: 'chatSearchSetQuery';
+    query: string;
+    includeReasoning: boolean;
+}
+/** Move the selection: -1 = older match, +1 = newer match (wraps). */
+ | {
+    type: 'chatSearchStep';
+    delta: -1 | 1;
+    includeReasoning: boolean;
+} | {
+    type: 'chatSearchClose';
+}
+/** Alt+↑ / Alt+↓: jump to the previous / next user message. */
+ | {
+    type: 'messageJump';
+    direction: -1 | 1;
+} | {
+    type: 'messageJumpClear';
 } | {
     type: 'brainStatus';
     state: State['brain']['state'];
@@ -1101,10 +1144,20 @@ export type Action = {
 } | {
     type: 'checkpointReceived';
     cp: State['checkpoints'][0];
-} | {
+}
+/** `selected` preselects a row (a message picked with Alt+↑); default the newest. */
+ | {
     type: 'rewindOverlayOpen';
+    selected?: number | undefined;
 } | {
     type: 'rewindOverlayClose';
+}
+/** Fork the session at a checkpoint and switch to the fork. */
+ | {
+    type: 'checkpointFork';
+    promptIndex: number;
+} | {
+    type: 'forkRequestDone';
 } | {
     type: 'rewindOverlayMove';
     delta: number;

package/dist/app-panel-state.d.ts

@@ -34,6 +34,24 @@ export type PanelState = {
         entryIds?: readonly number[] | undefined;
         scroll: number;
     } | null;
+    /**
+     * Transcript search bar (Alt+F / `/chat-search`). `selectedEntryId` is the
+     * current hit; `jumpSeq` increments whenever the view should scroll that
+     * hit into view. Null when the bar is closed.
+     */
+    chatSearch: {
+        query: string;
+        selectedEntryId: number | null;
+        jumpSeq: number;
+    } | null;
+    /**
+     * Alt+↑ / Alt+↓ user-message navigation: the user entry last jumped to, and
+     * a counter that bumps on every jump so the view scrolls it into view.
+     */
+    messageJump: {
+        entryId: number | null;
+        seq: number;
+    };
     picker: {
         open: boolean;
         query: string;
@@ -522,6 +540,13 @@ export type PanelState = {
         sessionId: string;
         sessionName: string;
     } | null;
+    /**
+     * A fork from the checkpoint timeline, waiting for the resume machinery
+     * (use-app-picker-keys) to branch the session there and switch to it.
+     */
+    forkRequest?: {
+        promptIndex: number;
+    } | null | undefined;
     /** Checkpoint timeline overlay — null when closed. */
     rewindOverlay: {
         checkpoints: Array<{

package/dist/app-props.d.ts

@@ -54,6 +54,12 @@ export interface AppProps {
     banner?: boolean | undefined;
     /** Persists the queue across crashes; rehydrated on mount, written on every mutation. */
     queueStore?: QueueStore | undefined;
+    /**
+     * The queue store of another session. With it, `/resume` brings that
+     * session's queue along (the WebUI keeps its queue in the same file) and
+     * leaves the previous session's on disk.
+     */
+    queueStoreFor?: ((sessionId: string) => QueueStore | undefined) | undefined;
     /**
      * Mirrors the queue's display texts (head first) to the host on every
      * queue change, so a running agent can be told what's waiting (queue
@@ -390,6 +396,12 @@ export interface AppProps {
      *  `(update available)` next to the version chip when this is set, so
      *  users notice without having to read the stderr notice. */
     updateAvailable?: boolean | undefined;
+    /**
+     * The standalone executable's background update: called with the version
+     * once it is downloaded, verified and waiting to be swapped in when this
+     * session exits. The status bar's version chip then says so.
+     */
+    subscribeUpdateReady?: ((listener: (version: string) => void) => () => void) | undefined;
     /**
      * Snapshot the keyed providers (and their model lists) for the
      * `/model` picker. Called every time the picker opens, so the result
@@ -501,6 +513,14 @@ export interface AppProps {
      * optionally by the startup rehydration path.
      */
     listSessions?: ((limit?: number) => Promise<ResumeSessionEntry[]>) | undefined;
+    /**
+     * Branch a session at a checkpoint (the conversation before that prompt)
+     * into a new session, leaving the original as it is. Returns the new id;
+     * the TUI then resumes it. The working tree is shared, not copied.
+     */
+    forkSession?: ((sessionId: string, checkpointPromptIndex: number) => Promise<{
+        id: string;
+    }>) | undefined;
     /**
      * Goal text passed from `--goal "..."` on the command line. When set,
      * the App mounts, renders the banner, then automatically dispatches

package/dist/app-reducer.d.ts

@@ -1,7 +1,7 @@
 import type { Action } from './app-action-type.js';
 import type { State } from './app-state.js';
-export type { DraftEntry, FleetEntry, GoalSummary, QueueItem, ResumeSessionEntry, Settings, SlashCommandMatch, State, } from './app-state.js';
 export type { Action } from './app-action-type.js';
+export type { DraftEntry, FleetEntry, GoalSummary, QueueItem, ResumeSessionEntry, Settings, SlashCommandMatch, State, } from './app-state.js';
 export { firstSelectable, pruneToolInput, skipDivider } from './reducers/helpers.js';
 export declare function reducer(state: State, action: Action): State;
 //# sourceMappingURL=app-reducer.d.ts.map

package/dist/app-state-core-types.d.ts

@@ -38,6 +38,19 @@ export interface ResumeSessionEntry {
     toolCallCount: number;
     toolErrorCount: number;
     outcome?: 'completed' | 'error' | 'timeout' | 'aborted' | undefined;
+    /** Parent session id when this session is a fork; the picker nests it. */
+    forkedFrom?: string | undefined;
+    /**
+     * Set when the session belongs to another git worktree of this repository
+     * (its own project directory). Choosing it switches to that worktree first.
+     */
+    worktree?: {
+        root: string;
+        name: string;
+        branch?: string | undefined;
+    } | undefined;
+    /** Tree connector (`├─ `, `└─ `) the picker draws; set when the picker opens. */
+    treePrefix?: string | undefined;
     /** The current session — marked so the picker can disallow resuming into itself. */
     isCurrent?: boolean | undefined;
     /**

package/dist/app-view-contract.d.ts

@@ -70,7 +70,7 @@ interface AppViewRuntime {
     liveStatuslineMode: StatuslineMode;
     projectName: string | undefined;
     workingDirChip: string | undefined;
-    handleRewindTo: (checkpointIndex: number) => Promise<void>;
+    handleRewindTo: (checkpointIndex: number) => Promise<import('./hooks/use-session-rewind.js').RewindOutcome>;
     activeCtrlRef: MutableRefObject<AbortController | null>;
     clearPendingConfirms: () => void;
     liveDirector: () => Director | null;

package/dist/background-strip-model.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The background strip above the composer: every running subagent and every
+ * background shell, as one row of chips. Alt+B focuses it; ←/→ pick a chip,
+ * Enter shows or hides the last lines of its output, `x` stops a shell (after
+ * a `y`), Esc leaves.
+ *
+ * This file is the pure part (items, layout, peek lines) and the strip's own
+ * little store. The store lives outside the app reducer on purpose: the strip
+ * state is view-only and short-lived, and the key route and the component are
+ * its only readers.
+ */
+import type { FleetEntry } from './app-state-fleet.js';
+export interface BackgroundItem {
+    /** `agent:<id>` or `shell:<pid>`. */
+    id: string;
+    kind: 'agent' | 'shell';
+    label: string;
+    startedAt: number;
+    agentId?: string | undefined;
+    pid?: number | undefined;
+    logFile?: string | undefined;
+}
+export interface BackgroundProcessLike {
+    pid: number;
+    command: string;
+    startedAt: number;
+    background: boolean;
+    killed: boolean;
+    logFile?: string | undefined;
+}
+/** Running subagents (oldest first), then background shells (oldest first). */
+export declare function buildBackgroundItems(fleet: Readonly<Record<string, FleetEntry>>, processes: readonly BackgroundProcessLike[]): BackgroundItem[];
+/** `12s`, `3m`, `1h4m`. */
+export declare function formatElapsed(ms: number): string;
+export interface StripChip {
+    item: BackgroundItem;
+    text: string;
+    selected: boolean;
+}
+/**
+ * The chips that fit in `width` columns (after the `prefix` and before the
+ * `suffix`), always including the selected one; `hidden` counts the rest.
+ */
+export declare function layoutStripChips(items: readonly BackgroundItem[], selected: number, width: number, now: number, spinner: string): {
+    chips: StripChip[];
+    hidden: number;
+};
+/** What a subagent is doing, newest last. */
+export declare function agentPeekLines(entry: FleetEntry | undefined, max: number): string[];
+export interface BackgroundStripState {
+    focused: boolean;
+    /** By id, so a chip that appears before it does not move the selection. */
+    selectedId: string | undefined;
+    peek: boolean;
+    confirmStop: boolean;
+    items: readonly BackgroundItem[];
+}
+export declare function getBackgroundStrip(): BackgroundStripState;
+export declare function updateBackgroundStrip(patch: Partial<BackgroundStripState>): void;
+/** Position of the selected chip (0 when nothing is selected). */
+export declare function selectedIndex(state: BackgroundStripState): number;
+/** Same ids in the same order: the strip keeps its item list (and render). */
+export declare function sameItems(a: readonly BackgroundItem[], b: readonly BackgroundItem[]): boolean;
+export declare function useBackgroundStrip(): BackgroundStripState;
+//# sourceMappingURL=background-strip-model.d.ts.map

package/dist/brain-panel-model.d.ts

@@ -93,7 +93,8 @@ export interface BrainPanelSettings {
     /** Effective heuristic toggles (defaults already filled in by the host). */
     heuristics: BrainPanelHeuristics;
     /** Single-LLM tier quality gate. */
-    llmMaxTokens: number;
+    /** undefined = the model's own output ceiling. */
+    llmMaxTokens?: number | undefined;
     llmRejectUncertain: boolean;
     llmMinConfidence: number;
     llmDenyIsTerminal: BrainDenyIsTerminal;
@@ -163,7 +164,7 @@ export interface BrainPanelHost {
      * positive integer"), so there is no "clear back to default" step here —
      * the preset ladders are number-only.
      */
-    setLlmMaxTokens(tokens: number): Promise<string | null>;
+    setLlmMaxTokens(tokens: number | undefined): Promise<string | null>;
     setLlmRejectUncertain(on: boolean): Promise<string | null>;
     setLlmMinConfidence(value: number): Promise<string | null>;
     setLlmDenyIsTerminal(mode: BrainDenyIsTerminal): Promise<string | null>;
@@ -277,7 +278,7 @@ export declare const AUTO_DENY_PRESETS: ReadonlyArray<number | undefined>;
  * fields, so there is no `undefined` ("back to default") rung — the default
  * value itself is the first rung.
  */
-export declare const LLM_MAX_TOKENS_PRESETS: readonly number[];
+export declare const LLM_MAX_TOKENS_PRESETS: ReadonlyArray<number | undefined>;
 export declare const LLM_MIN_CONFIDENCE_PRESETS: readonly number[];
 export declare const CACHE_TTL_PRESETS: readonly number[];
 export declare const CACHE_MAX_ENTRIES_PRESETS: readonly number[];
@@ -291,10 +292,9 @@ export declare const COUNCIL_TIMEOUT_PRESETS: ReadonlyArray<number | undefined>;
 export declare const COUNCIL_CONCURRENCY_PRESETS: ReadonlyArray<number | undefined>;
 export declare const COUNCIL_JUDGE_MAX_TOKENS_PRESETS: ReadonlyArray<number | undefined>;
 /**
- * Per-seat output budget rungs. The default is 2000 (see
- * `BRAIN_COUNCIL_DEFAULT_VOTER_MAX_TOKENS` in core) — reasoning models spend
- * their thinking tokens from this budget, so the rungs skew higher than the
- * judge ladder.
+ * Per-seat output budget rungs. The default (unset) is the model's own output
+ * ceiling — reasoning models spend their thinking tokens from this budget, so
+ * the rungs skew higher than the judge ladder.
  */
 /**
  * Deliberation round presets. Deliberately short: every step is another

package/dist/chat-search-slash.d.ts

@@ -0,0 +1,15 @@
+import type { SlashCommand } from '@wrongstack/core/types';
+import type { Action } from './app-action-type.js';
+interface ChatSearchSlashDeps {
+    dispatch: (action: Action) => void;
+    /** Thinking cards are only searchable while model reasoning is shown. */
+    includeReasoning: () => boolean;
+}
+/**
+ * TUI `/chat-search [text]` — opens the transcript search bar (same as
+ * Alt+F), optionally prefilled. Searches the history retained in this TUI;
+ * entries evicted by history retention are not searched.
+ */
+export declare function createChatSearchSlashCommand(deps: ChatSearchSlashDeps): SlashCommand;
+export {};
+//# sourceMappingURL=chat-search-slash.d.ts.map

package/dist/clipboard.d.ts

@@ -1,2 +1,15 @@
-export { readClipboardImage, readClipboardText, writeClipboardText, type ClipboardImage, } from '@wrongstack/runtime/clipboard';
+export { type ClipboardImage, readClipboardImage, readClipboardText, } from '@wrongstack/runtime/clipboard';
+interface ClipboardWriteDeps {
+    native: (text: string) => Promise<boolean>;
+    stdout: Pick<NodeJS.WriteStream, 'write' | 'isTTY'>;
+}
+/**
+ * Copy text for the TUI's copy actions. The OS clipboard tool first; when there
+ * is none that works — an SSH session, a headless Linux box without
+ * wl-copy/xclip — the terminal is asked to copy it with OSC 52, which reaches
+ * the clipboard of the machine the user is actually sitting at. (Inside tmux
+ * that needs `set -g set-clipboard on`.) OSC 52 has no acknowledgement, so a
+ * sent sequence counts as copied.
+ */
+export declare function writeClipboardText(text: string, deps?: ClipboardWriteDeps): Promise<boolean>;
 //# sourceMappingURL=clipboard.d.ts.map

package/dist/components/background-strip.d.ts

@@ -0,0 +1,20 @@
+import type React from 'react';
+import type { FleetEntry } from '../app-state-fleet.js';
+/** Output lines shown under the strip while a chip is open. */
+export declare const BACKGROUND_STRIP_PEEK_ROWS = 6;
+/** Rows the strip takes: none while nothing runs in the background. */
+export declare function backgroundStripRows(state: {
+    items: readonly unknown[];
+    focused: boolean;
+    peek: boolean;
+}): number;
+/**
+ * Running subagents and background shells, one chip each, right above the
+ * composer. Hidden while nothing runs in the background. Alt+B focuses it
+ * (see key-route-background-strip.ts).
+ */
+export declare function BackgroundStrip({ fleet, width, }: {
+    fleet: Readonly<Record<string, FleetEntry>>;
+    width: number;
+}): React.ReactElement | null;
+//# sourceMappingURL=background-strip.d.ts.map

package/dist/components/chat-search-bar.d.ts

@@ -0,0 +1,19 @@
+import type React from 'react';
+import type { State } from '../app-state.js';
+import type { HistoryEntry } from '../history-entry.js';
+/** Rows the bar always occupies, so the history viewport never jumps. */
+export declare const CHAT_SEARCH_BAR_ROWS = 2;
+interface ChatSearchBarProps {
+    search: NonNullable<State['chatSearch']>;
+    entries: readonly HistoryEntry[];
+    includeReasoning: boolean;
+    width: number;
+}
+/**
+ * Transcript search bar shown above the composer while Alt+F search is open.
+ * Row 1: query, match position and key hints. Row 2: the selected match's
+ * line with the hit highlighted (or guidance when there is nothing to show).
+ */
+export declare const ChatSearchBar: React.MemoExoticComponent<({ search, entries, includeReasoning, width, }: ChatSearchBarProps) => React.ReactElement>;
+export {};
+//# sourceMappingURL=chat-search-bar.d.ts.map

package/dist/components/checkpoint-timeline.d.ts

@@ -9,11 +9,15 @@ export interface CheckpointTimelineProps {
     selected: number;
     onSelect: (index: number) => void;
     onConfirm: (index: number) => void | Promise<void>;
+    /** Branch a new session at the checkpoint; absent when the host cannot fork. */
+    onFork?: ((index: number) => void) | undefined;
     onClose: () => void;
 }
 /**
  * Full-screen checkpoint timeline overlay for the /rewind command.
- * Arrow keys to navigate, Enter to rewind to selected, Esc to close.
+ * Arrow keys to navigate, Enter to rewind to selected, `f` to fork a new
+ * session there, Esc to close. Both take the selected prompt and everything
+ * after it back, and put the prompt back in the composer.
  */
-export declare function CheckpointTimeline({ checkpoints, selected, onSelect, onConfirm, onClose, }: CheckpointTimelineProps): React.ReactElement;
+export declare function CheckpointTimeline({ checkpoints, selected, onSelect, onConfirm, onFork, onClose, }: CheckpointTimelineProps): React.ReactElement;
 //# sourceMappingURL=checkpoint-timeline.d.ts.map

package/dist/components/history/code-block.d.ts

@@ -1,96 +1,14 @@
-import { type DiffLineRow, type DiffPreview } from '@wrongstack/tools/tool-diff';
+import type { DiffLineRow, DiffPreview } from '@wrongstack/tools/tool-diff';
 import type React from 'react';
 import { type Lang, type Token } from '../../highlight.js';
 export type { DiffLineKind, DiffLineRow, DiffPreview } from '@wrongstack/tools/tool-diff';
-/**
- * A parsed diff paired with the file it belongs to. Used when a tool
- * produces diffs for several files at once (currently `replace`); each
- * `DiffFilePreview` renders as one labeled `DiffFileBlock`.
- */
-export interface DiffFilePreview {
-    path: string;
-    preview: DiffPreview;
-}
-interface OmittedDiffSummary {
-    fileCount: number;
-    added: number;
-    removed: number;
-}
-/** Renderable file previews plus aggregate data for files omitted by the cap. */
-export type DiffFilePreviews = DiffFilePreview[] & {
-    omitted?: OmittedDiffSummary | undefined;
-};
-/**
- * Hard ceiling for one file's rendered diff preview. Diff rows are React/Ink
- * elements and therefore retained by the active virtual-history window; an
- * unbounded preview lets a single generated-file edit defeat virtualization.
- * Totals for the whole diff remain available through `added`/`removed`, while
- * the footer reports the hidden portion.
- */
-export declare const DIFF_MAX_LINES = 200;
-/** Maximum number of per-file diff blocks retained for one tool entry. */
-export declare const MULTI_DIFF_MAX_FILES = 20;
-/** Maximum rendered diff rows retained across every file in one tool entry. */
-export declare const MULTI_DIFF_MAX_ROWS = 400;
+export * from './diff-model.js';
 /** Syntax-highlighted, framed code block. */
 declare function CodeBlockImpl({ code, lang, contentWidth, }: {
     code: string;
     lang: Lang;
     contentWidth: number;
 }): React.ReactElement;
-/**
- * Minimum number of files before a summary footer is rendered above the
- * per-file blocks. Below this threshold each file's own `… +N -M hidden`
- * footer carries enough signal; above it, a single aggregate line keeps
- * the screen from being drowned in per-file tail lines.
- *
- * This is the default when no user-tunable value is supplied. The
- * settings picker exposes `MULTI_DIFF_SUMMARY_THRESHOLD_PRESETS` so
- * users can raise the cutoff (e.g. for very wide terminals) or lower
- * it (e.g. for tiny scrollback), or set it to 0 to suppress the
- * summary entirely.
- */
-export declare const MULTI_DIFF_SUMMARY_THRESHOLD = 5;
-/**
- * Aggregate stats across a list of per-file diffs — used to print a
- * single summary line at the top of a multi-file diff view when there
- * are enough files to make the rollup useful.
- */
-export interface MultiDiffSummary {
-    fileCount: number;
-    added: number;
-    removed: number;
-    hiddenAdded: number;
-    hiddenRemoved: number;
-    /** Number of rendered files whose preview was truncated (has hidden rows).
-     *  Does not include files omitted entirely by the multi-file render ceiling;
-     *  those are tracked separately via {@link omittedFiles}. */
-    truncatedFiles: number;
-    /** Files omitted entirely by the multi-file render ceiling. Guaranteed non-negative. */
-    omittedFiles: number;
-}
-/**
- * Sum the totals of a list of per-file diff previews. Files that were
- * parsed but have no rows (e.g. entirely empty after the no-op skip) are
- * excluded from the rollup so the summary reflects what the user will
- * actually see rendered below.
- */
-export declare function summarizeMultiFileDiffs(items: DiffFilePreviews): MultiDiffSummary;
-/**
- * Format a multi-file diff summary as a single dim italic line, suitable
- * for rendering above the per-file blocks. Mirrors the per-file footer's
- * `… +N -M hidden` shape so a reader who has seen the footer recognises
- * the format. Returns `null` when there's nothing useful to surface
- * (no files, or below the user's threshold where the per-file footer
- * already covers the rollup).
- *
- * @param threshold User-tunable cutoff. Pass `MULTI_DIFF_SUMMARY_THRESHOLD`
- *   for the default behaviour, `0` to suppress the summary entirely
- *   (always returns null), or a positive number to set a custom cutoff.
- *   A negative value is treated as "use default" so callers can pass an
- *   `undefined`-coerced settings value without a separate branch.
- */
-export declare function formatMultiDiffSummary(summary: MultiDiffSummary, threshold?: number): string | null;
 /**
  * One labeled diff — used to render a per-file block inside multi-file
  * diff views (e.g. when `replace` modifies several files). The path label
@@ -105,12 +23,6 @@ export declare function DiffFileBlock({ path, preview, useColor, contentWidth, }
     /** Pass-through to {@link DiffBlock}. See that component for details. */
     contentWidth?: number | undefined;
 }): React.ReactElement;
-/**
- * Human-readable change-size line for a diff — `Added N lines, removed M
- * lines` (Claude Code phrasing). Omits the zero side; returns `null` when
- * nothing changed so callers can skip the line entirely.
- */
-export declare function formatDiffStats(added: number, removed: number): string | null;
 /**
  * Return the token list to render on a diff wash (`diffAddBg` /
  * `diffDelBg`). When `onWash` is false the input is returned unchanged —
@@ -176,52 +88,6 @@ export declare function DiffBlock({ rows, hidden, added, removed, hiddenAdded, h
      */
     contentWidth?: number | undefined;
 }): React.ReactElement;
-/**
- * Parse a unified-diff string into a {@link DiffPreview}. Thin wrapper over the
- * shared, single-source-of-truth `parseUnifiedDiffPreview` in
- * @wrongstack/tools/tool-diff (which the WebUI and HQ also read). Kept as a
- * local export so this module's many callers and tests are unchanged.
- */
-export declare function parseUnifiedDiff(diff: string, maxLines: number): DiffPreview;
-/**
- * Pull a unified-diff string out of a tool's JSON output, then turn it
- * into a small, structured preview suitable for colour-coded rendering.
- */
-export declare function extractDiffPreview(toolName: string, output: string | undefined, input?: unknown | undefined): DiffPreview | undefined;
-/**
- * Pull one diff preview per file from a `replace` tool result. Each entry
- * has a `path` (best-effort: `results[i].path`, falling back to the input
- * argument when every result is for the same file) and a `preview` ready
- * for `DiffFileBlock` / `DiffBlock` rendering.
- *
- * Returns `undefined` when no per-file diff is recoverable (e.g. an empty
- * `results` array, no diff fields, or the result isn't a JSON object).
- *
- * Note: For a single entry point that handles `replace`, `diff`, and
- * `patch` (the three tools whose output can span multiple files), use
- * {@link extractMultiFileDiffs} instead — this function is kept for the
- * narrower replace-specific test cases.
- */
-export declare function extractReplaceDiffs(toolName: string, output: string | undefined, input?: unknown | undefined): DiffFilePreviews | undefined;
-/**
- * Pull a list of per-file diffs from a tool result that may span multiple
- * files. Handles:
- *
- * - `replace`: JSON `{ results: [{ path, diff }, …] }` (path per result,
- *   fallback to the input path when the result omits one).
- * - `diff`: JSON `{ diff: string }` where `diff` is a git-style multi-file
- *   unified diff (split on `diff --git` headers).
- * - `patch`: either JSON `{ diff: string, files: string[] }` or a raw
- *   unified-diff string (split on `diff --git` headers, falling back to
- *   `--- a/<path>` if no `diff --git` is present).
- *
- * Returns `undefined` when the tool isn't multi-file capable, the output
- * is missing/unparseable, or no per-file diff is recoverable. Returns an
- * empty array (not undefined) when the output parses but every entry has
- * an empty diff after trimming — the caller treats both as "nothing to
- * render" but the distinction is useful in tests.
- */
-export declare function extractMultiFileDiffs(toolName: string, output: string | undefined, input?: unknown | undefined): DiffFilePreviews | undefined;
 /**
  * Syntax-highlighted code / diff block.
  *