@linxiraos/pi-tui 1.1.26 → 1.1.27

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,6 +56,12 @@ 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;
     onCancel: () => void;

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

@@ -121,12 +121,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/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;

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

@@ -6,7 +6,7 @@ import { type Component, type ResizeScrollbackMode, type TerminalFramePlan, type
 import type { NativeSurface, NativeSurfaceProvider } from "../native/node.js";
 import { CustomEditor } from "./custom-editor.js";
 import type { WordCompletionMethod } from "./word-completion.js";
-import { type LspServerInfo, type RecentSession, WelcomeComponent } from "./welcome.js";
+import { WelcomeComponent, type RecentSession, type LspServerInfo } from "./welcome.js";
 /** Live settings that affect the composer before and after session adoption. */
 export interface ComposerPreferences {
     readonly quiet: boolean;
@@ -122,6 +122,21 @@ export declare class Composer implements TerminalFrameProvider, NativeSurfacePro
     #private;
     readonly ui: TUI;
     constructor(options?: ComposerOptions);
+    /**
+     * Rows the below-transcript chrome under `root` (editor, status line, …)
+     * took in the last frame, so a root that grows upward can cap itself to
+     * the screen rows left above them; `undefined` before `root` was laid out.
+     */
+    rowsBelow(root: Component): number | undefined;
+    /**
+     * Keep the input on the bottom row while the live rows cannot fill the
+     * screen, as after an inline decision panel closes. A tall block that just
+     * left the chrome above the editor (a command report) may have scrolled
+     * rows into native history that cannot be pulled back; without the pin the
+     * editor would jump up to where the shorter frame now ends. The pin lifts
+     * once live rows fill the screen again.
+     */
+    pinInputToBottom(): void;
     /** Compose the bounded mutable viewport and the next ordered history append. */
     renderFrame(viewport: ViewportSize): TerminalFramePlan;
     /**
@@ -164,7 +179,7 @@ export declare class Composer implements TerminalFrameProvider, NativeSurfacePro
     enableInput(): void;
     /** Apply settings changes without replacing the editor or welcome component. */
     setPreferences(update: Partial<ComposerPreferences>): void;
-    /** Patch welcome data in place as model, session, and project discovery complete. */
+    /** Patch welcome data in place as version, session, and project discovery complete. */
     updateWelcome(update: ComposerWelcomeUpdate): void;
     /** Replace optional header content around the stable welcome scene. */
     setHeaderExtras(before: readonly Component[], after: readonly Component[]): void;

package/dist/types/prompt/custom-editor.d.ts

@@ -18,6 +18,10 @@ export interface ComposerNativeState {
     };
     /** Thinking effort word (`high`, `off`, `auto`); undefined when the model has no thinking. */
     readonly thinking?: string;
+    /** The thinking level draws as the model chip's icon instead of its own chip (where the terminal has `effort`). */
+    readonly thinkingInModel?: boolean;
+    /** Generation tok/s after the thinking level (live while running, else the last reading); undefined hides it. */
+    readonly rate?: number;
     /** A turn is running: the send keycap becomes a Stop button. */
     readonly running: boolean;
     /** The viewed subagent's lineage, outermost first and the viewed agent last; undefined on the main session. */
@@ -213,6 +217,8 @@ export declare class CustomEditor extends Editor {
      *  once after construction (and again after `setEditorComponent` swaps the
      *  editor). Passing `undefined` clears any pending frame. */
     setShimmerRepaintHandler(handler: (() => void) | undefined): void;
+    /** Editing is available during bootstrap; atomic sends wait until submission is wired and enabled. */
+    protected get nativeSendable(): boolean;
     /** Viewing a subagent, the draft goes to it: the placeholder names it. */
     describePlaceholder: () => string;
     /** A shell-mode draft highlights as its language. */
@@ -227,7 +233,8 @@ export declare class CustomEditor extends Editor {
      * The TSP composer: role `zeta.editor[.bash|.python]` (tone `pending` while
      * a turn runs) over the context hairline, the viewing header while a
      * subagent is focused, the attachment chips, a `line` row of the
-     * shell-mode chip and the input, and the `bar`: model chip, effort chip,
+     * shell-mode chip and the input, and the `bar`: model chip, effort chip
+     * (or the effort glyph as the model chip's icon), the generation rate,
      * the other status facts, usage, then send (Stop while a turn runs).
      * Clicks come back as `status.model`, `thinking.cycle`, `submit`,
      * `interrupt` and `focus:<id>` actions.
@@ -237,7 +244,8 @@ export declare class CustomEditor extends Editor {
      * Clicks on the composer's controls take the same paths as their keys: ⇧⇥,
      * ⏎ and Esc; the viewing header's links (`focus:<id>`) go to the host,
      * the status facts' clicks (`status.*`) to their source. Selection edits
-     * go to the buffer.
+     * go to the buffer; `send` submits its own prompt after saving the old draft
+     * for recall and waiting for in-flight clipboard work.
      */
     handleNativeEvent(event: NativeUiEvent): void;
     onEscape?: () => void;
@@ -268,9 +276,9 @@ export declare class CustomEditor extends Editor {
     onLeftAtStart?: () => void;
     /** Called when the viewing header asks to view agent `id` ({@link MAIN_AGENT_ID}: the main session). */
     onFocusAgent?: (id: string) => void;
-    /** Space-bar push-to-talk; set its `handler` to enable it. It is a text-composition gesture, so it
-     *  stays out of Vim's Normal/Visual modes (where the space bar is the `l` motion) and away from an
-     *  open autocomplete menu. */
+    /** Configurable push-to-talk; set its `handler` to enable it. It is a text-composition gesture, so
+     *  it stays out of Vim's Normal/Visual modes (where the space bar is the `l` motion), away from an
+     *  open autocomplete menu, and out of a pending character jump (whose target may be the key). */
     readonly spaceHold: SpaceHoldGesture;
     setActionKeys(action: ConfigurableEditorAction, keys: KeyId[]): void;
     /**
@@ -285,6 +293,7 @@ export declare class CustomEditor extends Editor {
      * Clear all custom key handlers.
      */
     clearCustomKeyHandlers(): void;
+    capturesInput(data: string): boolean;
     handleInput(data: string): void;
     /**
      * Route a keystroke through the base text-editor pipeline only, skipping the

package/dist/types/prompt/interactive-context-helpers.d.ts

@@ -15,6 +15,7 @@ export interface AssistantMessageHost {
     readonly viewSession: AssistantMessageSession;
     readonly effectiveHideThinkingBlock: boolean;
     readonly proseOnlyThinking: boolean;
+    readonly expandThinkingBlocks: boolean;
     readonly assistantImagesVisible: boolean;
     readonly hideToolActivity: boolean;
     readonly toolOutputExpanded: boolean;

package/dist/types/prompt/welcome.d.ts

@@ -37,7 +37,7 @@ export declare class WelcomeComponent implements Component {
     private recentSessions;
     /** Detected project servers; `null` means LSP is disabled and hides the section. */
     private lspServers;
-    constructor(version: string, modelName: string, providerName: string, recentSessions?: RecentSession[], 
+    constructor(version: string, modelName?: string, providerName?: string, recentSessions?: RecentSession[], 
     /** Detected project servers; `null` means LSP is disabled and hides the section. */
     lspServers?: LspServerInfo[] | null);
     get tip(): string | undefined;

package/dist/types/space-hold.d.ts

@@ -1,45 +1,60 @@
-/** Max gap (ms) between two spaces for the later one to count as OS key auto-repeat rather than a
- *  deliberate press. OS auto-repeat is fast; a deliberate tap (even a fast one) is slower. */
+import { type KeyId } from "./keys.js";
+/** Printable text a push-to-talk candidate key types (plain or shifted single characters and Space),
+ *  or undefined for non-printable keys and chords, which the gesture reserves instead of typing. */
+export declare function getSpaceHoldText(data: string, canonical: string | undefined): string | undefined;
+/** Max gap (ms) between two configured-key presses for a later one to count as OS key auto-repeat
+ *  rather than a deliberate press. OS auto-repeat is fast; a deliberate tap (even a fast one) is slower. */
 export declare const SPACE_REPEAT_MAX_GAP_MS = 120;
-/** Two consecutive inter-space gaps are "mechanical" (machine-driven auto-repeat) when both are
+/** Two consecutive inter-key gaps are "mechanical" (machine-driven auto-repeat) when both are
  *  within {@link SPACE_REPEAT_MAX_GAP_MS} and differ by no more than this — an absolute jitter floor
  *  or, for slower repeat rates, {@link SPACE_REPEAT_JITTER_RATIO} of the smaller gap. OS key-repeat
- *  is metronomic; a human smashing the bar is fast but irregular, so its deltas never stay this
- *  steady. */
+ *  is metronomic; human typing is irregular, so its deltas do not stay this steady. */
 export declare const SPACE_REPEAT_JITTER_MS = 18;
 export declare const SPACE_REPEAT_JITTER_RATIO = 0.35;
-/** Consecutive mechanical (fast + steady) deltas that confirm the space bar is held and start
- *  recording. Needs a sustained metronomic cadence, so jittery smashing and deliberate taps never
+/** Consecutive mechanical (fast + steady) deltas that confirm a configured key is held and start
+ *  recording. Needs a sustained metronomic cadence, so jittery typing and deliberate taps never
  *  reach it. */
 export declare const SPACE_HOLD_MECHANICAL_RUN = 2;
-/** Idle gap (ms) after the last repeated space that counts as the space bar being released, ending
- *  the push-to-talk recording. Must comfortably exceed the OS key-repeat interval. */
+/** Idle gap (ms) after the last repeated configured-key press that counts as release and ends
+ *  push-to-talk. Must comfortably exceed the OS key-repeat interval. */
 export declare const SPACE_HOLD_RELEASE_MS = 250;
-/** What a recognized space-bar hold drives — the push-to-talk start and stop. */
+/** A release timer firing more than this (ms) past its deadline means the event loop stalled (a
+ *  synchronous microphone open, GC, a heavy render) while the bar may still be held: the repeats
+ *  emitted during the stall are queued but unread, so the stall must not read as a release. */
+export declare const SPACE_HOLD_STALL_SLACK_MS = 100;
+/** What a recognized push-to-talk hold drives — the start and stop callbacks. */
 export interface SpaceHoldHandler {
-    /** Gate for the gesture. Returns false to keep the space bar inserting spaces normally, so
-     *  disabling push-to-talk restores plain space behavior. */
+    /** Gate for the gesture. Returns false to let matching keys behave normally. */
     enabled(): boolean;
-    /** A sustained hold was recognized. The optimistically-typed spaces have already been deleted. */
+    /** A sustained hold was recognized; any safely typed candidate text has already been deleted. */
     onStart(): void;
-    /** The held space bar was released (an idle gap with no further repeated spaces, or any other key). */
+    /** The held key was released (an idle gap with no further repeats, or any other key). */
     onEnd(): void;
 }
 /** What the host must do with a keypress after {@link SpaceHoldGesture.process} has seen it:
- *  `"pass"` — handle it normally; `"type"` — insert the space now (it is tracked back out if the run
- *  turns into a hold); `"swallow"` — drop it, the gesture consumed it. */
+ *  `"pass"` — handle it normally; `"type"` — insert its safely decoded printable text now (it is
+ *  tracked back out if the run turns into a hold); `"swallow"` — drop it, the gesture consumed it. */
 export type SpaceHoldStep = "pass" | "type" | "swallow";
-/** Space-hold push-to-talk state machine. A held space bar emits OS auto-repeat: a *steady* stream
- *  of spaces at a fixed fast interval. We watch the inter-space deltas and only recognize a hold once
- *  {@link SPACE_HOLD_MECHANICAL_RUN} consecutive deltas are "mechanical" — both auto-repeat-fast and
- *  near-identical (see {@link gapsAreMechanical}). Smashing the bar is fast but jittery and deliberate
- *  taps are too slow, so neither escalates and both keep typing real spaces; the few spaces typed
- *  before a real hold is recognized are tracked back out of the host input. */
+/** Push-to-talk key-hold state machine. A held key emits OS auto-repeat at a steady fast interval.
+ *  We watch inter-key deltas and only recognize a hold once {@link SPACE_HOLD_MECHANICAL_RUN}
+ *  consecutive deltas are mechanical (see {@link gapsAreMechanical}). Deliberate taps and jittery
+ *  runs stay typed; only text typed during the current steady run is removed on recognition. */
 export declare class SpaceHoldGesture {
     #private;
-    /** Unset (the default) keeps the space bar typing spaces. */
+    /** Configured alternative keys. Alternatives are tracked independently and never combine into one run. */
+    get keys(): readonly KeyId[];
+    set keys(keys: readonly KeyId[]);
+    /** Unset (the default) keeps configured keys behaving normally. */
     handler: SpaceHoldHandler | undefined;
     constructor(deleteTyped: (count: number) => void, allowed?: () => boolean);
-    /** Feed one keypress, `isSpace` when it is a plain space bar press. */
-    process(isSpace: boolean): SpaceHoldStep;
+    /** Pure focused-owner preflight on raw input: whether the key must reach the host before
+     *  TUI-wide input listeners. Only non-printable bindings are claimed — they would otherwise
+     *  trigger app shortcuts mid-hold; printable candidates keep the normal listener path so
+     *  raw-input observers (e.g. extensions) still see typed text, as they did before remapping. */
+    shouldRoute(data: string): boolean;
+    /** Feed one canonical keypress and, when safely printable, its decoded text length. The host
+     *  records the actual inserted length with {@link recordTyped} after applying normal typing. */
+    process(key: string | undefined, insertedCharacterLength?: number): SpaceHoldStep;
+    /** Account for text the host actually inserted for the preceding `"type"` step. */
+    recordTyped(insertedCharacterLength: number): void;
 }

package/dist/types/status-line/context-usage.d.ts

@@ -3,6 +3,7 @@ import type { CompactionSettings } from "@linxiraos/pi-agent-core/compaction";
 import type { Tool as AiTool, Model } from "@linxiraos/pi-ai";
 import type { Theme } from "../theme/index.js";
 import { Container } from "../tui.js";
+import type { TspText } from "@linxiraos/pi-wire";
 import type { DescribeContext, NativeNode } from "../native/node.js";
 interface ContextSkill {
     readonly name: string;
@@ -154,6 +155,8 @@ export declare function computeNonMessageBreakdown(session: NonMessageTokenSourc
  * session and model.
  */
 export declare function computeContextBreakdown(session: ContextUsageSession, options: ContextUsageOptions): ContextBreakdown;
+/** The `/context` title: the model and its window once a model is selected. */
+export declare function contextUsageHead(breakdown: ContextBreakdown): TspText;
 /**
  * Native context-usage panel for terminals without `meter`: the cell grid as
  * unwrapped styled rows beside the legend. The terminal places the legend
@@ -161,15 +164,14 @@ export declare function computeContextBreakdown(session: ContextUsageSession, op
  */
 export declare function describeContextUsage(breakdown: ContextBreakdown): NativeNode;
 /**
- * The `/context` transcript block: ANSI renders the titled cell grid between
- * rules; natively it is one frame, drawn with `meter`s where the terminal
- * has them and as the glyph grid otherwise.
+ * The `/context` report body, without a frame or title of its own (the panel
+ * showing it is titled {@link contextUsageHead}): ANSI renders the cell grid
+ * beside the legend; natively it is drawn with `meter`s where the terminal has
+ * them and as the glyph grid otherwise.
  */
 export declare class ContextUsageView extends Container {
     #private;
     constructor(breakdown: ContextBreakdown, theme: Theme);
-    /** Replace the shown breakdown in place, refreshing both the ANSI and native views. */
-    setBreakdown(breakdown: ContextBreakdown): void;
     describe(cx: DescribeContext): NativeNode;
 }
 /**

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

@@ -11,7 +11,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" | "base" | "trueColor";
+export type TerminalId = "kitty" | "ghostty" | "wezterm" | "iterm2" | "vscode" | "alacritty" | "warp" | "orca" | "otty" | "rio" | "tern" | "monstar" | "base" | "trueColor";
 /** Terminal capability details used for rendering and protocol selection. */
 export declare class TerminalInfo {
     readonly id: TerminalId;
@@ -296,6 +296,13 @@ export interface ImageRenderOptions {
     placementId?: number;
     /** When true (Kitty + {@link imageId}), also return the one-time transmit sequence. */
     includeTransmit?: boolean;
+    /**
+     * SIXEL sequence for the target pixel size renderImage computes, so the
+     * caller can encode off the JS thread: answer `undefined` while the encode
+     * is pending (the image's rows stay reserved) and `null` once it failed.
+     * Without a provider, renderImage encodes synchronously.
+     */
+    sixel?: (widthPx: number, heightPx: number) => string | null | undefined;
 }
 export declare function getCellDimensions(): CellDimensions;
 export declare function setCellDimensions(dims: CellDimensions): void;
@@ -393,6 +400,12 @@ export declare function getJpegDimensions(base64Data: string): ImageDimensions |
 export declare function getGifDimensions(base64Data: string): ImageDimensions | null;
 export declare function getWebpDimensions(base64Data: string): ImageDimensions | null;
 export declare function getImageDimensions(base64Data: string, mimeType: string): ImageDimensions | null;
+/**
+ * SIXEL sequence for `base64Data` at the given pixel size, encoded on the JS
+ * thread; `null` when the encode fails. For output that cannot wait for an
+ * off-thread encode.
+ */
+export declare function encodeSixelNow(base64Data: string, widthPx: number, heightPx: number): string | null;
 export declare function renderImage(base64Data: string, imageDimensions: ImageDimensions, options?: ImageRenderOptions): {
     sequence?: string;
     lines?: string[];

package/dist/types/terminal.d.ts

@@ -1,4 +1,5 @@
 import { type TspHello } from "./native/encode.js";
+export { writeTerminalSequence, writeThroughActiveTerminal } from "./active-terminal.js";
 /**
  * Split `data` into chunks whose encoded UTF-8 byte length is no greater than
  * `maxChunkBytes`, preferring a line boundary (`\n`) as the cut point so
@@ -69,16 +70,6 @@ export declare class StdoutStallWatchdog {
 }
 /** Record alternate-screen state (called by the TUI on `?1049h`/`?1049l` writes). */
 export declare function setAltScreenActive(active: boolean): void;
-/**
- * Route an out-of-band escape sequence (e.g. an OSC title update) through the
- * active terminal's output path. While a TUI owns stdout, frame paints go
- * through the off-thread write pump and can split across multiple write(2)
- * calls; a direct main-thread `process.stdout.write` can land between two of
- * them — mid escape sequence — and the host terminal then prints the payload
- * as literal text at the cursor position. Returns false when no terminal has
- * started, in which case the caller owns stdout and may write directly.
- */
-export declare function writeThroughActiveTerminal(data: string): boolean;
 /**
  * Emergency terminal restore - call this from signal/crash handlers
  * Resets terminal state without requiring access to the ProcessTerminal instance

package/dist/types/thinking.d.ts

@@ -4,7 +4,7 @@ import { ThinkingLevel } from "@linxiraos/pi-agent-core/thinking";
 import { Effort } from "@linxiraos/pi-catalog/effort";
 import type { Model } from "@linxiraos/pi-catalog/types";
 /** Thinking selectors accepted by CLI inputs, in display order. */
-export declare const CLI_THINKING_LEVELS: readonly string[];
+export declare const CLI_THINKING_LEVELS: readonly ConfiguredThinkingLevel[];
 /**
  * Metadata used to render thinking selector values in the coding-agent UI.
  */

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

@@ -4,8 +4,13 @@ import { type OutputMeta } from "./output-meta.js";
 import type { NativeToolView, RenderResultContextOptions, RenderResultOptions } from "./renderer.js";
 /** Default collapsed shell output preview height. */
 export declare const BASH_DEFAULT_PREVIEW_LINES = 10;
-/** LLM-facing footer appended when a tool call becomes a background job. */
-export declare function formatBackgroundNotice(jobId: string): string;
+/**
+ * LLM-facing footer appended when a tool call becomes a background job. It states the job's kill
+ * deadline (`timeoutSec`, `undefined` when disabled) so the model knows the job will die at it before
+ * it waits on the result. The deadline counts the job's whole run time, not time left from now: an
+ * auto-backgrounded call has already spent its foreground wait.
+ */
+export declare function formatBackgroundNotice(jobId: string, timeoutSec: number | undefined): string;
 /** Shell execution metadata used by transcript rendering. */
 export interface BashToolDetails {
     meta?: OutputMeta;

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

@@ -1,10 +1,9 @@
 import type { Usage } from "@linxiraos/pi-ai";
 import type { ThemeColor } from "../theme/theme.js";
 import type { ConfiguredThinkingLevel } from "../render/render-utils.js";
+import type { RenderResultOptions, NativeToolView, ToolRenderResult } from "./renderer.js";
 import { type Component } from "../tui.js";
-import type { RenderResultOptions } from "./renderer.js";
 import { type Theme } from "../theme/theme.js";
-import type { NativeToolView, ToolRenderResult } from "./renderer.js";
 /** Render context threaded in from `ToolExecutionComponent.#buildRenderContext`. */
 interface TaskRenderContext {
     hasResult?: boolean;
@@ -108,6 +107,8 @@ export interface TaskItem {
     solutionSpace?: string;
     /** Per-spawn thinking effort: lowest/middle/highest level the resolved model supports. Overrides the agent's default selector (e.g. `auto`). */
     effort?: "lo" | "med" | "hi";
+    /** Per-spawn model selector or ordered selector array; overrides agent and settings preferences. */
+    model?: string | string[];
     /** Caller-provided output schema; its presence overrides the selected agent's schema. */
     outputSchema?: unknown;
     /** Validation behavior for a caller-provided or inherited output schema. */
@@ -134,6 +135,8 @@ export interface TaskParams {
     solutionSpace?: string;
     /** Per-spawn thinking effort (flat form): lowest/middle/highest level the resolved model supports. */
     effort?: "lo" | "med" | "hi";
+    /** Per-spawn model selector or ordered selector array; overrides agent and settings preferences. */
+    model?: string | string[];
     /** Caller-provided output schema; its presence overrides the selected agent's schema. */
     outputSchema?: unknown;
     /** Validation behavior for a caller-provided or inherited output schema. */
@@ -255,7 +258,7 @@ export interface AgentProgress {
     resolvedModelRoute?: string;
     /** True when a live advisor was attached to this run's session, not merely enabled in settings. */
     advisor?: boolean;
-    /** The agent's latest self-estimate of task completion (0–100), from the periodic `task.completionProbeMs` side request. */
+    /** The agent's latest self-estimate of task completion (0–100), from the periodic `task.completionProbe` side request. */
     completionPercent?: number;
     /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
     extractedToolData?: Record<string, unknown[]>;

package/dist/types/tui.d.ts

@@ -150,6 +150,11 @@ export interface Component {
     describeScreen?(cx: DescribeContext): NativeScreen;
     /** User actions on nodes this component described (toggle, select, activate, custom). */
     handleNativeEvent?(event: NativeUiEvent): void;
+    /**
+     * Pure preflight for focused input that must precede TUI-wide input listeners
+     * and debug shortcuts. A true result routes the event to this component first.
+     */
+    capturesInput?(data: string): boolean;
     /**
      * Optional handler for keyboard input when component has focus
      */

package/dist/types/windows-input-mode.d.ts

@@ -16,10 +16,26 @@
  * terminal sends; chords legacy encoding loses (modified Enter/Tab/Escape,
  * Ctrl+Shift+letter, …) translate to kitty CSI-u, which key matching already
  * parses.
+ *
+ * A host terminal that writes VT instead of key records (any ConPTY host
+ * besides Windows Terminal's native path) reaches us as one `Vk = 0` text
+ * record per byte: Alt+Up arrives as `ESC`, `[`, `1`, `;`, `3`, `A`. Those
+ * bytes are reassembled into the escape sequence they spell; delivering them
+ * one at a time turns every such key into a bare Escape plus typed garbage.
+ */
+/**
+ * Stateful decoder: joins UTF-16 surrogate halves that arrive as separate
+ * records, and reassembles VT escape sequences relayed as text records.
  */
-/** Stateful decoder: joins UTF-16 surrogate halves that arrive as separate records. */
 export declare class Win32InputModeDecoder {
     #private;
+    /** Whether relayed VT text is held waiting for the rest of its sequence. */
+    get hasPendingSequence(): boolean;
+    /**
+     * Release held VT text as-is. The caller invokes this once no further bytes
+     * arrived in time, so a lone relayed ESC still acts as the Escape key.
+     */
+    flushPendingSequence(): string[];
     /**
      * Translate one stdin sequence. Returns `undefined` when `data` is not a
      * win32-input-mode record (pass it through unchanged), otherwise the key
@@ -35,3 +51,19 @@ export declare class Win32InputModeDecoder {
      */
     decodePaste(content: string): string;
 }
+/**
+ * Restores paste delimiters that a Windows console host emitted as individual
+ * win32-input-mode key records before StdinBuffer searches for the delimiters.
+ * Non-matching records remain untouched for normal key and paste decoding.
+ */
+export declare class Win32PasteMarkerNormalizer {
+    #private;
+    /**
+     * `onExpired` runs after held records are released because their wait timed
+     * out, so a downstream holder can treat the same wait as already elapsed.
+     */
+    constructor(onInput: (data: string) => void, onExpired?: () => void);
+    process(data: string): void;
+    /** Release an incomplete marker as its original key records. */
+    flush(): void;
+}