@linxiraos/pi-tui 1.1.26 → 1.2.0

package/dist/types/overlays/annotation-overlay.d.ts

@@ -1,4 +1,4 @@
-import { type Component, type TUI } from "../index.js";
+import { type Focusable, type TUI } from "../index.js";
 import { type KeybindingsManager } from "../app-keybindings.js";
 import { type Theme } from "../theme/theme.js";
 import type { CodeReviewAnnotation, CodeReviewOverlayResult, ReviewDiffFile, TextReviewAnnotation, TextReviewOverlayResult, TextReviewSource } from "./annotation-types.js";
@@ -10,6 +10,8 @@ export interface AnnotationOverlayCallbacks {
     onWarning?(message: string): void;
     /** Open the draft in the host's editor and invoke `commit` with its result. */
     onAnnotationExternalEditor?(draft: string, commit: (text: string | null) => void): void | Promise<void>;
+    /** Open the current source in the host's editor. The overlay stays open. */
+    onExternalEditor?(): void | Promise<void>;
 }
 export interface CodeReviewOverlayCallbacks extends AnnotationOverlayCallbacks {
     onComplete(result: CodeReviewOverlayResult | undefined): void;
@@ -17,15 +19,30 @@ export interface CodeReviewOverlayCallbacks extends AnnotationOverlayCallbacks {
 export interface TextReviewOverlayCallbacks extends AnnotationOverlayCallbacks {
     onComplete(result: TextReviewOverlayResult | undefined): void;
 }
+/** Splits a text source into the overlay's 1-based annotatable lines. */
+export declare function splitTextLines(text: string): string[];
 /** A fullscreen, annotated diff picker that only relies on public OMP APIs. */
-export declare class AnnotationOverlay implements Component {
+export declare class AnnotationOverlay implements Focusable {
     #private;
+    focused: boolean;
     constructor(tui: TUI, theme: Theme, keybindings: KeybindingsManager, files: readonly ReviewDiffFile[], mode: string, callbacks: CodeReviewOverlayCallbacks);
     constructor(tui: TUI, theme: Theme, keybindings: KeybindingsManager, source: TextReviewSource, callbacks: TextReviewOverlayCallbacks);
+    /** Keep the nested editor's cursor mode aligned with the overlay focus target. */
+    setUseTerminalCursor(useTerminalCursor: boolean): void;
     invalidate(): void;
     dispose(): void;
     getAnnotations(): CodeReviewAnnotation[];
     getTextAnnotations(): TextReviewAnnotation[];
+    /** Repo-relative path of the diff file under the cursor, if this is a code review. */
+    reviewFilePath(): string | undefined;
+    /** Current text-source bytes, including edits applied by {@link replaceTextSource}. */
+    textSourceText(): string | undefined;
+    /**
+     * Replace the text under review. Line notes whose quote still sits on the
+     * same row stay; a quote that moved to exactly one row is retargeted;
+     * every other line note is dropped. Returns how many were dropped.
+     */
+    replaceTextSource(text: string): number;
     handleInput(data: string): void;
     describe(): NativeNode;
     handleNativeEvent(event: NativeUiEvent): void;

package/dist/types/overlays/annotation-types.d.ts

@@ -81,4 +81,6 @@ export type TextReviewAnnotation = {
 export interface TextReviewOverlayResult {
     action: "paste";
     annotations: TextReviewAnnotation[];
+    /** Source text after an external-editor edit; absent when the source was not edited. */
+    editedText?: string;
 }

package/dist/types/overlays/ask-dialog.d.ts

@@ -101,8 +101,11 @@ export declare class AskDialogComponent implements Component {
     handleInput(keyData: string): void;
     render(width: number): readonly string[];
     /**
-     * A bottom-anchored glass sheet over the composer (the `overlay` hoists into
-     * the terminal's layer; the dialog's own slot in the dock stays empty).
+     * In the dock, in the composer's place and framed as the composer is: a
+     * `col` with the prompt editor's root role (`zeta.editor`), so the terminal
+     * gives it the composer's insets and spacing. Not a modal `overlay` sheet:
+     * one anchored at the bottom covered the transcript rows that explain the
+     * question and blocked scrolling until the question was answered.
      */
     describe(cx: DescribeContext): NativeNode;
     /**

package/dist/types/overlays/btw-history-panel.d.ts

@@ -1,6 +1,7 @@
 import { type Component, type Focusable, Input } from "../index.js";
 import { type BtwHistoryRecord } from "./btw-history.js";
 import type { SpaceHoldHandler } from "../space-hold.js";
+import { type KeyId } from "../app-keybindings.js";
 import type { NativeNode, NativeUiEvent } from "../native/node.js";
 interface BtwHistoryPanelOptions {
     records: readonly BtwHistoryRecord[];
@@ -9,10 +10,17 @@ interface BtwHistoryPanelOptions {
     onCancel: (record: BtwHistoryRecord) => void;
     canFollowUp?: (record: BtwHistoryRecord) => boolean;
     onFollowUp?: (record: BtwHistoryRecord, question: string, signal: AbortSignal) => Promise<boolean>;
-    /** Space-bar push-to-talk for a follow-up composer: dictates into `input` while Space is held. */
+    /** Configured push-to-talk keys for a follow-up composer. */
+    spaceHoldKeys?: readonly KeyId[];
     spaceHold?: (input: Input) => SpaceHoldHandler;
     requestRender: () => void;
     getHeight: () => number;
+    /**
+     * Esc closes the panel even while the selected answer runs (it keeps
+     * streaming in the background) and `x` cancels it, instead of Esc cancelling
+     * first. For a host with no inline panel to fall back to (Tern).
+     */
+    escapeHides?: boolean;
 }
 /** Session-local side questions. Selecting or copying never promotes them into chat. */
 export declare class BtwHistoryPanel implements Component, Focusable {
@@ -25,6 +33,10 @@ export declare class BtwHistoryPanel implements Component, Focusable {
     markCopied(recordId: string, text: string): void;
     invalidate(): void;
     openFollowUp(recordId: string): boolean;
+    /** Select a record with its answer pane focused, read from the top (a just-asked /btw). */
+    showRecord(recordId: string): void;
+    /** Only an active follow-up composer can claim its configured push-to-talk keys. */
+    capturesInput(data: string): boolean;
     /** Enhanced clipboard pastes belong only to the active composer. */
     pasteText(text: string): void;
     handleInput(data: string): void;

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

@@ -31,6 +31,7 @@ export interface CopySelectorDeps {
     cwd: string;
     hideThinkingBlock?: () => boolean;
     proseOnlyThinking?: () => boolean;
+    expandThinkingBlocks?: () => boolean;
     linkTargets?: ReadonlyMap<string, string>;
     requestRender: () => void;
     /** Replaces the "Copy" header when the picker is reused for another purpose. */

package/dist/types/overlays/history-search.d.ts

@@ -15,6 +15,13 @@ import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node.
 export declare class HistorySearchComponent extends OverlayPanel {
     #private;
     constructor(historyStorage: HistorySource, onSelect: (prompt: string) => void, onCancel: () => void);
+    /**
+     * Repaint hook for debounced result updates. Once set, query edits search
+     * storage after a {@link SEARCH_DEBOUNCE_MS} quiet period instead of on
+     * every key; without it every edit searches synchronously.
+     */
+    setOnRequestRender(callback: () => void): void;
+    dispose(): void;
     handleInput(keyData: string): void;
     /**
      * With the `picker` kind: a `size:"md"` sheet of past prompts (first line
@@ -29,6 +36,9 @@ export declare class HistorySearchComponent extends OverlayPanel {
      * Picker: a row click highlights, a second click or `Insert` inserts it
      * (Enter), `Close` cancels (Esc), `Clear search` empties the query.
      * List: picking a result does what highlighting it and pressing Enter does.
+     * A row picked while a debounced search is pending belongs to the previous
+     * query: results are refreshed first and the pick only lands if that entry
+     * is still among them.
      */
     handleNativeEvent(event: NativeUiEvent): void;
 }

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

@@ -57,6 +57,10 @@ export interface HookSelectorOptions {
     /** Number of leading options (original order) that receive a selection
      *  marker. Defaults to every option when {@link selectionMarker} is set. */
     markableCount?: number;
+    /** Describe as a card in the dock (the composer slot) instead of a picker
+     *  sheet, so dock content above it (e.g. a `/omfg` candidate rule) stays
+     *  visible and the transcript stays scrollable on native surfaces. */
+    inline?: boolean;
 }
 export interface HookSelectorOption {
     label: string;
@@ -70,10 +74,11 @@ export declare class HookSelectorComponent extends OverlayPanel {
     render(width: number): readonly string[];
     dispose(): void;
     /**
-     * A plain option list is a picker sheet. Otherwise a card headed by the
-     * title (plus the countdown `elapsed` when a timeout runs), the extra title
-     * lines, the slider as `tabs`, the options as a `list` keyed by original
-     * option index, the search query while typing, and the key hints.
+     * A plain option list is a picker sheet. Otherwise (inline, slider, or
+     * countdown) a card headed by the title (plus the countdown `elapsed` when a
+     * timeout runs), the extra title lines, the slider as `tabs`, the options as
+     * a `list` keyed by original option index, the search query while typing,
+     * and the key hints.
      */
     describe(cx: DescribeContext): NativeNode;
     /** Pointer pick of an option does what highlighting it and pressing Enter does; a tab pick moves the slider. */

package/dist/types/overlays/hub-frame.d.ts

@@ -61,7 +61,10 @@ export declare class HubFrame {
     constructor(title: string, sidebarBounds: {
         min: number;
         max: number;
-    }, renderSidebar: (width: number, rows: number) => string[], renderBody: (width: number, height: number | undefined) => readonly string[]);
+    }, renderSidebar: (width: number, rows: number) => string[], renderBody: (width: number, height: number | undefined) => readonly string[], options?: {
+        bodyMinWidth?: number;
+        preserveSidebar?: boolean;
+    });
     /** Invalidate the composed layout. */
     invalidate(): void;
     /** Measure labels and annotations within this hub's sidebar width bounds. */

package/dist/types/overlays/jobs-panel.d.ts

@@ -1,4 +1,4 @@
-import { type Component, Container } from "../tui.js";
+import type { Component } from "../tui.js";
 import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node.js";
 /** One async job as the session snapshots it. */
 export interface JobsPanelJob {
@@ -40,12 +40,6 @@ export interface JobsSheetSource {
     /** Dismiss the sheet. */
     close(): void;
 }
-/** The `/jobs` block: `ansi` renders in the terminal, the snapshot describes the native frame. */
-export declare class JobsPanel extends Container {
-    #private;
-    constructor(snapshot: JobsPanelSnapshot, nowMs: number, ansi: readonly Component[]);
-    describe(cx: DescribeContext): NativeNode;
-}
 /**
  * The jobs pill's sheet: a centred `lg` glass sheet titled Background jobs.
  * A selectable list of every job (running first) sits over the selected

package/dist/types/overlays/model-browser.d.ts

@@ -1,5 +1,5 @@
 import type { Model } from "@linxiraos/pi-ai";
-import type { ModelKind } from "@linxiraos/pi-catalog/types";
+import { type ModelKind } from "@linxiraos/pi-catalog/types";
 import type { Component } from "../tui.js";
 import type { SgrMouseEvent } from "../mouse.js";
 import { type ConfiguredThinkingLevel } from "../thinking.js";
@@ -37,6 +37,17 @@ export interface ResolvedModelRoleValue {
     explicitThinkingLevel: boolean;
     warning?: string;
 }
+/** Where auto-compaction triggers for one model, as the model hub's preview shows it (edited from the Roles view). */
+export interface ModelCompactionPoint {
+    /** Context tokens that trigger auto-compaction; undefined when auto-compaction is off or the window is unknown. */
+    tokens: number | undefined;
+    /** Why it triggers there, in a few words: `fixed`, `85% of 400K base`, `80% of window`. */
+    basis?: string;
+    /** What sets it: the matching `compaction.modelThresholds` key, `global`, or `default`. */
+    source: string;
+    /** The model's own exact entry as editable text (`90k`, `80%`); absent when it has none. */
+    draft?: string;
+}
 /** Host-provided preferences and model-role resolution for the browser. */
 export interface ModelBrowserSource extends ModelRoleLookup {
     /**
@@ -49,11 +60,17 @@ export interface ModelBrowserSource extends ModelRoleLookup {
     readonly knownRoleIds: readonly string[];
     readonly mruOrder: readonly string[];
     readonly modelPerf: ReadonlyMap<string, ModelBrowserPerf>;
+    /**
+     * Service tier the host would send for `model`, when it runs one. Rows with a
+     * measured tier aggregate (`selector@tier`) then display that tier's numbers
+     * instead of the standard aggregate.
+     */
+    serviceTierFor?(model: Model): string | undefined;
     getRoleInfo(role: string): ModelBrowserRoleInfo;
-    /** True when the provider was injected from the upstream OMP model config. */
-    isOmpOriginProvider?(provider: string): boolean;
     defaultRoleChain(role: string): string[];
     resolveRoleValue(value: string | undefined, models: Model[], roleLookup?: ModelRoleLookup): ResolvedModelRoleValue;
+    /** Auto-compaction point for `model`; absent hosts show no compaction row in the preview. */
+    compactionPointFor?(model: Model): ModelCompactionPoint | undefined;
 }
 /** Read-only catalog surface consumed by model browsers. */
 export interface ModelBrowserRegistry {
@@ -86,6 +103,14 @@ export type RoleAssignments = Record<string, RoleAssignment | undefined>;
  * the alt+p session picker.
  */
 export declare function resolveRoleAssignments(settings: ModelBrowserSource, allModels: ReadonlyArray<Model>, autoCandidates: ReadonlyArray<Model>): RoleAssignments;
+/**
+ * Role-resolution pool for a `--models`/`enabledModels` scope: the scoped
+ * models plus every available non-chat runner (judge, search, image, …). The
+ * scope only filters chat models (it feeds Ctrl+P cycling) and runtime role
+ * resolution ignores it for other kinds, so displayed role assignments must too.
+ * Shared by the /models hub and the session picker.
+ */
+export declare function scopedRolePool(scoped: ReadonlyArray<Model>, registry: ModelBrowserRegistry): Model[];
 /** Wrap raw models into browser items. */
 export declare function buildBrowserItems(models: ReadonlyArray<Model>): ModelBrowserItem[];
 /** Options for {@link sortModelItems}. */
@@ -136,12 +161,28 @@ export interface SearchAffinity {
  * policy, not evidence of user preference.
  */
 export declare function buildSearchAffinity(providerOrder: ReadonlyArray<string>, roles: RoleAssignments, mruOrder: ReadonlyArray<string>): SearchAffinity;
-/** Rank picker and mention candidates by text relevance, user affinity, and MRU/version order. */
-export declare function rankModelItems(query: string, items: ReadonlyArray<ModelBrowserItem>, options: {
+/** Inputs to {@link rankModelItems} / {@link ModelItemRanker}. */
+export interface ModelRankOptions {
     roles: RoleAssignments;
     mruOrder: ReadonlyArray<string>;
     affinity: SearchAffinity;
-}): ModelBrowserItem[];
+}
+/**
+ * {@link rankModelItems} prepared for one candidate list: the fuzzy index, the
+ * MRU/version order, and the affinity ranks depend only on the items and options,
+ * so per-keystroke callers (composer mentions, `/switch` arguments, the picker)
+ * hold one ranker and pay only the per-query fuzzy scan.
+ */
+export declare class ModelItemRanker {
+    #private;
+    readonly items: ReadonlyArray<ModelBrowserItem>;
+    readonly options: ModelRankOptions;
+    constructor(items: ReadonlyArray<ModelBrowserItem>, options: ModelRankOptions);
+    /** Rank by text relevance, user affinity, and MRU/version order. */
+    rank(query: string): ModelBrowserItem[];
+}
+/** Rank picker and mention candidates by text relevance, user affinity, and MRU/version order. */
+export declare function rankModelItems(query: string, items: ReadonlyArray<ModelBrowserItem>, options: ModelRankOptions): ModelBrowserItem[];
 /**
  * A slim role chip: `● default ◉` — solid dot for configured assignments,
  * hollow for auto-selected fallbacks, thinking glyph attached when set.
@@ -157,7 +198,7 @@ export declare function rankModelItems(query: string, items: ReadonlyArray<Model
 export declare function formatRoleChip(role: string, assignment: RoleAssignment, settings: ModelBrowserSource): string;
 /** Fact columns of a model picker (Stencil `NATIVE_REDESIGN.md` §4.7); the lowest priority hides first. */
 export declare const MODEL_PICKER_COLUMNS: readonly TspPickerColumn[];
-/** The zeta theme token of a thinking level's dot (`thinkingHigh`); none for inherit and auto. */
+/** The omp theme token of a thinking level's dot (`thinkingHigh`); none for inherit and auto. */
 export declare function thinkingDotToken(level: ConfiguredThinkingLevel): string | undefined;
 /**
  * The fuzzy haystack for a model row: the displayed `provider/id`, plus `free`
@@ -242,6 +283,12 @@ export declare class ModelBrowser implements Component {
     setQuery(query: string): void;
     getSelected(): ModelBrowserItem | undefined;
     get visibleCount(): number;
+    /**
+     * Base items matching the live query, best first, without the separator
+     * row; undefined while the query is blank. Reuses the ranking the list
+     * already ran, so hosts can derive match counts without ranking again.
+     */
+    get queryMatches(): readonly ModelBrowserItem[] | undefined;
     /** Move selection to `selector`; false when it is not in the current view. */
     selectSelector(selector: string): boolean;
     /** True when `item`'s context window is smaller than the live session token count (grayed row; hosts compact before switching). */

package/dist/types/overlays/model-hub.d.ts

@@ -12,6 +12,14 @@ export interface ModelHubSource extends ModelBrowserSource {
     getProjectModelRole(role: string): string | undefined;
     getGlobalModelRole(role: string): string | undefined;
     getModelRoleSource(role: string): "global" | "project" | "default";
+    /**
+     * Saved model presets (in switch order) and the one the current role setup
+     * matches, if any. Absent hosts have no presets to switch between.
+     */
+    getModelPresets?(): {
+        names: readonly string[];
+        active: string | undefined;
+    };
 }
 /** Catalog capabilities required by the model hub. */
 export interface ModelHubRegistry extends ModelBrowserRegistry {
@@ -48,10 +56,39 @@ export interface ModelHubCallbacks {
     onLoginRequest?: (providerId: string) => void;
     /** Save the current role assignments and default thinking level as a named model preset. */
     onSavePreset?: (name: string) => void;
+    /**
+     * Apply a saved model preset (ctrl+←/→ or p/⇧P in the Roles view) and report
+     * the outcome itself. A switch that writes nothing (a refused preset) still
+     * advances the hub's preset cursor, so the next press moves past it.
+     */
+    onSwitchPreset?: (name: string) => void | Promise<void>;
     /** Persist a new quick-switch cycle order (the ctrl+p role cycle). */
     onCycleOrderChange?: (order: string[]) => void;
+    /**
+     * Persist typed text as `model`'s own compaction limit: a token base the
+     * policy scales (`400k`), a fixed trigger (`f400k`), a percentage (`80%`), or
+     * empty to reset. Rejected input returns `{ kind: "error" }`; input that
+     * needs acknowledgement (one that opens the extended window) returns
+     * `{ kind: "confirm" }` until called again with the same text and
+     * `confirmed`. Either keeps the field open.
+     */
+    onCompactionPointChange?: (model: Model, input: string, confirmed: boolean) => CompactionPointChangeResult | undefined;
+    /**
+     * One short line on where `model` would compact with the typed limit
+     * (`compacts at 340K · 85% of 400K base`), shown beside the field while
+     * typing; undefined for input that does not parse or fit.
+     */
+    previewCompactionPoint?: (model: Model, input: string) => string | undefined;
     onCancel: () => void;
 }
+/** Why {@link ModelHubCallbacks.onCompactionPointChange} kept the field open. */
+export type CompactionPointChangeResult = {
+    kind: "error";
+    message: string;
+} | {
+    kind: "confirm";
+    message: string;
+};
 export interface ModelHubOptions {
     /** Preselect this provider's sidebar entry (e.g. when reopening after /login). */
     initialProviderId?: string;

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

@@ -39,5 +39,4 @@ export declare class OAuthSelectorComponent extends OverlayPanel {
      * drives the hover band, and a left click selects and confirms like Enter.
      */
     routeMouse(event: SgrMouseEvent, line: number, _col: number): void;
-    render(width: number): readonly string[];
 }

package/dist/types/overlays/plan-review-overlay.d.ts

@@ -13,8 +13,9 @@
  * Focus regions (`toc`/`body`/`actions`) cycle with Tab/Shift+Tab; arrows move
  * within the focused region and step left into the sidebar. The default focus is
  * `actions`, so the muscle memory of the old single-target overlay carries over:
- * ↑/↓ select options, Enter confirms, ←/→ drives the slider when there is no
- * sidebar, g/G + PgUp/PgDn scroll, and the external-editor key opens the plan.
+ * ↑/↓ select options, Enter confirms, ←/→ drives the slider, g/G + PgUp/PgDn
+ * scroll, and the external-editor key opens the plan. Under Tern the options
+ * are a horizontal bar, so ←/→ select options and Shift+←/→ drive the slider.
  */
 import { type Component } from "../index.js";
 import type { HookSelectorSlider } from "./hook-selector.js";

package/dist/types/overlays/report-panel.d.ts

@@ -0,0 +1,68 @@
+import type { TspText } from "@linxiraos/pi-wire";
+import { OverlayPanel } from "../chrome/overlay-box.js";
+import type { NativeNode, NativeUiEvent } from "../native/node.js";
+import type { Component } from "../tui.js";
+/** Options of a {@link ReportPanel}. */
+export interface ReportPanelOptions {
+    /** Plain title: the text-mode border title, and the native sheet head unless {@link head} is given. */
+    readonly title: string;
+    /** Styled native sheet head. */
+    readonly head?: TspText;
+    /** The read-only report; it draws no frame or title of its own. */
+    readonly body: Component;
+    /**
+     * Display form of the key that dismisses the report while it sits above the
+     * editor (the editor's interrupt key, which routes to it). Once the panel
+     * holds focus ({@link ReportPanel.holdFocus}) the hint shows the key its own
+     * input closes on instead.
+     */
+    readonly closeKey: string;
+    /** The focused panel (native sheet, text-mode full-screen page) closes on Esc / its Close button: this runs. */
+    readonly onClose: () => void;
+    /**
+     * Most rows the text-mode panel may take, borders included (the screen rows
+     * left above the editor); a taller report scrolls inside it. `undefined`
+     * leaves it uncapped.
+     */
+    readonly maxRows?: () => number | undefined;
+}
+/**
+ * A read-only command report (`/changelog`, `/context`, `/tools`, …).
+ *
+ * Text mode draws a titled box with the body and an Esc hint: above the editor
+ * like the `/btw` panel while it fits there (the editor keeps focus and its
+ * Esc takes it away), or as a full-screen page on the alternate screen when it
+ * is taller, whose body scrolls on the arrow/page/Home/End keys and the wheel.
+ * Natively it is a sheet like `/usage`: a centred `lg` glass sheet titled by
+ * the report whose body the terminal scrolls (wheel, and the same keys
+ * forwarded as scroll requests), then a Close button; Esc closes it.
+ */
+export declare class ReportPanel extends OverlayPanel {
+    #private;
+    readonly nativeOverlay: NonNullable<Component["nativeOverlay"]>;
+    constructor(options: ReportPanelOptions);
+    /**
+     * The panel is shown with focus (native sheet, text-mode full-screen page):
+     * its own {@link handleInput} closes it, so the hint names that key.
+     */
+    holdFocus(): void;
+    /**
+     * Text mode: cap the box to {@link ReportPanelOptions.maxRows}, scrolling a
+     * taller body. The cap is a hard limit: when a resize leaves fewer rows than
+     * the box's chrome needs, its bottom (the hint and closing border) is cut
+     * rather than spilling over the editor.
+     */
+    render(width: number): readonly string[];
+    /** Text mode: rows the whole box takes at `width` when nothing caps it. */
+    heightAt(width: number): number;
+    /** The sheet body (the overlay is the frame, and its body the scroller): the report, then Close (Esc). */
+    describe(): NativeNode;
+    invalidate(): void;
+    /**
+     * Focused (the native sheet, or the text-mode full-screen page): Esc closes;
+     * the arrow, page, Home and End keys and the wheel scroll the body.
+     */
+    handleInput(data: string): void;
+    /** Close runs what Esc runs. */
+    handleNativeEvent(event: NativeUiEvent): void;
+}

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

@@ -48,6 +48,7 @@ export interface RewindSelectorDeps {
     cwd: string;
     hideThinkingBlock?: () => boolean;
     proseOnlyThinking?: () => boolean;
+    expandThinkingBlocks?: () => boolean;
     linkTargets?: ReadonlyMap<string, string>;
     requestRender: () => void;
     /** Sibling branch paths of `entryId`'s turn (excluding the turn itself). */

package/dist/types/overlays/session-observer-registry.d.ts

@@ -58,6 +58,8 @@ export interface ObservableSession {
     lastUpdate: number;
     /** Latest progress snapshot from the subagent executor */
     progress?: AgentProgress;
+    /** `Date.now()` when {@link progress} arrived; its `durationMs` was current then. */
+    progressAt?: number;
 }
 /** Coarse source of an observer change; callers use it to separate lifecycle work from high-frequency progress. */
 export type SessionObserverChangeKind = "main" | "reset" | "lifecycle" | "progress";

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

@@ -71,7 +71,7 @@ declare class SessionList<T extends SessionSelectorEntry> implements Component {
     onExit: () => void;
     onToggleScope?: () => void;
     onDeleteRequest?: (session: T) => void;
-    /** Re-render hook for async list updates (fuzzy scan chunks, history merge). */
+    /** Re-render hook for async list updates (fuzzy scan completion, history merge). */
     onRequestRender?: () => void;
     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. */
@@ -129,7 +129,11 @@ export interface SessionSelectorOptions<T extends SessionSelectorEntry = Session
     title?: string;
     /** Fixed scope label, or false to omit the scope suffix. */
     scopeLabel?: string | false;
-    /** Show each session's working directory in the list. */
+    /**
+     * Show each session's working directory in the list. Defaults to on when
+     * the session files live in more than one directory (e.g. the folder scope
+     * merging a repository's worktrees).
+     */
     showCwd?: boolean;
     /**
      * Reads the live terminal height so the visible window fits the viewport.

package/dist/types/overlays/settings-defs.d.ts

@@ -43,6 +43,7 @@ export type AnyUiMetadata = UiBase & {
     options?: ReadonlyArray<SubmenuOption> | "runtime";
     secret?: boolean;
     ordered?: boolean;
+    editor?: "json";
 };
 /** Structural schema entries supplied by the application host. */
 export interface SettingsDisplayEntry {

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

@@ -1,4 +1,4 @@
-import type { Effort } from "@linxiraos/pi-ai";
+import { type ConfiguredThinkingLevel } from "../thinking.js";
 import { SelectList, type SgrMouseEvent } from "../index.js";
 import { OverlayPanel } from "../chrome/overlay-box.js";
 import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node.js";
@@ -7,7 +7,7 @@ import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node.
  */
 export declare class ThinkingSelectorComponent extends OverlayPanel {
     #private;
-    constructor(currentLevel: Effort, availableLevels: Effort[], onSelect: (level: Effort) => void, onCancel: () => void);
+    constructor(currentLevel: ConfiguredThinkingLevel | undefined, availableLevels: ConfiguredThinkingLevel[], onSelect: (level: ConfiguredThinkingLevel) => void, onCancel: () => void);
     describe(cx: DescribeContext): NativeNode | null;
     /** Picker pointer events drive the list exactly as its keys do. */
     handleNativeEvent(event: NativeUiEvent): void;

package/dist/types/overlays/usage-dashboard.d.ts

@@ -33,10 +33,12 @@ export interface ProviderCard {
     /** Number of represented accounts, including unavailable usage lookups. */
     accounts: number;
     unavailableAccounts: string[];
-    /** Window rows sorted most-pressing first. */
+    /** Window rows in provider-declared order (e.g. 5h → weekly → monthly); the fullest CARD_MAX_WINDOWS lead. */
     windows: CardWindowRow[];
-    /** True when every account reports no limits (e.g. enterprise plans). */
+    /** True when every account reports no limits (e.g. enterprise plans, providers without a quota API). */
     unlimited: boolean;
+    /** Distinct report notes across accounts (e.g. why a provider exposes no quota windows). */
+    notes: string[];
     /** True when nothing is used anywhere (or there are no limits): collapses to a tick. */
     idle: boolean;
     resetCredits?: {
@@ -52,8 +54,10 @@ export interface ProviderCard {
  * Collapse usage reports into one compact card per provider: limits grouped by
  * quota bucket (label + window), each bucket showing the mean used fraction
  * across accounts (matching the classic report's aggregate "% free") with the
- * most-used account's reset countdown. Cards sort most-pressing first so
- * what's burning is on top-left; fully idle providers collapse into a tick.
+ * most-used account's reset countdown. Rows keep the provider's declared window
+ * order so 5h → week → month reads the same every time; cards sort by their
+ * fullest window so what's burning is on top-left; fully idle providers
+ * collapse into a tick.
  */
 export declare function buildProviderCards(reports: UsageReport[], nowMs: number, unavailableAccounts?: readonly UnavailableUsageAccount[]): ProviderCard[];
 /** GitHub-style week-per-column heatmap grid derived from daily activity. */
@@ -121,12 +125,12 @@ export declare class UsageDashboardComponent implements Component {
      * The sheet body (the terminal's `lg` overlay is the frame): a head row
      * (checked ago, Overview/Details tabs, Refresh), then either the provider
      * grid of frames with window meters and the activity heatmap, or the
-     * per-provider detail tables. `meter`/`chart` fall back to
-     * `progress`/`table` on terminals without them. Rebuilt only when its
-     * inputs change.
+     * per-provider detail tables, then Close like the other report sheets.
+     * `meter`/`chart` fall back to `progress`/`table` on terminals without
+     * them. Rebuilt only when its inputs change.
      */
     describe(cx: DescribeContext): NativeNode;
-    /** Tab clicks switch views like Enter/Esc; the Refresh button runs `r`. */
+    /** Tab clicks switch views like Enter/Esc; the Refresh button runs `r`; Close closes from either view. */
     handleNativeEvent(event: NativeUiEvent): void;
     handleInput(data: string): void;
 }

package/dist/types/overlays/usage-display.d.ts

@@ -1,4 +1,4 @@
-import type { UsageLimit, UsageReport, UsageResetCredits } from "@linxiraos/pi-ai";
+import type { UsageLimit, UsageReport, UsageResetCreditDetail, UsageResetCredits } from "@linxiraos/pi-ai";
 /** Include the usage tier in a limit title unless its label already names it. */
 export declare function formatLimitTitle(limit: UsageLimit): string;
 /** Human-readable quota scope for a normalized saved-reset window ID. */
@@ -10,6 +10,8 @@ export interface UsageResetSummary {
     soonestExpiry?: string;
     unavailableReason?: string;
 }
+/** Expiry (epoch ms) of a credit that still banks a reset, whether or not it can be spent now. */
+export declare function bankedResetCreditExpiryMs(credit: UsageResetCreditDetail): number | undefined;
 /**
  * Normalize old count-only and current provider reset metadata for display.
  * `availableCount` is banked inventory; `redeemableCount` is the subset that

package/dist/types/prompt/composer-cache.d.ts

@@ -1,4 +1,3 @@
-import type { LspServerInfo, RecentSession } from "./welcome.js";
 import type { ComposerPreferences, ComposerStatusCache } from "./composer.js";
 import type { SymbolPreset } from "../theme/theme.js";
 /** Theme inputs cached from the last resolved settings load for stable prepaint colors. */
@@ -8,19 +7,10 @@ export interface ComposerThemePreferences {
     readonly darkTheme?: string;
     readonly lightTheme?: string;
 }
-/** Last authoritative model labels shown in the welcome component. */
-export interface ComposerWelcomeCache {
-    readonly modelName: string;
-    readonly providerName: string;
-}
 /** Speculative composer state read before the settings/session graph is available. */
 export interface ComposerStartupCache {
     readonly preferences?: ComposerPreferences;
     readonly theme?: ComposerThemePreferences;
-    readonly welcome?: ComposerWelcomeCache;
-    readonly recentSessions: RecentSession[];
-    /** `null` when the last run had LSP disabled. */
-    readonly lspServers: LspServerInfo[] | null;
     readonly status?: ComposerStatusCache;
 }
 /**
@@ -43,12 +33,6 @@ export declare class ComposerCache {
     read(cwd: string): ComposerStartupCache;
     /** Resolved theme and composer settings for the next prepaint. */
     writeUi(cwd: string, preferences: ComposerPreferences, theme: ComposerThemePreferences): void;
-    /** Authoritative model/provider labels for the next welcome prepaint. */
-    writeWelcome(cwd: string, welcome: ComposerWelcomeCache): void;
-    /** The latest recent-session rows (first four). */
-    writeRecentSessions(cwd: string, sessions: readonly RecentSession[]): void;
-    /** The latest detected project LSP rows; `null` records that LSP is disabled. */
-    writeLspServers(cwd: string, servers: readonly LspServerInfo[] | null): void;
     /** Status-bar inputs for the next prepaint's startup status line. */
     writeStatus(cwd: string, status: ComposerStatusCache): void;
     close(): void;