@linxiraos/pi-tui 1.3.2 → 1.4.0

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 {};

package/dist/types/overlays/session-selector.d.ts

@@ -1,6 +1,7 @@
 import { type Component, Input } from "../index.js";
 import type { TspPickerGroup, TspPickerItem } from "@linxiraos/pi-wire";
 import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node.js";
+import { type ResumeSourceLike } from "./resume-picker.js";
 /** Session lifecycle status presented by the picker. */
 export type SessionSelectorStatus = "complete" | "interrupted" | "aborted" | "error" | "pending" | "unknown";
 /** Session listing fields consumed by the picker. */
@@ -18,6 +19,8 @@ export interface SessionSelectorEntry {
     /** Path to the parent session when this one was forked. */
     parentSessionPath?: string;
 }
+import { ResumeTreeComponent } from "./resume-tree.js";
+export type { ResumeConversationLike, ResumeDirectoryLike, ResumeProjectLike, ResumeQueryLike, ResumeScopeInputLike, ResumeScopeKindLike, ResumeSourceLike, ResumeViewLike, ResumeViewRowLike, ResumeWorkspaceLike, } from "./resume-picker.js";
 import { OverlayPanel } from "../chrome/overlay-box.js";
 /** The session list's part of the picker props, plus the memo keys it was built from. */
 interface SessionPickerView {
@@ -76,6 +79,11 @@ declare class SessionList<T extends SessionSelectorEntry> implements Component {
     constructor(sessions: T[], showCwd?: boolean, historyMatcher?: SessionHistoryMatcher, getTerminalRows?: () => number, pinnedIds?: ReadonlySet<string>, currentSessionPath?: string | (() => string | undefined));
     /** Replace the visible dataset, e.g. when toggling folder/all-projects scope. */
     setSessions(sessions: T[], showCwd: boolean, pinnedIds?: ReadonlySet<string>): void;
+    /**
+     * Resume-model mode: the given sessions are already the model's ordered,
+     * filtered view, so mirror them and keep the selection when it survives.
+     */
+    syncSessions(sessions: readonly T[], preferredPath?: string | null): void;
     /** Cancel pending async search work; idempotent, called on every picker exit path. */
     dispose(): void;
     removeSession(sessionPath: string): void;
@@ -125,6 +133,17 @@ export interface SessionSelectorOptions<T extends SessionSelectorEntry = Session
     loadAllSessions?: () => Promise<T[]>;
     /** Preloaded all-projects list; cached so the first Tab toggle is instant. */
     allSessions?: T[];
+    /**
+     * The host's resume model (project → workspace → conversation) and its
+     * pure view builder. When set, the native `picker` describes the resume
+     * tree instead of the flat day-grouped list; the ANSI path is unchanged.
+     */
+    resumeSource?: ResumeSourceLike;
+    /**
+     * What delete does to the session file: an in-session picker moves it to
+     * the trash, `--resume` deletes it permanently. Wording only.
+     */
+    deleteMode?: "trash" | "permanent";
     /** Picker heading; defaults to "Resume Session". */
     title?: string;
     /** Primary action label; defaults to "Resume" (ANSI footer defaults to "select"). */
@@ -160,9 +179,7 @@ export interface SessionSelectorOptions<T extends SessionSelectorEntry = Session
      */
     standalone?: boolean;
 }
-/**
- * Component that renders a session selector with optional confirmation dialog
- */
+/** Component that renders a session selector with optional confirmation dialog. */
 export declare class SessionSelectorComponent<T extends SessionSelectorEntry = SessionSelectorEntry> extends OverlayPanel {
     #private;
     constructor(sessions: T[], onSelect: (session: T) => void, onCancel: () => void, onExit: () => void, options?: SessionSelectorOptions<T>);
@@ -196,5 +213,6 @@ export declare class SessionSelectorComponent<T extends SessionSelectorEntry = S
     handleNativeEvent(event: NativeUiEvent): void;
     handleInput(keyData: string): void;
     getSessionList(): SessionList<T>;
+    /** The ANSI resume tree when the host supplied a resume source. */
+    getResumeTree(): ResumeTreeComponent | undefined;
 }
-export {};

package/dist/types/terminal-capabilities.d.ts

@@ -18,7 +18,7 @@ export declare enum NotifyProtocol {
     Osc99 = "\u001B]99;;",
     Osc9 = "\u001B]9;"
 }
-export type TerminalId = "kitty" | "ghostty" | "wezterm" | "iterm2" | "vscode" | "alacritty" | "warp" | "orca" | "otty" | "rio" | "tern" | "monstar" | "base" | "trueColor";
+export type TerminalId = "kitty" | "ghostty" | "wezterm" | "iterm2" | "vscode" | "alacritty" | "warp" | "orca" | "otty" | "rio" | "tern" | "monstar" | "zetawork" | "base" | "trueColor";
 /** Terminal capability details used for rendering and protocol selection. */
 export declare class TerminalInfo {
     readonly id: TerminalId;

package/dist/types/tools/hub.d.ts

@@ -123,6 +123,8 @@ export interface CoordinationDetails {
     }[];
     /** Running subagents not represented by a job row in this result. */
     agents?: AgentActivitySnapshot[];
+    /** `wait` returned early because blocking would deadlock (mesh S6). */
+    status?: "peer-waiting-on-you";
 }
 /** Hub result details: coordination snapshots or launch (process) state. */
 export type HubDetails = CoordinationDetails | LaunchToolDetails;
@@ -204,7 +206,7 @@ export interface IrcMessage {
 /** Delivery outcome for one peer recipient. */
 export interface IrcDeliveryReceipt {
     to: string;
-    outcome: "injected" | "woken" | "revived" | "failed";
+    outcome: "injected" | "woken" | "revived" | "queued" | "failed";
     error?: string;
 }
 /** Broker-facing launch parameters; the hub adapts its `ps` op to `list` before calling in. */

package/dist/types/tools/irc.d.ts

@@ -23,7 +23,11 @@ export interface IrcMessage {
 /** Delivery outcome for one peer recipient. */
 export interface IrcDeliveryReceipt {
     to: string;
-    outcome: "injected" | "woken" | "revived" | "failed";
+    /**
+     * `queued` is the cross-process offline path: the message is in the peer's
+     * persistent mailbox and will be injected when its process next starts.
+     */
+    outcome: "injected" | "woken" | "revived" | "queued" | "failed";
     error?: string;
 }
 /** Status ordering for peer rosters in child prompts. */

package/dist/types/tools/wait.d.ts

@@ -96,6 +96,12 @@ export interface CoordinationDetails {
     agents?: AgentActivitySnapshot[];
     /** `wait` was cut short by steering, a peer message, or a completion notice that injects next. */
     interrupted?: boolean;
+    /**
+     * `wait` returned early without a message because continuing would deadlock:
+     * the peer it was waiting on is itself waiting on this agent. Both sides can
+     * keep working — answer the peer, then wait again.
+     */
+    status?: "peer-waiting-on-you";
 }
 /** Pending wait frame. */
 declare function waitRenderCall(_args: object, _options: RenderResultOptions, uiTheme: Theme): Component;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@linxiraos/pi-tui",
-	"version": "1.3.2",
+	"version": "1.4.0",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://linxira-os.github.io/zeta/",
 	"author": "Linxira-OS",
@@ -38,14 +38,14 @@
 		"gen:glyphs": "bun scripts/gen-glyphs.ts"
 	},
 	"dependencies": {
-		"@linxiraos/pi-omptype": "1.3.2",
-		"@linxiraos/pi-agent-core": "1.3.2",
-		"@linxiraos/pi-ai": "1.3.2",
-		"@linxiraos/pi-catalog": "1.3.2",
-		"@linxiraos/pi-natives": "1.3.2",
-		"@linxiraos/pi-utils": "1.3.2",
-		"@linxiraos/pi-wire": "1.3.2",
-		"@linxiraos/pi-snapcompact": "1.3.2"
+		"@linxiraos/pi-omptype": "1.4.0",
+		"@linxiraos/pi-agent-core": "1.4.0",
+		"@linxiraos/pi-ai": "1.4.0",
+		"@linxiraos/pi-catalog": "1.4.0",
+		"@linxiraos/pi-natives": "1.4.0",
+		"@linxiraos/pi-utils": "1.4.0",
+		"@linxiraos/pi-wire": "1.4.0",
+		"@linxiraos/pi-snapcompact": "1.4.0"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"

package/src/apps/session-picker.ts

@@ -1,9 +1,12 @@
 import { logger } from "@linxiraos/pi-utils";
 import {
+	type ResumeSourceLike,
 	SessionSelectorComponent,
-	type SessionSelectorEntry,
 	type SessionHistoryMatcher,
+	type SessionSelectorEntry,
+	type SessionSelectorOptions,
 } from "../overlays/session-selector";
+import type { ResumeTreeSource } from "../overlays/resume-tree";
 import { runStandaloneTui } from "./standalone-picker";
 
 /** Persistence and history capabilities supplied by the session-owning host. */
@@ -12,6 +15,8 @@ export interface SessionPickerHost<T extends SessionSelectorEntry = SessionSelec
 	loadHistoryMatcher?(): SessionHistoryMatcher;
 	deleteSession?(session: T): Promise<boolean>;
 	loadAllSessions?(): Promise<T[]>;
+	/** Builds the three-level resume source for the standalone `--resume` tree. */
+	loadResumeSource?(deleteMode: "trash" | "permanent", workspacePath?: string): Promise<ResumeTreeSource | undefined>;
 }
 
 /** Presentation and capability controls for the standalone session picker. */
@@ -24,6 +29,12 @@ export interface SessionPickerOptions<T extends SessionSelectorEntry = SessionSe
 	allowGlobalScope?: boolean;
 	historySearch?: boolean;
 	pinnedIds?: ReadonlySet<string>;
+	/** Opt into the three-level resume tree; `deleteMode` words the confirm step. */
+	resume?: { deleteMode: "trash" | "permanent"; workspacePath?: string };
+	/** The host's resume model; when set, the native picker renders the project tree. */
+	resumeSource?: ResumeSourceLike;
+	/** Delete wording: in-session moves to trash, `--resume` deletes permanently. */
+	deleteMode?: "trash" | "permanent";
 }
 
 /**
@@ -51,6 +62,11 @@ export async function selectSession<T extends SessionSelectorEntry>(
 		}
 	}
 
+	const resumeMode = options.resume?.deleteMode;
+	const resumeSource = resumeMode
+		? await host.loadResumeSource?.(resumeMode, options.resume?.workspacePath)
+		: undefined;
+
 	return runStandaloneTui<T | null>(
 		({ ui, finish }) => {
 			const selector = new SessionSelectorComponent(
@@ -73,7 +89,9 @@ export async function selectSession<T extends SessionSelectorEntry>(
 					scopeLabel: options.scopeLabel,
 					showCwd: options.showCwd,
 					pinnedIds,
-				},
+					resumeSource: resumeSource ?? options.resumeSource,
+					deleteMode: resumeMode ?? options.deleteMode,
+				} as SessionSelectorOptions<T> & { resumeSource?: ResumeTreeSource; deleteMode?: "trash" | "permanent" },
 			);
 			selector.setOnRequestRender(() => ui.requestRender());
 			return selector;