@linxiraos/pi-tui 1.1.26 → 1.2.0

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;
@@ -47,7 +47,7 @@ export interface ComposerStatusCache {
 /** Optional dependencies and initial state for a standalone composer. */
 export interface ComposerOptions {
     readonly terminal?: Terminal;
-    /** Extra TUI construction options (render scheduler injection for tests and `zeta render`). */
+    /** Extra TUI construction options (render scheduler injection for tests and `zetacode render`). */
     readonly tuiOptions?: TUIOptions;
     readonly preferences?: Partial<ComposerPreferences>;
     readonly welcome?: ComposerWelcomeUpdate;
@@ -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

@@ -7,7 +7,7 @@ import type { AppKeybinding } from "../app-keybindings.js";
 import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node.js";
 import type { ComposerFactsSource } from "../status-line/types.js";
 import { type MacOSSpellingFeatures } from "./macos-spelling.js";
-import type { TspEditorDecoration } from "@linxiraos/pi-wire";
+import type { TspEditorDecoration, TspText } from "@linxiraos/pi-wire";
 import { type WordCompletionMethod } from "./word-completion.js";
 /** Live composer state the TSP layout shows; the interactive host wires {@link CustomEditor.composerState}. */
 export interface ComposerNativeState {
@@ -18,10 +18,16 @@ 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. */
     readonly viewing?: readonly string[];
+    /** The session's title, quoted in italics as the TSP placeholder; undefined until it has one. */
+    readonly title?: string;
 }
 /** Independently switchable prose-assistance features of the composer. */
 export interface SpellingFeatures extends MacOSSpellingFeatures {
@@ -112,19 +118,19 @@ export declare class CustomEditor extends Editor {
      *  Numbered by a per-draft monotonic counter so a deleted chip never recycles its number
      *  (labels key the atom table). */
     pendingTexts: TextAttachment[];
-    /** Host-wired producer of per-image `file://` links (session blob store); drives clickable
-     *  chip tokens for restored drafts (esc-esc, `/tree`, branch). */
+    /** Host-wired producer of per-image chip targets (a file on disk, or a session blob copy);
+     *  drives clickable chip tokens for restored drafts (esc-esc, `/tree`, branch). */
     draftImageLinkMaterializer?: (images: readonly ImageContent[]) => Promise<(string | undefined)[] | undefined>;
     /**
      * The host {@link TUI}, captured when a plugin constructs this editor through
-     * the upstream-pi `(tui, theme, keybindings)` convention. Undefined for zeta's
+     * the upstream-pi `(tui, theme, keybindings)` convention. Undefined for omp's
      * own `new CustomEditor(theme)` callers (they drive repaints through the
      * interactive-mode wiring instead). Plugins that call `this.tui.requestRender()`
      * in their overrides read it here (issue #4766).
      */
     tui?: TUI;
     /**
-     * Accept both the zeta constructor convention — `new CustomEditor(theme)` —
+     * Accept both the omp constructor convention — `new CustomEditor(theme)` —
      * and the upstream-pi `Editor` convention — `new Editor(tui, theme, keybindings)`
      * — that {@link ExtensionUIContext.setEditorComponent}'s factory contract
      * advertises `(tui, theme, keybindings)`. Plugins written against upstream pi
@@ -187,7 +193,8 @@ export declare class CustomEditor extends Editor {
     static readonly SHIMMER_PERIOD_MS = 1800;
     /** Decorate magic keywords, attachments, and the queue-composer header/list markers.
      *  Queue shorthand reserves its first logical line as a dim `Queueing` label; sequential
-     *  item markers use the accent color so separate follow-ups remain visible while composing. */
+     *  item markers use the accent color so separate follow-ups remain visible while composing.
+     *  Called once per layout segment, so whole-buffer inputs are computed once per text revision. */
     decorateText: (text: string, context: EditorTextDecorationContext) => string;
     /**
      * TSP decorations: magic keywords shimmer (terminal-clocked) in the accent
@@ -213,8 +220,10 @@ 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;
-    /** Viewing a subagent, the draft goes to it: the placeholder names it. */
-    describePlaceholder: () => string;
+    /** 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; else the session's title, quoted in italics. */
+    describePlaceholder: () => TspText;
     /** A shell-mode draft highlights as its language. */
     describeLanguage: () => string | undefined;
     /** Host-owned live state for the TSP composer (shell mode, effort chip, send/stop). */
@@ -227,7 +236,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 +247,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 +279,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 +296,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/image-source.d.ts

@@ -4,7 +4,8 @@
  * to the session's `local://` root, and generated video contact-sheet previews.
  * Symbol metadata stays out of serialized/model-bound image data while traveling
  * with the draft object, until AgentSession creates the hidden companion message
- * that tells the model the path (and link materialization prefers it over a blob copy).
+ * that tells the model the path. The model keeps `local://` references across
+ * `/move`; chips for internal URLs instead use a stable blob copy.
  */
 import type { ImageContent } from "@linxiraos/pi-ai";
 /** How an image attachment's backing file entered the session. */

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

@@ -15,14 +15,18 @@ export interface AssistantMessageHost {
     readonly viewSession: AssistantMessageSession;
     readonly effectiveHideThinkingBlock: boolean;
     readonly proseOnlyThinking: boolean;
+    readonly expandThinkingBlocks: boolean;
     readonly assistantImagesVisible: boolean;
+    /** Whether the viewed session's tables get charts: the main session's do, a focused subagent's do not. */
+    readonly tableChartsVisible: boolean;
     readonly hideToolActivity: boolean;
     readonly toolOutputExpanded: boolean;
     readonly ui: {
         requestRender(): void;
         readonly imageBudget: ImageBudget;
     };
-    resolveAssistantMessageLinks(texts: readonly string[]): Promise<ReadonlyMap<string, string>>;
+    /** Resolve already-extracted Markdown link destinations to local targets. */
+    resolveAssistantMessageLinkHrefs(hrefs: readonly string[]): Promise<ReadonlyMap<string, string>>;
 }
 /**
  * Resolve and cache the current session's model-authored prose links. Existing

package/dist/types/prompt/model-mention-autocomplete.d.ts

@@ -19,7 +19,7 @@ export declare function applyModelMentionCompletion(lines: string[], cursorLine:
 };
 /**
  * Create a session-scoped model candidate lookup using picker ordering. The
- * scope and search affinity are reused across queries until their inputs change.
+ * scope and its prepared ranker are reused across queries until their inputs change.
  */
 export declare function createModelMentionSource(host: {
     source: ModelBrowserSource;

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

@@ -14,7 +14,12 @@ export declare const WELCOME_LSP_SLOTS = 4;
  *  `r` is a uniform sample in [0, 1). Returns "" when `tips` is empty.
  *  Exported for tests. */
 export declare function pickWeightedTip(tips: readonly string[], r: number): string;
-export declare function renderWelcomeTip(tip: string, boxWidth: number, phase?: number): string[];
+/**
+ * The welcome tip as lines of at most `width` columns: `Tip:` and the body
+ * wrapped together, with no indent, so the banner can center each line.
+ * `[]` when `width` leaves no room for a useful line.
+ */
+export declare function renderWelcomeTip(tip: string, width: number, phase?: number): string[];
 export interface RecentSession {
     name: string;
     timeAgo: string;
@@ -37,7 +42,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/render/composite.d.ts

@@ -0,0 +1,2 @@
+/** Splice overlay content into a base line at a specific column. Single-pass optimized. */
+export declare function compositeLineAt(baseLine: string, overlayLine: string, startCol: number, overlayWidth: number, totalWidth: number): string;

package/dist/types/render/output-pane.d.ts

@@ -92,6 +92,7 @@ export declare class OutputPane implements Component {
     describe(_cx: DescribeContext): NativeNode;
     render(width: number): readonly string[];
     invalidate(): void;
+    releaseRenderCaches(): void;
 }
 /** Default styling for plain tool output while preserving existing ANSI. */
 export declare function styleToolOutputLine(line: string, theme: Theme): string;

package/dist/types/render/render-utils.d.ts

@@ -298,6 +298,7 @@ export interface RenderedStringCache {
 export declare function createRenderedStringCache(): RenderedStringCache;
 /** Drop the memo so the next lookup re-renders (e.g. the render function identity changed). */
 export declare function invalidateRenderedStringCache(cache: RenderedStringCache): void;
+export declare function releaseRenderedStringCache(cache: RenderedStringCache): void;
 /** Reuse a rendered string while its theme, expansion, content, and salt match. */
 export declare function cachedRenderedString(cache: RenderedStringCache | undefined, theme: Theme, expanded: boolean, salt: string, content: string, render: () => string): string;
 /**

package/dist/types/render/tool-card.d.ts

@@ -46,6 +46,11 @@ export interface ToolCardOptions {
     paddingY?: number;
     ignoreTight?: boolean;
     onInvalidate?: () => void;
+    /**
+     * Drop builder-owned memos the next build recomputes. Called by
+     * {@link ToolCard.releaseRenderCaches}, which never calls `onInvalidate`.
+     */
+    onReleaseRenderCaches?: () => void;
     onDispose?: () => void;
 }
 /** Map transcript lifecycle terminology onto the output frame's visual states. */
@@ -71,6 +76,7 @@ export declare class ToolCard implements Component {
     handleInput(data: string): void;
     setIgnoreTight(ignore: boolean): void;
     invalidate(): void;
+    releaseRenderCaches(): void;
     dispose(): void;
 }
 /** Construct a lazy framed tool card. */

package/dist/types/render/width-aware-text.d.ts

@@ -20,6 +20,8 @@ export declare class WidthAwareText implements Component {
     setCustomBgFn(customBgFn?: (text: string) => string): void;
     setIgnoreTight(ignore: boolean): this;
     invalidate(): void;
+    /** The formatted text stays: the inner `Text` renders from it, so dropping it would free nothing. */
+    releaseRenderCaches(): void;
     /**
      * Re-run the formatter on the next render because its inputs changed.
      * Unlike {@link invalidate}, the inner `Text` keeps its wrap cache, so a

package/dist/types/setup/scenes/types.d.ts

@@ -28,6 +28,7 @@ export interface SetupHost extends SetupUiHost {
     readonly disabledProviders: readonly string[];
     readonly authStorage: AuthStorage;
     readonly modelSource: ModelBrowserSource;
+    /** Available and catalog models of every kind; role chips resolve over all of them, rows list chat models. */
     getModels(): {
         available: Model[];
         all: Model[];

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/component.d.ts

@@ -86,6 +86,7 @@ export declare class StatusLineComponent<TSession extends StatusLineSession = St
     setPlanModeStatus(status: {
         enabled: boolean;
         paused: boolean;
+        workflow?: "parallel" | "iterative" | "ultra";
     } | undefined): void;
     setLoopModeStatus(status: NonNullable<SegmentContext["loopMode"]> | undefined): void;
     setGoalModeStatus(status: {
@@ -113,6 +114,8 @@ export declare class StatusLineComponent<TSession extends StatusLineSession = St
     setRecording(recording: boolean): void;
     /** Set the callback that presents detected Codex reset celebrations, or clear it with `undefined`. */
     setCodexResetFireworksHandler(handler: ((event: CodexResetFireworksEvent) => void) | undefined): void;
+    /** Set the callback that presents the first pool-wide saved-reset expiry warning, or clear it with `undefined`. */
+    setResetExpiryNoticeHandler(handler: ((notice: string) => void) | undefined): void;
     setHookStatus(key: string, text: string | undefined): void;
     watchBranch(onBranchChange: () => void): void;
     dispose(): 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/status-line/host.d.ts

@@ -2,7 +2,7 @@ import type { AgentMessage, ThinkingLevel } from "@linxiraos/pi-agent-core";
 import type { Tool, UsageLimit, UsageReport } from "@linxiraos/pi-ai";
 import type { Model } from "@linxiraos/pi-catalog/types";
 import type { CompactionBoundaries } from "./context-usage.js";
-import type { StatusLineSettings } from "./types.js";
+import type { StatusLineSettings, StatusResetExpiry } from "./types.js";
 export interface StatusAccountIdentity {
     accountId?: string;
     email?: string;
@@ -126,6 +126,9 @@ export interface StatusLineHost<TSession extends StatusLineSession = StatusLineS
     }>;
     calculateTokensPerSecond(messages: readonly AgentMessage[], isStreaming: boolean): number | null;
     limitMatchesActiveAccount(report: UsageReport, limit: UsageLimit, identity: StatusAccountIdentity): boolean;
+    classifyResetExpiry?(report: UsageReport, nowMs: number): StatusResetExpiry | undefined;
+    /** One-line warning for saved resets anywhere in the pool that expire within 24 hours. */
+    resetExpiryNotice?(reports: readonly UsageReport[], nowMs: number): string | undefined;
     computeCompactionBoundaries(session: TSession, contextWindow: number, model?: Model): CompactionBoundaries | null;
 }
 export interface FooterHost {

package/dist/types/status-line/segments.d.ts

@@ -7,6 +7,8 @@ export type { SegmentContext } from "./types.js";
  * model segment and the composer's effort chip.
  */
 export declare function thinkingLevelWord(session: Pick<StatusLineSession, "state" | "isAutoThinking" | "autoResolvedThinkingLevel">): string | undefined;
+/** Zeta-only: the ultra plan workflow gets its own status-line label (lost in the v18.8.8 merge once already). */
+export declare const PLAN_ULTRA_LABEL = "Plan-Ultra";
 export declare const SEGMENTS: Record<StatusLineSegmentId, StatusLineSegment>;
 export declare function renderSegment(id: StatusLineSegmentId, ctx: SegmentContext): RenderedSegment;
 /** Native description of one segment; null when it is hidden or unknown. */

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

@@ -93,6 +93,8 @@ export interface SegmentContext {
     planMode: {
         enabled: boolean;
         paused: boolean;
+        /** Plan workflow variant; `ultra` renders as `Plan-Ultra` in the mode segment. */
+        workflow?: "parallel" | "iterative" | "ultra";
     } | null;
     prewalk: {
         enabled: boolean;
@@ -112,7 +114,7 @@ export interface SegmentContext {
     } | null;
     /** Modal editing state, or null when `tui.vimMode` is off. */
     vim: {
-        mode: "insert" | "normal" | "visual" | "visual-line";
+        mode: "insert" | "normal" | "visual" | "visual-line" | "replace";
         /** Half-typed operator/count (`"2d"`), empty when nothing is pending. */
         pending: string;
         /** Lines spanned by the active Visual selection; 0 outside Visual modes. */
@@ -223,9 +225,18 @@ export interface SegmentContext {
             expiryHours?: number;
             expired?: boolean;
             unavailableReason?: string;
+            expiring?: StatusResetExpiry;
         };
     } | null;
 }
+/** How close an account's saved resets are to expiring, when it is worth a warning. */
+export interface StatusResetExpiry {
+    /** `soon`: within 7 days; `imminent`: within 24 hours. */
+    tier: "soon" | "imminent";
+    count: number;
+    /** Expiry of the reset the warning is about (epoch ms); it can be later than the soonest banked one. */
+    expiresAtMs: number;
+}
 export interface RenderedSegment {
     content: string;
     visible: boolean;
@@ -245,8 +256,8 @@ export interface SegmentView {
 }
 /**
  * The status line's facts for the native composer. A TSP terminal shows no
- * status strip: the tab title carries the session, the pane header the path
- * and branch, and the composer the rest.
+ * status strip: the tab title carries the session, the pane header the path,
+ * and the composer the rest (the git branch among its facts).
  */
 export interface ComposerFacts {
     /**