@linxiraos/pi-tui 1.1.27 → 1.2.0

package/dist/types/multiplexers/types.d.ts

@@ -0,0 +1,100 @@
+import type { TerminalNotification } from "../terminal-capabilities.js";
+/**
+ * Classification tier. `session` markers outrank the TERM fallback; `outerApp`
+ * hosts rank below it so a multiplexer nested inside them still wins.
+ */
+export type TerminalMultiplexerPrecedence = "session" | "outerApp";
+/**
+ * Notification delivery tier, tried in this order so the innermost target wins:
+ * a `pane` notifier addresses the exact pane through the multiplexer's CLI, a
+ * `surface` notifier addresses the containing app surface, and an `inBand`
+ * notifier rewrites the terminal's own notification sequence.
+ */
+export type TerminalMultiplexerNotificationTier = "pane" | "surface" | "inBand";
+/** One notification offered to a multiplexer notifier. */
+export interface TerminalMultiplexerNotificationRequest {
+    readonly message: string | TerminalNotification;
+    readonly env: NodeJS.ProcessEnv;
+    /** The host terminal's formatted OSC notification, or `null` when it notifies with a bare BEL. */
+    readonly sequence: string | null;
+    /** Write a sequence through the active terminal. */
+    write(data: string): void;
+}
+export interface TerminalMultiplexerNotifier {
+    readonly tier: TerminalMultiplexerNotificationTier;
+    /** Deliver the notification. `false` leaves it to the next notifier and then the terminal fallback. */
+    send(request: TerminalMultiplexerNotificationRequest): boolean;
+}
+/**
+ * OSC 8 handling inside a multiplexer session:
+ * - `render`: the multiplexer draws and opens links itself, so links work
+ *   whatever the outer terminal supports, unless another session with a
+ *   hyperlink policy sits in the path.
+ * - `drop`: never forwards OSC 8; its session anywhere in the path disables links.
+ * - `forward`: forwards OSC 8 once it self-reports (`TERM_PROGRAM`/`TERM_PROGRAM_VERSION`)
+ *   at least `major.minor`; older or unreported versions stay off.
+ */
+export type TerminalMultiplexerHyperlinks = "render" | "drop" | {
+    readonly forward: {
+        /** Lowercase `TERM_PROGRAM` the multiplexer sets inside its panes. */
+        readonly termProgram: string;
+        readonly major: number;
+        readonly minor: number;
+    };
+};
+/** A multiplexer that answers OSC 11 from a cached copy of the outer terminal's background color. */
+export interface TerminalMultiplexerBackgroundColorCache {
+    /** Wrap a query so it reaches the outer terminal and refreshes the cache. */
+    passthrough(query: string): string;
+    /** How long the multiplexer needs to store the outer reply before the cache is re-read. */
+    readonly settleMs: number;
+}
+/** Everything omp needs to recognize one terminal multiplexer and adapt to it. */
+export interface TerminalMultiplexerModule<Id extends string = string> {
+    readonly id: Id;
+    readonly precedence: TerminalMultiplexerPrecedence;
+    /** Every environment variable `isInside()` reads. */
+    readonly sessionEnvKeys: readonly string[];
+    /** Lowercase TERM prefix that identifies the multiplexer when its session markers were stripped. */
+    readonly termPrefix?: string;
+    /**
+     * Whether the multiplexer owns the screen grid. When true, rendering takes the
+     * multiplexer path (no scrollback rebuild, anchored resize, skipped probes).
+     */
+    readonly ownsScreenGrid: boolean;
+    isInside(env?: NodeJS.ProcessEnv): boolean;
+    /** Routes notifications the multiplexer would otherwise swallow. */
+    readonly notifier?: TerminalMultiplexerNotifier;
+    /** OSC 8 policy inside a session; unset defers to the outer terminal. */
+    readonly hyperlinks?: TerminalMultiplexerHyperlinks;
+    /**
+     * The pane's VTE honors DEC 2026 even when DECRQM is unanswered or reports
+     * the mode unrecognized (status 0): synchronized output starts on inside a
+     * session, and an unrecognized report does not turn it off.
+     */
+    readonly honorsSynchronizedOutput?: boolean;
+    /**
+     * The session does not reveal whether its client renders graphics while
+     * outer-terminal identity variables leak in, so images and Kitty
+     * placeholders stay off unless the user forces them.
+     */
+    readonly imagesRequireOverride?: boolean;
+    /** Platforms where the multiplexer breaks OSC 11 passthrough, so host appearance is used instead. */
+    readonly backgroundQueryBrokenOn?: readonly NodeJS.Platform[];
+    /** Present when OSC 11 replies come from a cache an explicit refresh must update first. */
+    readonly backgroundColorCache?: TerminalMultiplexerBackgroundColorCache;
+    /** Expands REP into identical styled cells, so destructive replays REP-encode their padding. */
+    readonly expandsRepPadding?: boolean;
+    /** Expires a synchronized update after a deadline, so large rebuild replays renew DEC 2026 as they stream. */
+    readonly expiresSynchronizedOutput?: boolean;
+    /**
+     * Restoring the alternate buffer schedules a redraw that ends a synchronized
+     * update early, so a synchronized resize rebuild stays on the main buffer.
+     */
+    readonly altRestoreEndsSynchronizedOutput?: boolean;
+    /**
+     * May grow its grid before SIGWINCH reaches the app, so a rebuild-mode grow
+     * whose full viewport no longer reaches the bottom replays history.
+     */
+    readonly growsBeforeSigwinch?: boolean;
+}

package/dist/types/multiplexers/wmux.d.ts

@@ -0,0 +1,12 @@
+/**
+ * wmux is a Windows multiplexer (Electron + xterm.js) modeled on cmux/herdr that
+ * repaints its pane in place. WMUX_CLI / WMUX_PIPE are CLI path overrides and can
+ * be set outside a wmux terminal.
+ */
+export declare const wmuxMultiplexer: {
+    readonly id: "wmux";
+    readonly precedence: "session";
+    readonly sessionEnvKeys: readonly ["WMUX", "WMUX_SURFACE_ID"];
+    readonly ownsScreenGrid: true;
+    readonly isInside: (env?: NodeJS.ProcessEnv) => boolean;
+};

package/dist/types/multiplexers/zellij.d.ts

@@ -0,0 +1,12 @@
+export declare const zellijMultiplexer: {
+    readonly id: "zellij";
+    readonly precedence: "session";
+    readonly sessionEnvKeys: readonly ["ZELLIJ"];
+    readonly ownsScreenGrid: true;
+    readonly isInside: (env?: NodeJS.ProcessEnv) => boolean;
+    readonly notifier: {
+        readonly tier: "inBand";
+        readonly send: ({ sequence, write }: import("./types.js").TerminalMultiplexerNotificationRequest) => boolean;
+    };
+    readonly backgroundQueryBrokenOn: readonly ["darwin"];
+};

package/dist/types/native/backend.d.ts

@@ -48,8 +48,9 @@ export interface NativeBackendOptions {
 /**
  * The reply a v1 terminal is assumed to give before its real `hello` arrives
  * (the `TERM_PROGRAM=tern` optimistic start): the whole vocabulary, the
- * default APC limit and credits, the terminal's width, the appearance zeta
- * already detected, and full motion.
+ * default APC limit and credits, the terminal's width, the appearance omp
+ * already detected, full motion, and `blobs`, so a resumed session's images
+ * are asked about rather than resent before the reply comes.
  */
 export declare function assumedTspHello(terminal: Terminal): TspHello;
 export declare class NativeBackend {

package/dist/types/native/blobs.d.ts

@@ -2,8 +2,10 @@
  * Content-addressed binary blobs (images) for `image` nodes.
  *
  * `describe()` registers the bytes and puts the returned id in `image.p.blob`;
- * the native backend uploads each referenced blob once per surface with verb
- * `b` before the frame that first references it.
+ * the native backend delivers each referenced blob once per terminal
+ * connection (asking the terminal first which it holds, or through its blob
+ * cache), else uploads it with verb `b` before the frame that first
+ * references it.
  */
 import type { TspProps } from "@linxiraos/pi-wire";
 import type { NativeNode } from "./node.js";
@@ -12,10 +14,12 @@ export interface NativeBlob {
     readonly mime: string;
     readonly bytes: Uint8Array;
 }
-/** Register `bytes` and return their content address (sha256 hex) for `image.p.blob`. */
+/** Register bytes for process-lifetime, id-only use. Prefer {@link nativeImageNode} for owned images. */
 export declare function registerNativeBlob(bytes: Uint8Array, mime: string): string;
 /** A registered blob by id. */
 export declare function getNativeBlob(id: string): NativeBlob | undefined;
+/** An image whose props own its bytes, including while hidden, unmounted, or awaiting upload. */
+export declare function nativeImageNode(bytes: Uint8Array, mime: string, p?: Omit<TspProps<"image">, "blob" | "builtin">, key?: string): NativeNode;
 /**
  * An `image` node for a base64 payload: the bytes are registered as a blob and
  * the pixel size probed from the header. Decoding and hashing cost real time,

package/dist/types/native/encode.d.ts

@@ -15,11 +15,10 @@ export type TspIncoming = {
 };
 /** Message parameters (`k=v`, ASCII, never containing `;`). */
 export type TspParams = Readonly<Record<string, string | number>>;
-/** Split `body` into pieces of at most `limit` UTF-8 bytes, never inside a code point. */
-export declare function splitUtf8(body: string, limit: number): string[];
 /**
- * Encode one logical message, chunked when `body` exceeds `limit` UTF-8 bytes.
- * Returns the complete byte string to write (all chunks, in order).
+ * Encode one logical message, chunked when `body` exceeds `limit` UTF-8 bytes:
+ * the first chunk carries `params`, every chunk `c=<id>` and all but the last
+ * `m=1`. Returns the complete byte string to write (all chunks, in order).
  */
 export declare function encodeTspMessage(verb: TspVerb, body: string, params?: TspParams, limit?: number): string;
 /** Encode a JSON message body. */

package/dist/types/native/overlay.d.ts

@@ -58,6 +58,11 @@ export interface ActionButtonOptions {
  * which the component routes to the same code path as the key.
  */
 export declare function actionButton(label: string, act: string, options?: ActionButtonOptions): NativeNode;
+/**
+ * A bare `esc` keycap button for a view's top-right corner: a click sends
+ * `act` (default `close`), which the component routes to its Esc path.
+ */
+export declare function escCloseButton(act?: string, key?: string): NativeNode;
 /** A row of {@link actionButton}s (role `zeta.actions`); `null` entries become the spacer that end-aligns what follows. */
 export declare function actionBar(buttons: readonly (NativeNode | null)[], key?: string): NativeNode;
 /** Spans of an annotation callout: a dim `label:` then the note. */

package/dist/types/overlays/agent-hub-projection.d.ts

@@ -15,11 +15,12 @@ interface AgentTreeProjection<TRecord extends AgentRecordLike> {
 export declare const STATUS_ORDER: Record<AgentStatus, number>;
 /** Exact observer usage for one roster entry. */
 export declare function progressMetrics(observed: ObservableSession | undefined): AgentMetrics | undefined;
-/** Live session whose own messages back a row's metrics when no observer progress exists. */
+/** Live session used to cache a row's direct assistant usage, including with observer progress. */
 export declare function hubFallbackStatsSession<TRecord extends AgentRecordLike>(ref: TRecord, observed: ObservableSession | undefined): NonNullable<TRecord["session"]> | undefined;
 /**
- * One roster row's usage: live observer progress, then persisted history, then
- * the cached fallback read of a live session (populated by {@link aggregateMetrics}).
+ * Preserve progress/history for non-cost metrics, overlaying cumulative direct-session cost.
+ * Persisted `history.metrics.cost` is a leaf-scoped snapshot, so it never overrides live
+ * progress; only the cumulative direct-cost sources do.
  */
 export declare function hubRowMetrics<TRecord extends AgentRecordLike>(ref: TRecord, observed: ObservableSession | undefined, sessionMetrics: WeakMap<object, {
     metrics: AgentMetrics | undefined;
@@ -37,6 +38,6 @@ export declare function aggregateMetrics<TRecord extends AgentRecordLike>(args:
     metrics: AggregateMetrics;
     hasFallbackLiveSessions: boolean;
 };
-/** Parent-before-child projection preserving the roster's stable sibling order. */
-export declare function projectAgentTree<TRecord extends AgentRecordLike>(refs: readonly TRecord[]): AgentTreeProjection<TRecord>;
+/** Parent-before-child projection preserving initial subtree rank and prepending new siblings. */
+export declare function projectAgentTree<TRecord extends AgentRecordLike>(refs: readonly TRecord[], rosterRank: ReadonlyMap<TRecord, number> | undefined): AgentTreeProjection<TRecord>;
 export {};

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

@@ -28,6 +28,13 @@ export interface AgentHubSession {
             messages: AgentMessage[];
         };
     };
+    /** Existing session ledger includes off-transcript model usage and nested-task attribution. */
+    readonly sessionManager?: {
+        getUsageStatistics(): {
+            cost: number;
+            subagentCost: number;
+        };
+    };
     getSessionStats(): {
         tokens: {
             input: number;
@@ -64,6 +71,8 @@ export interface AgentRecordLike {
         resolvedModel?: string;
         resolvedModelIsFallback?: boolean;
         metrics?: AgentMetricsSummary;
+        /** Cumulative own-session assistant and model_usage cost, excluding nested task results. */
+        directCost?: number;
         readOnly?: boolean;
         outputPath?: string;
         patchPath?: string;

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

@@ -114,6 +114,8 @@ export declare class AgentHubOverlayComponent<TRecord extends AgentRecordLike =
      * was raised by that gesture.
      */
     armCloseTap(): void;
+    /** Show `section`, as a slash-command deep link into an already-open hub does. */
+    showSection(section: AgentHubSection): void;
     /**
      * Open the fullscreen transcript viewer for an agent id (public for table Enter
      * and tests). Mounts {@link AgentTranscriptViewer} as a `fullscreen` overlay so it

package/dist/types/overlays/agent-transcript-viewer.d.ts

@@ -23,7 +23,7 @@ import type { AgentHubRegistry } from "./agent-hub-types.js";
 import type { SessionMessageEntryLike } from "../chat/transcript-entry.js";
 import type { SessionObserverRegistry } from "./session-observer-registry.js";
 import type { AgentHubRemote } from "./agent-hub.js";
-import type { DescribeContext, NativeNode } from "../native/node.js";
+import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node.js";
 /** Parsed message and model metadata relevant to a transcript viewer. */
 export type AgentTranscriptEntry = SessionMessageEntryLike | {
     type: "model_change";
@@ -31,7 +31,14 @@ export type AgentTranscriptEntry = SessionMessageEntryLike | {
 };
 /** Local filesystem and session parsing capabilities supplied by the host. */
 export interface AgentTranscriptSource {
-    fs: Pick<typeof fs, "openSync" | "closeSync" | "readSync" | "readFileSync" | "statSync">;
+    /**
+     * Sync primitives drive the first paint and the incremental tail. When the
+     * host also supplies `promises.readFile` (e.g. passes `node:fs` itself), full
+     * reloads after rotation/rewrite read the file off the UI thread.
+     */
+    fs: Pick<typeof fs, "openSync" | "closeSync" | "readSync" | "readFileSync" | "statSync"> & {
+        promises?: Pick<typeof fs.promises, "readFile">;
+    };
     parseEntries(text: string): AgentTranscriptEntry[];
 }
 export interface AgentTranscriptViewerDeps {
@@ -70,6 +77,8 @@ export declare class AgentTranscriptViewer implements Component {
     dispose(): void;
     handleInput(data: string): void;
     render(width: number): readonly string[];
+    /** The top-right `esc` runs Esc. */
+    handleNativeEvent(event: NativeUiEvent): void;
     /**
      * Header, transcript body (the builder's container, which describes its own
      * blocks), notice, message editor, stats and key hints. Scrolling is the

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

@@ -60,6 +60,15 @@ export interface AgentsHubDeps {
 export interface AgentsHubCallbacks {
     onCancel: () => void;
 }
+/**
+ * Parse model output into a {@link GeneratedAgentSpec}. Accepts a bare JSON object
+ * (tried first) or one wrapped in a code fence. Returns the spec with trimmed fields.
+ * Throws if the output is not valid JSON or not an object, if `identifier`, `whenToUse`
+ * or `systemPrompt` is missing or not a string, if the identifier is not lowercase
+ * kebab-case with 2+ words, if `whenToUse` does not start with "Use this agent when",
+ * or if `systemPrompt` is empty.
+ */
+export declare function parseGeneratedAgentSpec(raw: string): GeneratedAgentSpec;
 /**
  * The fullscreen agents hub component. Hosted via
  * `ui.showOverlay(..., { fullscreen: true })`; the host must call

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/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/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

@@ -64,8 +64,31 @@ export interface ModelHubCallbacks {
     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/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";