dsh-ssh-tui 0.5.9 → 0.6.0

package/lib/types/attach.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The launcher's attach/reconnect state machine, kept out of the bundle entry
+ * so it can be driven with fakes.
+ *
+ * This is the code that decides whether a launcher keeps fighting for a
+ * session's display. It used to answer a bare `close` from the Host with a
+ * retry — and since the Host answers a *replacement* by closing the previous
+ * relay, two SSH windows kicked each other off the display in a loop: every
+ * lap repainted the whole screen, every lap left the TTY cooked long enough to
+ * echo the DSR replies still in flight as `^[[17;1R`, and neither window could
+ * be typed into. `replaced` is now an exit, and the burst breaker below stops
+ * any leftover launcher from an older release that would ignore it.
+ */
+/** Why one relay session ended. */
+export type RelayReason = 'goodbye' | 'host-closed' | 'signal' | 'replaced';
+/** A relay that dies this soon after connecting reached a Host that was leaving. */
+export declare const ATTACH_RECOVERY_WINDOW_MS = 5000;
+/** How long to let a mid-dispose Host finish before starting a fresh one. */
+export declare const ATTACH_RECOVERY_WAIT_MS = 3000;
+/** Automatic re-attaches allowed inside this window before we stop trying. */
+export declare const RECOVERY_BURST_WINDOW_MS = 10000;
+export declare const RECOVERY_BURST_LIMIT = 3;
+/** How long to wait for a freshly spawned Host to accept on its channel. */
+export declare const HOST_START_TIMEOUT_MS = 15000;
+/** True when a relay error means the peer vanished rather than a real fault. */
+export declare function attachPeerVanished(error: unknown, elapsedMs: number): boolean;
+export interface LiveHost {
+    kind: 'attachable' | 'zombie';
+    sock: string;
+    pid: number;
+    exitWatch?: {
+        dispose(): void;
+        exited: Promise<number | null>;
+    };
+}
+export interface SpawnedDisplayHost {
+    sock: string;
+    pid: number;
+    errFile?: string;
+    exitWatch: {
+        dispose(): void;
+        exited: Promise<number | null>;
+    };
+}
+/** Everything the state machine touches; the bundle entry supplies the real ones. */
+export interface AttacherDeps {
+    /**
+     * Run one relay; `seed` is typing captured while no display existed, and
+     * `announce` asks it to erase the status line before the first paint.
+     */
+    relay(sock: string, seed: string, announce: boolean): Promise<{
+        reason: RelayReason;
+    }>;
+    /** Keep the TTY in raw mode and drop what is queued (stale replies, keys). */
+    quiet(): void;
+    /**
+     * Start keeping what the user types. A fresh Host takes a moment to boot,
+     * and the old code left stdin flowing with nobody listening, so everything
+     * typed in that window was silently dropped.
+     */
+    beginCapture?(): void;
+    /** Stop capturing and return the typing ('' when unsupported). */
+    endCapture?(): string;
+    inspectLiveHost(sessionId: string): Promise<LiveHost | undefined>;
+    spawnHost(sessionId: string): SpawnedDisplayHost;
+    waitForDisplaySock(spawned: SpawnedDisplayHost): Promise<void>;
+    /**
+     * One already-formatted status line for stderr. `transient` marks a line the
+     * relay will erase before the first paint (see `DisplayRelayOptions.announce`).
+     */
+    report(message: string, transient?: boolean): void;
+    exit(code: number): void;
+    /** `t(...)` for the two state machine messages. */
+    messages: {
+        connecting(sessionId: string): string;
+        recovering(sessionId: string): string;
+        replaced(sessionId: string): string;
+        flapping(sessionId: string): string;
+        zombie(sessionId: string, pid: number): string;
+    };
+    locksDisabled?(): boolean;
+    now?(): number;
+    debug?: boolean;
+    /** Override the burst breaker window/limit (tests). */
+    burst?: {
+        windowMs?: number;
+        limit?: number;
+    };
+}
+export interface Attacher {
+    /**
+     * Attach to one Host channel. `announce` writes the "attaching" status line
+     * for a user waiting on their own terminal; it is off for automatic retries
+     * and takeovers, whose terminal may be a dead link that would later flush
+     * whatever was written into it.
+     */
+    attachExisting(sessionId: string, sock: string, recover?: boolean, options?: {
+        announce?: boolean;
+        seed?: string;
+    }): Promise<void>;
+    /** Attach to a live Host on this session, or spawn a fresh one and attach. */
+    attachOrSpawn(sessionId: string, recover?: boolean): Promise<void>;
+    /** Recoveries recorded in the current burst window (tests). */
+    readonly recoveries: number;
+}
+export declare function createAttacher(deps: AttacherDeps): Attacher;

package/lib/types/commands.d.ts

@@ -0,0 +1,103 @@
+/** This plugin's own commands, in suggestion order. */
+export declare const LOCAL_COMMANDS: readonly [{
+    readonly name: "help";
+    readonly key: "cmd.help";
+}, {
+    readonly name: "model";
+    readonly key: "cmd.model";
+}, {
+    readonly name: "effort";
+    readonly key: "cmd.effort";
+}, {
+    readonly name: "provider";
+    readonly key: "cmd.provider";
+}, {
+    readonly name: "submodel";
+    readonly key: "cmd.submodel";
+}, {
+    readonly name: "subeffort";
+    readonly key: "cmd.subeffort";
+}, {
+    readonly name: "mode";
+    readonly key: "cmd.mode";
+}, {
+    readonly name: "quit";
+    readonly key: "cmd.quit";
+}, {
+    readonly name: "exit";
+    readonly key: "cmd.quit";
+    readonly aliasOf: "quit";
+}, {
+    readonly name: "clear";
+    readonly key: "cmd.clear";
+}, {
+    readonly name: "status";
+    readonly key: "cmd.status";
+}, {
+    readonly name: "diag";
+    readonly key: "cmd.diag";
+}, {
+    readonly name: "disconnect";
+    readonly key: "cmd.disconnect";
+}, {
+    readonly name: "approval";
+    readonly key: "cmd.approval";
+}, {
+    readonly name: "view";
+    readonly key: "cmd.view";
+}, {
+    readonly name: "usage";
+    readonly key: "cmd.usage";
+}, {
+    readonly name: "balance";
+    readonly key: "cmd.usage";
+    readonly aliasOf: "usage";
+}, {
+    readonly name: "quota";
+    readonly key: "cmd.usage";
+    readonly aliasOf: "usage";
+}, {
+    readonly name: "subagents";
+    readonly key: "cmd.subagents";
+}, {
+    readonly name: "resume";
+    readonly key: "cmd.resume";
+}, {
+    readonly name: "setup";
+    readonly key: "cmd.setup";
+}, {
+    readonly name: "find";
+    readonly key: "cmd.find";
+}, {
+    readonly name: "copy";
+    readonly key: "cmd.copy";
+}, {
+    readonly name: "language";
+    readonly key: "cmd.language";
+}, {
+    readonly name: "lang";
+    readonly key: "cmd.language";
+    readonly aliasOf: "language";
+}, {
+    readonly name: "dialog-test";
+    readonly key: "cmd.dialog-test";
+}];
+export interface LocalizedCommand {
+    name: string;
+    description: string;
+    aliasOf?: string;
+}
+export interface CommandSuggestion {
+    name: string;
+    description: string;
+    local: boolean;
+}
+export declare function commandDescription(name: string, aliasOf?: string): string;
+export declare function localizedCommands(): LocalizedCommand[];
+/**
+ * Suggestions for the current input: only a `/`-prefixed line suggests
+ * anything, aliases are held back until a prefix is typed, and the host's
+ * commands follow this plugin's (a local name wins the duplicate). A typed
+ * prefix ranks names that start with it above names that merely contain it.
+ */
+export declare function commandSuggestions(input: string, foreign: readonly CommandSuggestion[]): CommandSuggestion[];

package/lib/types/diag.d.ts

@@ -0,0 +1,78 @@
+/** How much of a Host stderr log the report carries. */
+export declare const DIAG_ERR_TAIL_BYTES = 2000;
+export interface DiagHostState {
+    /** 'none' — no lock file; 'live' — owner alive and channel reachable;
+     *  'zombie' — owner alive but the channel does not answer;
+     *  'stale' — lock exists but its owner is gone (stealable). */
+    kind: 'none' | 'live' | 'zombie' | 'stale';
+    pid?: number;
+    /** Lock state as written by the Host (`attached`/`paused`/`running-detached`). */
+    state?: string;
+    agentStatus?: string;
+    disconnectPolicy?: string;
+    tty?: string;
+    /** Owner identity check: 'verified', 'mismatch', or 'unverifiable'. */
+    identity?: 'verified' | 'mismatch' | 'unverifiable';
+    lockPath?: string;
+    path: string;
+}
+export interface DiagSnapshot {
+    pluginVersion: string;
+    hostVersion: string;
+    nodeVersion: string;
+    platform: string;
+    sessionId: string;
+    /** This process is the detached Host rather than the launcher. */
+    hostProcess: boolean;
+    locksDisabled: boolean;
+    dshHome: string;
+    sockPath: string;
+    /** `true` when a connect to the channel succeeded. */
+    sockReachable: boolean;
+    /** A socket *file* exists on disk (POSIX only; pipes are invisible to fs). */
+    sockFilePresent?: boolean;
+    host: DiagHostState;
+    link: {
+        kind: 'ssh' | 'local';
+        rttMs?: number;
+        probeState: 'measured' | 'unknown' | 'unprobed';
+        paintIntervalMs?: number;
+    };
+    lockHeldByThisProcess: boolean;
+    sessionLog?: {
+        format: string;
+        bytes: number;
+        modifiedAt?: number;
+        events?: number;
+        seq?: number;
+    };
+    /** Last lines the Host wrote to its stderr log, if any. */
+    errTail?: string;
+    /** Locks found under DSH_HOME for *other* sessions (context for "who holds it"). */
+    otherLocks: Array<{
+        sessionId: string;
+        pid: number;
+        state?: string;
+    }>;
+}
+/** Tail of a Host stderr log, or undefined when there is nothing to read. */
+export declare function readErrTail(sessionId: string, dshHome?: string): Promise<string | undefined>;
+/**
+ * Why `--resume` would behave the way it does, as an ordered chain of verdicts.
+ * The first entry is the actionable one; the rest is supporting context.
+ */
+export declare function diagVerdicts(snapshot: DiagSnapshot): string[];
+/** The whole report as transcript lines. Pure. */
+export declare function formatDiag(snapshot: DiagSnapshot): string[];
+/** Gather everything the report needs. Every probe is best-effort. */
+export declare function collectDiag(options: {
+    sessionId: string;
+    pluginVersion: string;
+    hostVersion: string;
+    hostProcess: boolean;
+    link: DiagSnapshot['link'];
+    paintIntervalMs?: number;
+    dshHome?: string;
+}): Promise<DiagSnapshot>;
+/** Directory holding the per-session index, for callers that report it. */
+export declare function diagIndexPath(dshHome?: string): string;

package/lib/types/dialogs.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Dialog state rules: the dialog shapes, and what one key does to a question
+ * list, a confirm prompt or the inspect overlay.
+ *
+ * `tui.ts` owns the rendering, the promise plumbing and the agent side; these
+ * functions decide cursor moves, selection, and whether Enter means "answer",
+ * "cancel" or "send the free-text box". Keeping them here makes the rules
+ * testable without a terminal.
+ */
+import type { AskUserQuestionItem } from '@deepseek-ai/dsh-user-questions';
+import type { DiffDisplayLine } from './tool-present.js';
+export interface ConfirmDialog {
+    kind: 'confirm';
+    prompt: string;
+    hint: string;
+    resolve(value: 'y' | 'n' | 'cancel'): void;
+}
+export interface QuestionDialog {
+    kind: 'questions';
+    question: AskUserQuestionItem;
+    index: number;
+    total: number;
+    selected: Set<number>;
+    cursor: number;
+    resolve(selection: {
+        selected: string[];
+        custom?: string;
+    }): void;
+    reject(error: unknown): void;
+}
+export interface OnboardingDialog {
+    kind: 'onboarding';
+}
+export interface InspectDialog {
+    kind: 'inspect';
+    title: string;
+    lines: DiffDisplayLine[];
+    offset: number;
+}
+export type Dialog = ConfirmDialog | QuestionDialog | OnboardingDialog | InspectDialog;
+export interface DialogAnswer {
+    selected: string[];
+    custom?: string;
+}
+/** Digits then letters: the hotkeys painted next to question options. */
+export declare const QUESTION_OPTION_KEYS = "123456789abcdefghijklmnopqrstuvwxyz";
+/** Options a dialog can answer with; only a question list has any. */
+export declare function optionsLength(dialog: Dialog): number;
+/**
+ * The option index a hotkey selects, or undefined when the key is not one of
+ * the painted keys or names no option.
+ */
+export declare function questionOptionIndex(key: string, optionCount: number): number | undefined;
+/** Move the question highlight, clamped to its options. Returns false if not a question dialog. */
+export declare function moveQuestionCursor(dialog: QuestionDialog, delta: number): boolean;
+/** Select option `index`: toggles in a multi-select list, replaces otherwise. */
+export declare function selectQuestionOption(dialog: QuestionDialog, index: number): void;
+/** Handle a hotkey: select its option and report whether it applied. */
+export declare function selectQuestionOptionByKey(dialog: QuestionDialog, key: string): boolean;
+export type QuestionSubmit = {
+    kind: 'resolve';
+    selected: string[];
+    custom?: string;
+} | {
+    kind: 'reject';
+} | {
+    kind: 'none';
+};
+/**
+ * What Enter means for a question dialog. A single-select list with nothing
+ * highlighted cancels (the user must not accidentally answer with the first
+ * option); a multi-select list may answer with an empty selection. With no
+ * options at all, the typed text is the answer.
+ */
+export declare function questionSubmit(dialog: QuestionDialog, input: string): QuestionSubmit;
+/** y/n/ctrl-c/esc answers for a confirm prompt. */
+export declare function confirmAnswer(text: string): 'y' | 'n' | 'cancel' | undefined;
+/** The inspect overlay closes on any of these, and ignores the rest. */
+export declare function inspectClosesOn(text: string): boolean;

package/lib/types/display-sock.d.ts

@@ -4,6 +4,7 @@ export declare const FRAME_RESIZE = 3;
 export declare const FRAME_HELLO = 4;
 export declare const FRAME_GOODBYE = 5;
 export declare const FRAME_RTT = 6;
+export declare const FRAME_REPLACED = 7;
 /**
  * Drop launcher SIGTERM/SIGINT/SIGHUP so closing SSH cannot dispose the tree
  * before hangup handling. Leaving the session with setsid() is best-effort:
@@ -78,11 +79,17 @@ export interface DisplayHostHandlers {
 export declare class DisplayHost {
     readonly path: string;
     private readonly handlers;
+    /** Test seam: how long a silent connection may wait for its HELLO. */
+    private readonly options;
     private server;
     private socket;
     private reader;
     attached: boolean;
-    constructor(path: string, handlers: DisplayHostHandlers);
+    constructor(path: string, handlers: DisplayHostHandlers, 
+    /** Test seam: how long a silent connection may wait for its HELLO. */
+    options?: {
+        helloGraceMs?: number;
+    });
     listen(): Promise<void>;
     private accept;
     sendStdout(bytes: Buffer | string): boolean;
@@ -119,15 +126,64 @@ export interface SpawnedHost {
     /** Exit watch so a Host that dies before listening is reported at once. */
     exitWatch: HostExitWatch;
 }
+/**
+ * Keep what the user types while no display exists yet.
+ *
+ * A fresh Host takes a moment to boot; the launcher used to leave stdin flowing
+ * with nobody listening, so every key pressed in that window was dropped. The
+ * capture strips cursor replies (it is the same stream the relay will probe)
+ * and hands the rest to the relay as its `seed`.
+ */
+export declare function captureTerminalInput(stdin?: NodeJS.ReadStream): {
+    stop(): string;
+};
+/**
+ * Keep the terminal quiet while the launcher retries or waits for a Host.
+ *
+ * Between attempts the TTY is back in cooked mode, so a DSR reply still in
+ * flight from the previous probe is echoed to the screen as `^[[17;1R`-style
+ * garbage. Raw mode plus a drain swallows those bytes instead: they are either
+ * stale replies or keys typed before any display existed, and neither should
+ * reach the shell.
+ */
+export declare function quietTerminalInput(stdin?: NodeJS.ReadStream): number;
+/**
+ * Hand the TTY back to the shell: cooked mode, echo back, input paused.
+ *
+ * `quietTerminalInput` deliberately leaves raw mode on while a relay is about
+ * to take the terminal, and the relay restores it on its way out — but every
+ * exit path then calls `quiet()` once more to drain a cursor reply still owed,
+ * which turns raw mode back on. Without this the shell comes back with no line
+ * discipline and no echo: the user cannot type, and the only recovery is
+ * dropping the SSH connection. Only local termios calls here — nothing is
+ * written into a link that may already be dead.
+ */
+export declare function restoreTerminalInput(stdin?: NodeJS.ReadStream): void;
 /** Spawn a detached Host copy of this `dsh` invocation and return its sock path. */
 export declare function spawnDetachedHost(sessionId: string): SpawnedHost;
 export declare function probeDisplaySock(path: string, timeoutMs?: number): Promise<boolean>;
 export interface RelayResult {
     /** Host sent goodbye — user exited from the attached session. */
-    reason: 'goodbye' | 'host-closed' | 'signal';
+    reason: 'goodbye' | 'host-closed' | 'signal' | 'replaced';
+}
+/** Terminal and signal sources; injectable so a test can drive the relay. */
+export interface DisplayRelayOptions {
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+    signals?: Pick<NodeJS.Process, 'on' | 'off' | 'removeListener'>;
+    /** Link kind for the RTT probe; defaults to this process's SSH env. */
+    ssh?: boolean;
+    /** Typing captured before this relay existed; sent to the Host after HELLO. */
+    seed?: string;
+    /**
+     * The waiting status line currently on screen, if the launcher announced one.
+     * It is erased here — after the measurement, before the Host's first paint —
+     * so the picker's screen does not sit frozen while the probe runs.
+     */
+    announce?: boolean;
 }
 /**
  * Turn this process into a Display relay until the Host hangs up or the
  * local TTY dies. Restores the terminal before resolving.
  */
-export declare function runDisplayRelay(path: string): Promise<RelayResult>;
+export declare function runDisplayRelay(path: string, options?: DisplayRelayOptions): Promise<RelayResult>;

package/lib/types/dsh-compat.d.ts

@@ -62,6 +62,13 @@ export interface SessionInspectionLike {
     events: readonly unknown[];
     meta?: SessionHeaderLike;
     header?: SessionHeaderLike;
+    /**
+     * Backend state for the slice. `detached` means the backend never
+     * materialized a physical artifact (the writer is in this process and has
+     * not flushed yet), so `events: []` says nothing about whether the session
+     * is blank. Callers must not delete artifacts on a `detached` read.
+     */
+    eventState?: string;
 }
 /**
  * 0.1.2 `list()` returns headers; 0.1.5 returns `{ header, revision, … }`

package/lib/types/i18n/index.d.ts

@@ -16,12 +16,16 @@ export declare const UI_LOCALE_SCHEMA: z<Schemastery.ObjectS<{
     view: z<string, string>;
     disconnect: z<string, string>;
     autoApproval: z<string, string>;
+    /** Milliseconds a leftover, finished Host waits before exiting; 0 = never. */
+    idleExit: z<number, number>;
 }>, Schemastery.ObjectT<{
     language: z<string, string>;
     skipUpdate: z<string, string>;
     view: z<string, string>;
     disconnect: z<string, string>;
     autoApproval: z<string, string>;
+    /** Milliseconds a leftover, finished Host waits before exiting; 0 = never. */
+    idleExit: z<number, number>;
 }>>;
 export declare function localeFromTag(tag: string): Locale | undefined;
 /** Pick zh/en from env, optionally after a saved settings value. */

package/lib/types/index.d.ts

@@ -5,13 +5,17 @@
  * subagents, sandbox approvals) is the same one the web surface uses.
  */
 import type { Context } from '@deepseek-ai/cordis';
-/** A relay that dies this soon after connecting reached a Host that was leaving. */
-export declare const ATTACH_RECOVERY_WINDOW_MS = 5000;
-/** True when a relay error means the peer vanished rather than a real fault. */
-export declare function attachPeerVanished(error: unknown, elapsedMs: number): boolean;
+export { ATTACH_RECOVERY_WINDOW_MS, attachPeerVanished } from './attach.js';
 export declare const name = "ssh-tui";
 /** Core services required before the terminal channel can drive an agent. */
 export declare const inject: string[];
+/**
+ * Grace allowed to the launcher's graceful `appExit` before the process is
+ * forced out. That shutdown only sets `process.exitCode`, and a lingering
+ * event-loop handle (the profile patch watcher) can keep the drain from ever
+ * finishing — with the user's shell still blocked on the foreground process.
+ */
+export declare const EXIT_FALLBACK_MS = 2000;
 /** Plugin config: the session identity and presentation defaults. */
 export interface Config {
     sessionId: string;

package/lib/types/paint.d.ts

@@ -4,7 +4,6 @@
  * Kept off `tui.ts` so the launch picker can dirty-paint without loading
  * the agent-backed SshTui class.
  */
-export declare const DSR_PROBE_TIMEOUT_MS = 800;
 /** Give a running turn this long to settle after cancel before we flush anyway. */
 export declare const HANGUP_CANCEL_TIMEOUT_MS = 10000;
 export type PaintLinkKind = 'local' | 'ssh';
@@ -20,7 +19,7 @@ export declare function resolvePaintIntervalMs(configured?: number, env?: NodeJS
     rttMs?: number;
 }): number;
 /** True when this process is attached to an SSH session (jump host / proxy). */
-export declare function detectSshSession(env?: NodeJS.ProcessEnv): boolean;
+export { detectSshSession } from './terminal-input.js';
 /** Node errno on a write/close that means the TTY is gone (SSH drop, HUP). */
 export declare function isHangupErrno(error: unknown): boolean;
 /**
@@ -85,8 +84,12 @@ export declare function findCursorPositionReply(text: string): {
  * Round-trip to the attached terminal via CSI 6n. Returns undefined when the
  * reply never arrives (dumb pipe, blocked DSR). Does not interpret the
  * coordinates — only the elapsed milliseconds matter.
+ *
+ * Sampling and plausibility live in `terminal-input.ts`: a single request used
+ * to accept a previous probe's answer (~2 ms) and to report a repaint queue as
+ * the link (~1900 ms on a 50 ms SSH line).
  */
-export declare function probeTerminalRttMs(stdin?: NodeJS.ReadStream, stdout?: NodeJS.WriteStream, timeoutMs?: number): Promise<number | undefined>;
+export declare function probeTerminalRttMs(stdin?: NodeJS.ReadStream, stdout?: NodeJS.WriteStream, timeoutMs?: number, ssh?: boolean): Promise<number | undefined>;
 /** Sliding window of `windowSize` items that keeps `cursor` visible. */
 export declare function pickerWindowStart(cursor: number, total: number, windowSize?: number): number;
 /** Immediate first-frame chrome so a 2–3s Host boot is not a blank TTY. */

package/lib/types/picker.d.ts

@@ -3,12 +3,14 @@
  * TUI mounts, so launching without an explicit session id lands on a choice
  * instead of a fresh main screen.
  *
- * The list itself is not capped. The visible page is always nine rows so
- * digits 1-9 map onto every on-screen item. Arrow keys move a highlight,
- * typing filters by title / id / cwd, and Enter confirms the focused row.
+ * Reading is lazy. The first page is inspected up front and only then painted,
+ * so nothing on screen is a raw id waiting to turn into a title; older sessions
+ * are read only when the user reaches for them — pressing past the last row, or
+ * filtering, which has to look deeper than the rows on screen. The visible page
+ * is always nine rows so digits 1-9 map onto every on-screen item.
  */
 import type { Context } from '@deepseek-ai/cordis';
-import { listResumableSessionsProgressive, type ResumableSession } from './session-list.js';
+import { openResumableSessionPager, type ResumableSession } from './session-list.js';
 /** What the launch picker decided. */
 export type SessionPickerResult = {
     kind: 'resume';
@@ -37,8 +39,10 @@ export interface SessionPickerState {
      * shortcuts. Set automatically by the first letter, or by `/` / Ctrl+F.
      */
     filterActive: boolean;
-    /** Older logs are still being inspected in the background. */
+    /** A page is being read right now (the first one, or a lazy load). */
     loading?: boolean;
+    /** Sessions in history that have not been read yet. */
+    more?: number;
 }
 /** One key / control action against {@link SessionPickerState}. */
 export type SessionPickerAction = {
@@ -96,6 +100,22 @@ export declare function clampPickerCursor(cursor: number, total: number): number
 export declare function pickerCapacity(rows: number): number;
 /** Whether two picker states would paint the same frame. */
 export declare function pickerStateUnchanged(previous: SessionPickerState, next: SessionPickerState): boolean;
+/**
+ * Whether this input asked for sessions the picker has not read yet.
+ *
+ * Older history is read lazily, so the trigger matters: while filtering, a page
+ * that leaves fewer matches than fit on screen is deepened (a search has to look
+ * past the rows on screen); otherwise the user has to press past the last loaded
+ * row — pressing Down at the end, PageDown, or End — before older sessions are
+ * read.
+ */
+export declare function pickerWantsMorePage(input: {
+    previous: Pick<SessionPickerState, 'sessions' | 'cursor' | 'query' | 'filterActive'>;
+    next: Pick<SessionPickerState, 'sessions' | 'cursor' | 'query' | 'filterActive'>;
+    actions: readonly SessionPickerAction[];
+    more: number;
+    windowSize?: number;
+}): boolean;
 /**
  * Apply one picker action. Pure: the TTY layer maps keystrokes onto this, and
  * tests drive it without stdin.
@@ -110,7 +130,7 @@ export declare function splitPickerInput(text: string): string[];
  * unit; ordinary text is applied character by character so a pasted "fix 2"
  * types the digit instead of treating it as a 1-9 shortcut.
  */
-export declare function feedPicker(state: SessionPickerState, text: string, windowSize?: number): SessionPickerStep;
+export declare function feedPicker(state: SessionPickerState, text: string, windowSize?: number, onAction?: (action: SessionPickerAction) => void): SessionPickerStep;
 /**
  * Show the picker and wait for a selection, a new-session request, or cancel.
  * Restores the terminal before resolving; an AbortSignal cancels as well.
@@ -123,6 +143,6 @@ export declare function feedPicker(state: SessionPickerState, text: string, wind
 export interface SessionPickerOptions {
     stdin?: NodeJS.ReadStream;
     stdout?: NodeJS.WriteStream;
-    listSessions?: typeof listResumableSessionsProgressive;
+    openPager?: typeof openResumableSessionPager;
 }
 export declare function showSessionPicker(ctx: Context, color: boolean, signal?: AbortSignal, options?: SessionPickerOptions): Promise<SessionPickerResult>;