@linxiraos/pi-tui 1.3.1 → 1.4.0

package/dist/types/overlays/resume-picker.d.ts

@@ -0,0 +1,293 @@
+/**
+ * Native (`picker`) mapping of the resume directory model.
+ *
+ * The coding-agent owns the data model (`ResumeDirectory` / `buildResumeView`:
+ * project → workspace → conversation). pi-tui cannot import it (dependency
+ * direction), so this module declares structurally compatible `*Like` types
+ * and accepts a {@link ResumeSourceLike} the host builds from its real
+ * directory and view builder (the ANSI tree passes the same object). Nothing
+ * here re-groups conversations: the rows come from the model, and this module
+ * only turns them into picker props.
+ */
+import type { TspPickerGroup, TspPickerItem, TspPickerScope } from "@linxiraos/pi-wire";
+import type { SessionSelectorStatus } from "./session-selector.js";
+import type { NativeChild } from "../native/node.js";
+export type ResumeScopeKindLike = "workspace" | "project" | "all";
+export interface ResumeScopeLike {
+    readonly kind: ResumeScopeKindLike;
+    readonly key?: string;
+    readonly projectKey?: string;
+    readonly workspaceKey?: string;
+}
+export type ResumeScopeInputLike = ResumeScopeKindLike | ResumeScopeLike;
+/** Parsed query, as far as the native renderer reads it (the ANSI tree passes a subset). */
+export interface ResumeQueryLike {
+    readonly raw: string;
+    readonly terms?: readonly string[];
+    readonly project?: readonly string[];
+    readonly workspace?: readonly string[];
+    readonly branch?: readonly string[];
+    readonly status?: readonly string[];
+    readonly current?: boolean | null;
+    readonly fork?: boolean | null;
+    readonly pinned?: boolean | null;
+}
+/** The session fields the picker reads; the host's `SessionInfo` supplies all of them. */
+export interface ResumeSessionLike {
+    readonly path: string;
+    readonly id: string;
+    readonly cwd: string;
+    readonly title?: string;
+    readonly modified: Date;
+    readonly size?: number;
+    readonly firstMessage?: string;
+    readonly allMessagesText?: string;
+    readonly status?: SessionSelectorStatus;
+    readonly parentSessionPath?: string;
+    readonly created?: Date;
+    readonly messageCount?: number;
+    readonly assistantTurns?: number;
+    /** Last model recorded in the session (`provider/modelId`), when one was persisted. */
+    readonly model?: string;
+}
+export interface ResumeConversationLike {
+    readonly session: ResumeSessionLike;
+    readonly key: string;
+    readonly id: string;
+    readonly path: string;
+    readonly title: string;
+    readonly cwd: string;
+    readonly projectKey: string;
+    readonly workspaceKey: string;
+    readonly created: Date;
+    readonly modified: Date;
+    readonly status?: SessionSelectorStatus;
+    readonly pinned: boolean;
+    readonly current: boolean;
+    readonly fork: boolean;
+    /** Subagent marker from `session_init.agent`; forks never set it. */
+    readonly isSubagent?: boolean;
+    readonly agentName?: string;
+    readonly parentKey?: string;
+    readonly subagents?: readonly ResumeConversationLike[];
+    readonly messageCount: number;
+}
+export interface ResumeWorkspaceLike {
+    readonly key: string;
+    readonly path: string;
+    readonly name: string;
+    readonly alias?: string | null;
+    readonly displayName?: string;
+    readonly projectKey: string;
+    readonly branch: string | null;
+    readonly isWorktree?: boolean;
+    readonly pinned: boolean;
+    readonly lastActivity: Date | null;
+    /** Flat conversation list; the core model keeps conversations on the directory only. */
+    readonly conversations?: readonly ResumeConversationLike[];
+    readonly counts: {
+        readonly conversations: number;
+        readonly pinnedConversations: number;
+    };
+}
+export interface ResumeProjectLike {
+    readonly key: string;
+    readonly root: string;
+    readonly name: string;
+    readonly alias: string | null;
+    readonly displayName: string;
+    readonly isDefault: boolean;
+    readonly pinned: boolean;
+    readonly removable?: boolean;
+    readonly collapsed: boolean;
+    readonly lastActivity: Date | null;
+    readonly workspaces?: readonly ResumeWorkspaceLike[];
+    readonly conversations?: readonly ResumeConversationLike[];
+    readonly counts: {
+        readonly conversations: number;
+        readonly workspaces: number;
+        readonly pinnedConversations: number;
+    };
+}
+export interface ResumeDirectoryLike {
+    readonly projects: readonly ResumeProjectLike[];
+    readonly workspaces: readonly ResumeWorkspaceLike[];
+    readonly conversations: readonly ResumeConversationLike[];
+    readonly defaultProjectKey: string;
+    readonly defaultWorkspaceKey: string;
+    readonly counts: {
+        readonly projects: number;
+        readonly workspaces: number;
+        readonly conversations: number;
+        readonly pinnedConversations: number;
+    };
+}
+export interface ResumeProjectRowLike {
+    readonly type: "project";
+    readonly key: string;
+    readonly project: ResumeProjectLike;
+    readonly depth?: 0;
+    readonly pinned: boolean;
+    readonly collapsed: boolean;
+    readonly conversationCount: number;
+    readonly totalConversationCount: number;
+    readonly workspaceCount: number;
+    readonly totalWorkspaceCount: number;
+}
+export interface ResumeWorkspaceRowLike {
+    readonly type: "workspace";
+    readonly key: string;
+    readonly workspace: ResumeWorkspaceLike;
+    readonly projectKey: string;
+    readonly depth?: 1;
+    readonly pinned: boolean;
+    readonly conversationCount: number;
+    readonly totalConversationCount: number;
+}
+export interface ResumeConversationRowLike {
+    readonly type: "conversation";
+    readonly key: string;
+    readonly conversation: ResumeConversationLike;
+    readonly projectKey: string;
+    readonly workspaceKey: string;
+    readonly depth?: number;
+    readonly pinned: boolean;
+    readonly current: boolean;
+    readonly score?: number;
+    readonly pinnedOnly?: boolean;
+}
+export type ResumeViewRowLike = ResumeProjectRowLike | ResumeWorkspaceRowLike | ResumeConversationRowLike;
+export interface ResumeViewCountsLike {
+    readonly conversations: number;
+    readonly workspaces?: number;
+    readonly projects?: number;
+    readonly pinnedConversations?: number;
+    readonly totalConversations: number;
+    readonly totalWorkspaces?: number;
+    readonly totalProjects?: number;
+}
+export interface ResumeViewLike {
+    readonly scope: ResumeScopeLike;
+    readonly query: ResumeQueryLike;
+    readonly rows: readonly ResumeViewRowLike[];
+    /** Conversation rows; the ANSI tree leaves it out and read `rows` instead. */
+    readonly conversations?: readonly ResumeConversationRowLike[];
+    readonly counts: ResumeViewCountsLike;
+    readonly referenceBranch?: string | null;
+    readonly currentWorkspaceKey?: string;
+}
+export interface ResumeViewOptionsLike {
+    scope?: ResumeScopeInputLike;
+    query?: string;
+    currentSessionPath?: string;
+}
+/** Names and per-scope conversation totals for the segmented control. */
+export interface ResumeScopeSummaryLike {
+    readonly workspaceName: string;
+    readonly projectName: string;
+    readonly counts: Readonly<Record<ResumeScopeKindLike, number>>;
+}
+/**
+ * The host's resume model: the loaded directory plus its pure view builder.
+ * Shared with the ANSI tree, which supplies the same object; `directory` is
+ * null until the first scan finishes, and `buildView` returns null then.
+ */
+export interface ResumeSourceLike {
+    readonly directory: ResumeDirectoryLike | null;
+    readonly initialScope?: ResumeScopeKindLike;
+    readonly deleteMode?: "trash" | "permanent";
+    buildView(options: ResumeViewOptionsLike): ResumeViewLike | null;
+    scopeSummary?(): ResumeScopeSummaryLike;
+    persistScope?(scope: ResumeScopeKindLike): void | Promise<void>;
+    refresh?(): Promise<void>;
+    pinConversation?(conversation: ResumeConversationLike, pinned: boolean): void | Promise<void>;
+    deleteConversation?(conversation: ResumeConversationLike): boolean | Promise<boolean>;
+    isLoading?(): boolean;
+    loadError?(): string | undefined;
+}
+export declare const RESUME_SCOPE_ORDER: readonly ResumeScopeKindLike[];
+/** The scope after `kind` in the three-way cycle (Tab). */
+export declare function nextResumeScope(kind: ResumeScopeKindLike): ResumeScopeKindLike;
+/** The segmented control's label for a scope kind. */
+export declare function resumeScopeLabel(kind: ResumeScopeKindLike): string;
+/**
+ * Per-scope conversation totals for the segmented control. The host summary
+ * wins when present (the ANSI tree already computes it); otherwise the active
+ * scope's own pre-query total is reused and the other scopes cost one
+ * empty-query view each, so the model's scope resolution (current session →
+ * default workspace) decides the group, not this module.
+ */
+export declare function resumeScopeTabs(source: ResumeSourceLike, active: ResumeViewLike, currentSessionPath: string | undefined): TspPickerScope[];
+/** Assistant turns the session persisted; older listings fall back to the message count. */
+export declare function resumeTurnCount(conversation: ResumeConversationLike): number;
+export interface ResumeItemOptions {
+    /** Show each conversation's working directory (multi-worktree scopes). */
+    readonly showCwd?: boolean;
+    readonly now?: number;
+    /** Branch of the current workspace; a repeated branch stays off the cards. */
+    readonly referenceBranch?: string | null;
+}
+/** One conversation card: the existing facts plus turns, branch and model. */
+export declare function resumePickerItem(row: ResumeConversationRowLike, workspace: ResumeWorkspaceLike | undefined, options?: ResumeItemOptions): TspPickerItem;
+/** Project and workspace section heads followed by their conversations, from the model's rows. */
+export declare function resumePickerOrder(view: ResumeViewLike): (string | TspPickerGroup)[];
+/** Free-text hit ranges for the displayed rows (structured tokens never highlight). */
+export declare function resumePickerHits(view: ResumeViewLike, items: ReadonlyMap<string, TspPickerItem>): Record<string, readonly (readonly [number, number])[]> | undefined;
+/** Catalogue items for every conversation in the target scope (identity stable while typing). */
+export declare function resumePickerItems(catalogue: ResumeViewLike, directory: ResumeDirectoryLike, options?: ResumeItemOptions): {
+    items: TspPickerItem[];
+    byPath: Map<string, TspPickerItem>;
+};
+/** The selected conversation path: the caller's when still visible, else the first row. */
+export declare function resumePickerSelection(view: ResumeViewLike, preferred: string | null | undefined): string | null;
+/**
+ * The same view with locally deleted conversations (and the section heads
+ * left empty by them) removed. Deletes are host-driven; the directory is not
+ * rebuilt per keystroke, so the picker hides the removed rows itself.
+ */
+export declare function resumeViewWithout(view: ResumeViewLike, hidden: ReadonlySet<string>): ResumeViewLike;
+export interface ResumePickerModel {
+    readonly view: ResumeViewLike;
+    readonly catalogue: ResumeViewLike;
+    readonly items: readonly TspPickerItem[];
+    readonly order: readonly (string | TspPickerGroup)[];
+    readonly hits?: Readonly<Record<string, readonly (readonly [number, number])[]>>;
+    readonly tabs: readonly TspPickerScope[];
+    readonly selected: string | null;
+    readonly current: readonly string[];
+    readonly total: number;
+    /** Conversations the filter hides (the ANSI tree stays on screen while filtering). */
+    readonly hidden: number;
+    readonly empty: string;
+    readonly placeholder: string;
+}
+export interface ResumePickerModelOptions {
+    readonly scope: ResumeScopeInputLike;
+    readonly query: string;
+    readonly currentSessionPath?: string;
+    readonly hidden?: ReadonlySet<string>;
+    readonly showCwd?: boolean;
+    readonly now?: number;
+    /** Selection to keep when it survives the query; the first row otherwise. */
+    readonly preferredPath?: string | null;
+}
+/**
+ * Everything the native sheet needs for one scope + query: the model's
+ * filtered view (rows, counts, tokens), a stable catalogue built without the
+ * query, the picker items for it, section order, hits, scope tabs and copy.
+ */
+export declare function buildResumePickerModel(source: ResumeSourceLike, options: ResumePickerModelOptions): ResumePickerModel | undefined;
+/** True when the view carries any filter (free text or structured token). */
+export declare function resumeQueryActive(view: ResumeViewLike): boolean;
+/** The empty pane's copy: no matches while filtering, else the scope's own empty wording. */
+export declare function resumeEmptyText(view: ResumeViewLike): string;
+/** The search field's placeholder for the active scope (names come from the host summary). */
+export declare function resumePlaceholder(source: ResumeSourceLike, scope: ResumeScopeInputLike): string;
+/** The selected conversation's preview: project, workspace, branch, status, model, then the excerpt. */
+export declare function resumeConversationPreview(conversation: ResumeConversationLike, project: ResumeProjectLike | undefined, workspace: ResumeWorkspaceLike | undefined): NativeChild[];
+/** Project/workspace lookups for a conversation path, derived from the directory (no re-grouping). */
+export declare function resumeConversationContext(directory: ResumeDirectoryLike, path: string): {
+    conversation: ResumeConversationLike;
+    project: ResumeProjectLike | undefined;
+    workspace: ResumeWorkspaceLike | undefined;
+} | undefined;

package/dist/types/overlays/resume-tree.d.ts

@@ -0,0 +1,353 @@
+/**
+ * ANSI three-level resume tree: project → workspace → conversation.
+ *
+ * Renders the rows produced by the coding-agent resume view model; it never
+ * groups sessions itself. The model arrives through {@link ResumeTreeSource},
+ * which the host builds from `loadResumeDirectory` + `buildResumeView` (pi-tui
+ * cannot depend on the coding-agent package). Scope cycling, collapse state,
+ * search focus, pin actions and the delete confirmation live here; view
+ * construction and persistence live in the host.
+ */
+import * as path from "node:path";
+import { type Component } from "../index.js";
+export type ResumeTreeScope = "workspace" | "project" | "all";
+/** Persisted picker state (v2 file): scope plus local expansion. */
+export interface ResumeTreePickerState {
+    scope: ResumeTreeScope;
+    collapsedProjects?: readonly string[];
+    expandedProjects?: readonly string[];
+    collapsedWorkspaces?: readonly string[];
+    /** Absolute paths in the project/workspace/cwd labels; absent means false. */
+    fullPaths?: boolean;
+}
+export type ResumeTreeStatus = "complete" | "interrupted" | "aborted" | "error" | "pending" | "unknown";
+export type ResumeTreeDeleteMode = "trash" | "permanent";
+/** The session fields the tree reads from a conversation row. */
+export interface ResumeTreeSession {
+    path: string;
+    id: string;
+    cwd: string;
+    size?: number;
+    title?: string;
+    modified: Date;
+    firstMessage?: string;
+}
+export interface ResumeTreeConversation {
+    session: ResumeTreeSession;
+    key: string;
+    id: string;
+    path: string;
+    title: string;
+    cwd: string;
+    projectKey: string;
+    workspaceKey: string;
+    created: Date;
+    modified: Date;
+    status?: ResumeTreeStatus;
+    pinned: boolean;
+    current: boolean;
+    fork: boolean;
+    /** Subagent marker from `session_init.agent`; forks never set it. */
+    isSubagent?: boolean;
+    agentName?: string;
+    parentKey?: string;
+    /** Direct subagent children, when the directory attached them. */
+    subagents?: readonly ResumeTreeConversation[];
+    messageCount: number;
+}
+export interface ResumeTreeWorkspace {
+    key: string;
+    path: string;
+    name: string;
+    /** User-configured alias, or null. The directory name never changes. */
+    alias?: string | null;
+    /** Alias when set, otherwise `name`. */
+    displayName?: string;
+    projectKey: string;
+    branch: string | null;
+    pinned: boolean;
+    lastActivity: Date | null;
+    counts: {
+        conversations: number;
+        pinnedConversations: number;
+    };
+}
+export interface ResumeTreeProject {
+    key: string;
+    root: string;
+    name: string;
+    alias: string | null;
+    displayName: string;
+    isDefault: boolean;
+    pinned: boolean;
+    collapsed: boolean;
+    lastActivity: Date | null;
+    counts: {
+        conversations: number;
+        workspaces: number;
+        pinnedConversations: number;
+    };
+}
+export interface ResumeTreeProjectRow {
+    type: "project";
+    key: string;
+    project: ResumeTreeProject;
+    pinned: boolean;
+    collapsed: boolean;
+    conversationCount: number;
+    totalConversationCount: number;
+    workspaceCount: number;
+    totalWorkspaceCount: number;
+}
+export interface ResumeTreeWorkspaceRow {
+    type: "workspace";
+    key: string;
+    workspace: ResumeTreeWorkspace;
+    projectKey: string;
+    pinned: boolean;
+    conversationCount: number;
+    totalConversationCount: number;
+}
+export interface ResumeTreeConversationRow {
+    type: "conversation";
+    key: string;
+    conversation: ResumeTreeConversation;
+    projectKey: string;
+    workspaceKey: string;
+    pinned: boolean;
+    current: boolean;
+    pinnedOnly?: boolean;
+}
+export type ResumeTreeRow = ResumeTreeProjectRow | ResumeTreeWorkspaceRow | ResumeTreeConversationRow;
+export interface ResumeTreeView {
+    scope: {
+        kind: ResumeTreeScope;
+        projectKey?: string;
+        workspaceKey?: string;
+    };
+    query: {
+        raw: string;
+        terms?: readonly string[];
+    };
+    rows: readonly ResumeTreeRow[];
+    conversations?: readonly ResumeTreeConversationRow[];
+    counts: {
+        conversations: number;
+        workspaces?: number;
+        projects?: number;
+        totalConversations: number;
+        totalWorkspaces?: number;
+        totalProjects?: number;
+    };
+    /** Branch of the current session's workspace, when known. */
+    referenceBranch?: string | null;
+    /** Workspace key of the current session, when known. */
+    currentWorkspaceKey?: string;
+}
+/** Names and per-scope conversation totals for the scope header. */
+export interface ResumeTreeScopeSummary {
+    workspaceName: string;
+    projectName: string;
+    counts: Record<ResumeTreeScope, number>;
+}
+/**
+ * Host bridge. `buildView` must be a pure projection of the loaded directory;
+ * `refresh`/`pin*`/`deleteConversation` perform I/O and resolve when the
+ * source's internal state is current again.
+ */
+export interface ResumeTreeSource {
+    readonly initialScope: ResumeTreeScope;
+    buildView(input: {
+        scope: ResumeTreeScope;
+        query: string;
+        currentSessionPath?: string;
+    }): ResumeTreeView | null;
+    scopeSummary(): ResumeTreeScopeSummary;
+    currentSessionPath?(): string | undefined;
+    /** Remember the chosen scope across opens. */
+    persistScope?(scope: ResumeTreeScope): void | Promise<void>;
+    /** Restored v2 picker state (scope + expansion); absent means defaults. */
+    pickerState?(): ResumeTreePickerState;
+    /** Persist scope + expansion together (preferred over `persistScope`). */
+    persistPickerState?(state: ResumeTreePickerState): void | Promise<void>;
+    /** Re-read the directory; resolves once `buildView` reflects the new state. */
+    refresh?(): Promise<void>;
+    /** Partial scan failures (unreadable project folders) while rows are still listed. */
+    scanWarningNames?(): readonly string[];
+    /** A failed load: no rows available at all. */
+    loadError?(): string | undefined;
+    isLoading?(): boolean;
+    pinConversation?(conversation: ResumeTreeConversation, pinned: boolean): Promise<void>;
+    pinProject?(project: ResumeTreeProject, pinned: boolean): Promise<void>;
+    pinWorkspace?(workspace: ResumeTreeWorkspace, pinned: boolean): Promise<void>;
+    /** Set the workspace display alias; resolves the name the picker now shows. */
+    renameWorkspace?(workspace: ResumeTreeWorkspace, alias: string | null): Promise<string | null>;
+    openWorkspace?(workspace: ResumeTreeWorkspace): void | Promise<void>;
+    /** Rename the persisted session title; resolves the stored name or null. */
+    renameConversation?(conversation: ResumeTreeConversation, title: string): Promise<string | null>;
+    /** False hides the conversation rename action (read-only/foreign session). */
+    canRenameConversation?(conversation: ResumeTreeConversation): boolean;
+    /** Scopes without a project header (workspace/project) resolve the project here. */
+    projectByKey?(key: string): ResumeTreeProject | undefined;
+    deleteConversation?(conversation: ResumeTreeConversation): Promise<boolean>;
+    deleteMode: ResumeTreeDeleteMode;
+}
+export interface ResumeTreeOptions {
+    source: ResumeTreeSource;
+    getTerminalRows?: () => number;
+    onSelect: (conversation: ResumeTreeConversation) => void;
+    onCancel: () => void;
+    onExit: () => void;
+    onRequestRender?: () => void;
+    /** Start with the search field focused (the default for a resume picker). */
+    searchFocused?: boolean;
+}
+/** Short relative age, localised through the shared session-picker keys. */
+export declare function formatResumeAge(date: Date, now?: number): string;
+/** Middle-ellipsis truncation for path-like text (`a/b/…/x/y`). */
+export declare function middleEllipsis(text: string, maxWidth: number): string;
+/** Pick the path API from the string's own shape, not the host platform. */
+export declare function resumePathApi(value: string): typeof path.posix;
+/** Full path spelled with its own platform's separators (drive, UNC or POSIX). */
+export declare function absoluteResumePath(value: string): string;
+/** Short parent/name tail or the full absolute path, per the picker toggle. */
+export declare function formatResumePath(value: string, fullPaths: boolean): string;
+/** Basename-first path tail (`parent/name`) keeping the platform separator. */
+export declare function resumePathTail(value: string): string;
+/**
+ * Truncate from the left so the tail stays readable, keeping a drive/UNC root
+ * when there is room for one (`D:\…\repo`, `\\server\share\…\repo`). The
+ * returned string never exceeds `maxWidth` visible columns.
+ */
+export declare function truncateResumePath(value: string, maxWidth: number): string;
+/**
+ * A workspace branch is noise when it repeats the current workspace's branch;
+ * it is kept for the current workspace or when it actually differs.
+ */
+export declare function shouldShowBranch(branch: string | null | undefined, referenceBranch: string | null | undefined, current: boolean, workspaceName?: string): boolean;
+/** Stable right-hand column widths for the conversation list. */
+export interface ConversationColumns {
+    status: number;
+    turns: number;
+    age: number;
+    flags: number;
+}
+/** Width of the status column, fixed across rows so every title starts together. */
+export declare function statusColumnWidth(): number;
+/** Column widths across every visible conversation row, so columns stay put while scrolling. */
+export declare function conversationColumns(rows: readonly ResumeTreeConversationRow[], now?: number): ConversationColumns;
+/**
+ * One dense conversation row: `status | title | turns | age | flags | ⋯`.
+ * The status cell and every metadata column have fixed widths computed once
+ * per frame; the title is the only flexible cell, and nothing ever wraps.
+ */
+export declare function renderConversationRow(row: ResumeTreeConversationRow, options: {
+    width: number;
+    selected: boolean;
+    now?: number;
+    columns?: ConversationColumns;
+    /** Show the conversation cwd as an absolute path instead of omitting it. */
+    fullPaths?: boolean;
+}): string;
+/**
+ * One workspace sub-header, indented one visible step: a coloured fold+name,
+ * a branch chip when it adds information, and right-aligned counts + `⋯`.
+ */
+export declare function renderWorkspaceRow(row: ResumeTreeWorkspaceRow, options: {
+    width: number;
+    selected: boolean;
+    collapsed: boolean;
+    referenceBranch?: string | null;
+    current?: boolean;
+    /** Show absolute workspace paths instead of parent/name tails. */
+    fullPaths?: boolean;
+    /** Workspace scope has no use for the path label; callers can omit it. */
+    showPath?: boolean;
+}): string;
+/**
+ * Project section header: pin + name + path tag on the left, counts/workspaces/
+ * age right-aligned. The caller draws a full-width rule under it.
+ */
+export declare function renderProjectRow(row: ResumeTreeProjectRow, options: {
+    width: number;
+    selected: boolean;
+    collapsed: boolean;
+    now?: number;
+    /** Show the absolute project root instead of the parent/name tail. */
+    fullPaths?: boolean;
+}): string;
+/** Full-width rule closing a project section header. */
+export declare function renderProjectRule(width: number): string;
+/** A scope-segment hit range on the header line, in tree-local columns. */
+export interface ResumeScopeHit {
+    kind: ResumeTreeScope;
+    start: number;
+    end: number;
+}
+/** The three-tab scope control with per-scope counts, plus its clickable ranges. */
+export declare function renderScopeHeaderHits(scope: ResumeTreeScope, summary: ResumeTreeScopeSummary, width: number): {
+    text: string;
+    hits: ResumeScopeHit[];
+};
+/** The three-tab scope control with per-scope counts. */
+export declare function renderScopeHeader(scope: ResumeTreeScope, summary: ResumeTreeScopeSummary, width: number): string;
+interface FlatRow {
+    row: ResumeTreeRow;
+    /** Visible when every ancestor group is expanded. */
+    parentKey?: string;
+}
+export interface ResumeTreeState {
+    collapsedProjects: Set<string>;
+    expandedProjects: Set<string>;
+    collapsedWorkspaces: Set<string>;
+}
+/** Flatten model rows under the current local collapse state (headers always stay). */
+export declare function flattenResumeRows(rows: readonly ResumeTreeRow[], state: ResumeTreeState, searching: boolean): FlatRow[];
+/**
+ * The ANSI resume tree component. The host mounts it inside its panel chrome;
+ * this component renders the scope control, search field, banners and rows.
+ */
+export declare class ResumeTreeComponent implements Component {
+    #private;
+    readonly onSelect: (conversation: ResumeTreeConversation) => void;
+    readonly onCancel: () => void;
+    readonly onExit: () => void;
+    onRequestRender?: () => void;
+    constructor(options: ResumeTreeOptions);
+    /** Rebuild the cached view (call after the host refreshes its directory). */
+    invalidate(): void;
+    get scope(): ResumeTreeScope;
+    get fullPaths(): boolean;
+    /**
+     * Toggle absolute paths. In workspace scope the path is redundant, so the
+     * key surfaces a one-line hint and leaves the setting untouched; the
+     * project/all scopes actually flip and persist it.
+     */
+    toggleFullPaths(): void;
+    /** Adopt a host-refreshed view while keeping selection and collapse state. */
+    setView(view: ResumeTreeView | null): void;
+    /** Cycle workspace → project → all → workspace. */
+    cycleScope(direction?: 1 | -1): void;
+    /** Switch to a scope (the scope segments and Tab share this path). */
+    setScope(scope: ResumeTreeScope): void;
+    /** Re-read the directory through the host source. */
+    refresh(): Promise<void>;
+    /** Focus the search field (the `/` key, and the initial state). */
+    focusSearch(): void;
+    /** Pin the selected conversation (`p`) or its project (`P`). */
+    pinSelected(project: boolean): Promise<void>;
+    /**
+     * Hit-test an SGR mouse report against the rows the last render recorded.
+     * The fullscreen picker paints from screen row 0, so callers pass the
+     * component's frame offset (`row` of the first rendered line, `col` of its
+     * first content column). Keyboard handling never depends on this path.
+     */
+    handleMouse(data: string, offset?: {
+        row?: number;
+        col?: number;
+    }): boolean;
+    handleInput(keyData: string): void;
+    render(width: number): readonly string[];
+    dispose(): void;
+}
+export {};