@oh-my-pi/pi-coding-agent 15.12.3 → 15.13.0

package/dist/types/modes/components/tool-execution.d.ts

@@ -1,6 +1,6 @@
 import type { SnapshotStore } from "@oh-my-pi/hashline";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import { type Component, Container, type TUI } from "@oh-my-pi/pi-tui";
+import { type Component, Container, type NativeScrollbackLiveRegion, type TUI } from "@oh-my-pi/pi-tui";
 /**
  * Transcript-side probe telling a block whether it is still inside the live
  * (repaintable) region. Implemented by `TranscriptContainer`; injected rather
@@ -33,10 +33,20 @@ export interface ToolExecutionHandle {
     setArgsComplete(toolCallId?: string): void;
     setExpanded(expanded: boolean): void;
 }
+/** Drive pending-tool redraws at 30fps for live tool headers and displaceable
+ * poll blocks. The TUI throttles at the same cadence, and static frames diff to
+ * a no-op redraw at ~zero cost. */
+export declare const SPINNER_RENDER_INTERVAL_MS: number;
+/** Advance the spinner glyph at its classic ~12.5fps step, decoupled from the
+ * render cadence (mirrors `Loader`). */
+export declare const SPINNER_GLYPH_ADVANCE_MS = 80;
+/** Phase-locked spinner glyph index shared by every live tool block so parallel
+ * spinners advance in lockstep instead of each tracking its own start time. */
+export declare function sharedSpinnerFrame(frameCount: number, now?: number): number;
 /**
  * Component that renders a tool call with its result (updateable)
  */
-export declare class ToolExecutionComponent extends Container {
+export declare class ToolExecutionComponent extends Container implements NativeScrollbackLiveRegion {
     #private;
     constructor(toolName: string, args: any, options: ToolExecutionOptions | undefined, tool: AgentTool | undefined, ui: TUI, cwd?: string, _toolCallId?: string);
     updateArgs(args: any, _toolCallId?: string): void;
@@ -63,6 +73,14 @@ export declare class ToolExecutionComponent extends Container {
         details?: any;
         isError?: boolean;
     }, isPartial?: boolean, _toolCallId?: string): void;
+    /**
+     * Standalone harnesses may mount a tool component directly under `TUI`
+     * instead of inside `TranscriptContainer`. In that shape the component must
+     * report its own live-region seam for provisional previews, or the core
+     * renderer treats it like shell output and commits tail-window edit/eval/bash
+     * previews to immutable native scrollback before the result replaces them.
+     */
+    getNativeScrollbackLiveRegionStart(): number | undefined;
     /**
      * Whether this block has reached a terminal state for transcript freezing.
      * Reports `false` while it can still visually change so the
@@ -74,20 +92,12 @@ export declare class ToolExecutionComponent extends Container {
     isTranscriptBlockFinalized(): boolean;
     /**
      * Whether this still-live block's settled rows may enter native scrollback
-     * (see `FinalizableBlock.isTranscriptBlockCommitStable`). Classification is
-     * per renderer (`ToolRenderer.provisionalPendingPreview`): tail-window
-     * streaming views (edit's streamed-diff tail, bash/ssh command caps, eval
-     * cells) are re-anchored top-first by the result render, so promoting
-     * their visually static head — e.g. an edit preview idling on its last
-     * frame while the apply + LSP pass runs — would strand a stale copy of
-     * the call box above the final block the moment the result lands. Every
-     * other pending preview streams top-anchored append-shaped rows the
-     * result render preserves (a task call's context/assignment markdown, a
-     * write's content), so it stays commit-eligible — a call taller than the
-     * viewport scrolls into native history mid-stream instead of reading as
-     * cut off until the result. Expanded blocks always stream top-anchored
-     * (the over-tall write/eval scrollback contract). Displaceable waiting
-     * polls are removed wholesale by the next poll and must never commit.
+     * (see `FinalizableBlock.isTranscriptBlockCommitStable`). Renderers classify
+     * pending views by durability instead of by tool name: a provisional view is
+     * allowed to be useful on screen, but finalization may replace or re-anchor
+     * it wholesale, so committing any of its rows would strand stale preview
+     * bytes in immutable scrollback. Non-provisional views stream rows whose
+     * committed prefix survives the remaining transitions.
      */
     isTranscriptBlockCommitStable(): boolean;
     /**

package/dist/types/modes/components/transcript-container.d.ts

@@ -1,4 +1,4 @@
-import { type Component, Container, type NativeScrollbackCommittedRows, type NativeScrollbackLiveRegion, type RenderStablePrefix } from "@oh-my-pi/pi-tui";
+import { type Component, Container, type NativeScrollbackCommittedRows, type NativeScrollbackLiveRegion, type RenderStablePrefix, type ViewportTailProvider } from "@oh-my-pi/pi-tui";
 /**
  * Transcript container that renders every block's current content each frame
  * and reports the live-region seam (`NativeScrollbackLiveRegion`) that gates
@@ -22,7 +22,7 @@ import { type Component, Container, type NativeScrollbackCommittedRows, type Nat
  * through {@link RenderStablePrefix} so the engine can skip marker scanning,
  * line preparation, and the committed-prefix audit for those rows.
  */
-export declare class TranscriptContainer extends Container implements NativeScrollbackLiveRegion, NativeScrollbackCommittedRows, RenderStablePrefix {
+export declare class TranscriptContainer extends Container implements NativeScrollbackLiveRegion, NativeScrollbackCommittedRows, RenderStablePrefix, ViewportTailProvider {
     #private;
     invalidate(): void;
     clear(): void;
@@ -30,6 +30,7 @@ export declare class TranscriptContainer extends Container implements NativeScro
     getRenderStablePrefixRows(): number;
     getNativeScrollbackLiveRegionStart(): number | undefined;
     getNativeScrollbackCommitSafeEnd(): number | undefined;
+    getNativeScrollbackSnapshotSafeEnd(): number | undefined;
     /**
      * Whether `component` sits below a still-mutating block — i.e. inside the
      * live region, where its rows cannot have been committed to native
@@ -52,6 +53,26 @@ export declare class TranscriptContainer extends Container implements NativeScro
      * become commit-eligible native-scrollback history.
      */
     isBlockInLiveRegion(component: Component): boolean;
+    /**
+     * Render only the bottom `maxRows` rows of the transcript at `width`, walking
+     * blocks from the last toward the first and stopping the instant enough rows
+     * are collected — blocks above the fold are never rendered. The engine's
+     * resize viewport fast path uses this so a drag (a SIGWINCH burst, each event
+     * a fresh width that misses every per-width cache) re-lays-out only the
+     * handful of visible blocks instead of the whole history every event.
+     *
+     * State-isolated by contract: touches none of the persistent full-compose
+     * fields (#lines, #segments, the per-block diff snapshots, the commit/stable
+     * bookkeeping), so the authoritative full render on settle reconciles exactly
+     * as if this never ran. Calling each block's render() still warms its own
+     * per-width cache, which that settle render then reuses for free.
+     *
+     * Consecutive visible blocks are joined by exactly one blank separator, the
+     * same rule render() applies, so the result equals the bottom of a full
+     * render except for an at-most-one-row separator on the topmost included
+     * block — a transient discrepancy the settle paint overwrites.
+     */
+    renderViewportTail(width: number, maxRows: number): readonly string[];
     render(width: number): readonly string[];
 }
 /**

package/dist/types/modes/components/tree-selector.d.ts

@@ -1,6 +1,6 @@
 import { type Component, Container } from "@oh-my-pi/pi-tui";
 import type { TreeFilterMode } from "../../config/settings-schema";
-import type { SessionTreeNode } from "../../session/session-manager";
+import type { SessionTreeNode } from "../../session/session-entries";
 /** Filter mode for tree display */
 type FilterMode = TreeFilterMode;
 declare class TreeList implements Component {

package/dist/types/modes/components/usage-row.d.ts

@@ -0,0 +1,3 @@
+import type { Usage } from "@oh-my-pi/pi-ai";
+import { Container } from "@oh-my-pi/pi-tui";
+export declare function createUsageRowBlock(usage: Usage): Container;

package/dist/types/modes/controllers/command-controller.d.ts

@@ -29,14 +29,14 @@ export declare class CommandController {
     handleRenameCommand(title: string): Promise<void>;
     handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
     handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
-    handleCompactCommand(customInstructions?: string): Promise<CompactionOutcome>;
+    handleCompactCommand(customInstructions?: string, beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>): Promise<CompactionOutcome>;
     /**
      * TUI handler for `/shake`. `elide` drops heavy structural content and
      * `images` strips image blocks. Rebuilds the chat and reports counts.
      */
     handleShakeCommand(mode: ShakeMode): Promise<void>;
     handleSkillCommand(skillPath: string, args: string): Promise<void>;
-    executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean): Promise<CompactionOutcome>;
+    executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean, beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>): Promise<CompactionOutcome>;
     handleHandoffCommand(customInstructions?: string): Promise<void>;
 }
 export declare function renderProviderSection(details: ProviderDetails, uiTheme: Pick<typeof theme, "fg">): string;

package/dist/types/modes/controllers/event-controller.d.ts

@@ -1,27 +1,10 @@
 import type { InteractiveModeContext } from "../../modes/types";
 import type { AgentSessionEvent } from "../../session/agent-session";
-/**
- * Loader label shown the instant a user interrupt (Esc) is requested, kept until
- * the agent turn fully unwinds. Esc fires the abort synchronously, but the loop
- * only stops the spinner at `agent_end`, which it cannot reach until every
- * in-flight tool settles its abort in `executeToolCalls` (`Promise.allSettled`).
- * Swapping the steady "Working…" for this acknowledges the keypress instead of
- * reading as an ignored Esc for the seconds a slow tool takes to tear down.
- */
-export declare const INTERRUPTING_WORKING_MESSAGE = "Interrupting\u2026";
 export declare class EventController {
     #private;
     private ctx;
     constructor(ctx: InteractiveModeContext);
     dispose(): void;
-    /**
-     * Acknowledge a user interrupt (Esc) immediately: switch the loader to
-     * `INTERRUPTING_WORKING_MESSAGE` and freeze intent-driven working-message
-     * updates for the rest of the turn so a late `tool_execution_start` intent
-     * cannot repaint a "Working…/<intent>" line over the acknowledgment. Reset at
-     * the next `agent_start`. No-op outside an active turn or if already set.
-     */
-    notifyInterrupting(): void;
     subscribeToAgent(): void;
     /**
      * Clear every transcript-anchored/turn-scoped piece of state. Used by the

package/dist/types/modes/controllers/input-controller.d.ts

@@ -27,6 +27,20 @@ export declare class InputController {
     handleImagePathPaste(path: string): Promise<void>;
     handleImagePaste(): Promise<boolean>;
     handleClipboardTextRawPaste(): Promise<void>;
+    /**
+     * Editor `onLargePaste` hook: gate a marker-sized paste behind the large-paste menu. Returns
+     * `true` to intercept (the editor skips its default `[Paste]` marker) once the paste reaches the
+     * configured `paste.largeMenuThreshold` line count; otherwise `false` for default collapse-to-marker
+     * behavior. The async menu is fired and forgotten — the editor only needs the synchronous verdict.
+     */
+    handleLargePaste(text: string, lineCount: number): boolean;
+    /**
+     * Present the large-paste menu and apply the chosen action: wrap in a code block or in XML tags
+     * (both collapse to a `[Paste]` marker that expands on submit), or save the text to a file and
+     * reference its path so the agent can `read` it on demand. Cancelling (Esc) falls back to the
+     * default inline paste marker, so the pasted content is never lost.
+     */
+    presentLargePasteMenu(text: string, lineCount: number): Promise<void>;
     createAutocompleteProvider(commands: SlashCommand[], basePath: string): AutocompleteProvider;
     /** Copy the current editor line to the system clipboard. */
     handleCopyCurrentLine(): void;

package/dist/types/modes/controllers/selector-controller.d.ts

@@ -43,5 +43,7 @@ export declare class SelectorController {
     showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
     showResetUsageSelector(): Promise<void>;
     showDebugSelector(): Promise<void>;
-    showAgentHub(observers: SessionObserverRegistry): void;
+    showAgentHub(observers: SessionObserverRegistry, options?: {
+        requireContent?: boolean;
+    }): void;
 }

package/dist/types/modes/gradient-highlight.d.ts

@@ -1,7 +1,12 @@
-/** A gradient keyword highlighter. `resetTo` is the SGR foreground sequence
- *  re-emitted after each painted keyword so surrounding text keeps its color;
- *  it defaults to a plain foreground reset (editor / default-colored text). */
-export type KeywordHighlighter = (text: string, resetTo?: string) => string;
+/** A gradient keyword highlighter.
+ *
+ * - `resetTo` is the SGR foreground sequence re-emitted after each painted
+ *   keyword so surrounding text keeps its color; it defaults to a plain
+ *   foreground reset (editor / default-colored text).
+ * - `phase` ∈ [0, 1) rotates the gradient stops cyclically; pass `Date.now()`-
+ *   derived values to animate a shimmer. Defaults to `0` (the static
+ *   sent-bubble palette). */
+export type KeywordHighlighter = (text: string, resetTo?: string, phase?: number) => string;
 /** Declarative spec for {@link createGradientHighlighter}. */
 export interface GradientHighlightSpec {
     /** Cheap, stateless presence probe used to skip the boundary regex on most lines. Must be non-global. */

package/dist/types/modes/image-references.d.ts

@@ -4,6 +4,12 @@ import { type BlobPutResult } from "../session/blob-store";
  *  Group 1 is the kind (`Image`/`Paste`), group 2 the 1-based index. The optional metadata
  *  tail (`, …`) is captured loosely (no `]`/newline) so future label tweaks keep matching. */
 export declare const PLACEHOLDER_REGEX: RegExp;
+/** Renumber every `[Image #N]` marker in `text` by `offset` (added to the
+ *  existing index), preserving the optional `, WxH` tail. Paste markers are
+ *  left untouched. Used when restoring queued image-messages back into a draft
+ *  that already holds pending images so the merged text's positional markers
+ *  still line up with `pendingImages`. */
+export declare function shiftImageMarkers(text: string, offset: number): string;
 type ImageBlobWriter = (data: Buffer, options?: {
     extension?: string;
 }) => Promise<BlobPutResult>;

package/dist/types/modes/interactive-mode.d.ts

@@ -13,7 +13,8 @@ import type { MCPManager } from "../mcp";
 import { type PlanApprovalDetails } from "../plan-mode/approved-plan";
 import type { AgentSession } from "../session/agent-session";
 import { HistoryStorage } from "../session/history-storage";
-import type { SessionContext, SessionManager } from "../session/session-manager";
+import type { SessionContext } from "../session/session-context";
+import type { SessionManager } from "../session/session-manager";
 import type { ShakeMode } from "../session/shake-types";
 import type { LspStartupServerInfo } from "../tools";
 import type { EventBus } from "../utils/event-bus";
@@ -33,6 +34,18 @@ import { OAuthManualInputManager } from "./oauth-manual-input";
 import type { ObservableSession } from "./session-observer-registry";
 import type { Theme } from "./theme/theme";
 import type { CompactionQueuedMessage, InteractiveModeContext, InteractiveModeInitOptions, InteractiveSelectorDialogOptions, SubmittedUserInput, TodoItem, TodoPhase } from "./types";
+/**
+ * Editor max-height cap for a terminal of `terminalRows` rows.
+ *
+ * Roomy terminals get the comfortable [6, 18] band. Small terminals shrink the
+ * cap so the editor leaves at least EDITOR_MIN_CHROME_ROWS rows for the
+ * transcript + status line. The editor is bordered, so it never renders fewer
+ * than EDITOR_MIN_RENDERED_ROWS rows; once the terminal is too small for both
+ * (terminalRows < EDITOR_MIN_RENDERED_ROWS + EDITOR_MIN_CHROME_ROWS) the cap is
+ * pinned to that floor — returning a smaller number would not shrink the editor
+ * any further, it would only misreport the rows it actually occupies.
+ */
+export declare function computeEditorMaxHeight(terminalRows: number): number;
 /** Options for creating an InteractiveMode instance (for future API use) */
 export interface InteractiveModeOptions {
     /** Providers that were migrated during startup */
@@ -74,6 +87,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     btwContainer: Container;
     omfgContainer: Container;
     errorBannerContainer: Container;
+    modelCycleContainer: Container;
     editor: CustomEditor;
     editorContainer: Container;
     hookWidgetContainerAbove: Container;
@@ -107,8 +121,6 @@ export declare class InteractiveMode implements InteractiveModeContext {
     loadingAnimation: Loader | undefined;
     autoCompactionLoader: Loader | undefined;
     retryLoader: Loader | undefined;
-    autoCompactionEscapeHandler?: () => void;
-    retryEscapeHandler?: () => void;
     unsubscribe?: () => void;
     onInputCallback?: (input: SubmittedUserInput) => void;
     optimisticUserMessageSignature: string | undefined;
@@ -177,6 +189,13 @@ export declare class InteractiveMode implements InteractiveModeContext {
     updateEditorBorderColor(): void;
     updateEditorTopBorder(): void;
     rebuildChatFromMessages(): void;
+    /**
+     * Render the ctrl+p model-role cycle chip track into its own anchored
+     * container (just above the editor), mirroring the todo HUD: the container is
+     * cleared and rebuilt in place on every cycle, so rapid presses or concurrent
+     * chat activity can never stack duplicate tracks into the scrollback.
+     */
+    showModelCycleTrack(track: string): void;
     /** Apply any deferred model switch after the current stream ends. */
     flushPendingModelSwitch(): Promise<void>;
     showPlanReview(planContent: string, title: string, options: string[], dialogOptions?: {
@@ -191,6 +210,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     }): Promise<string | undefined>;
     handlePlanModeCommand(initialPrompt?: string): Promise<void>;
     handleGoalModeCommand(rest?: string): Promise<void>;
+    handleGuidedGoalCommand(rest?: string): Promise<void>;
     /** Manually (re-)open the plan-review overlay — bound to `/plan-review`. Lets
      *  the operator pull the review back up after dismissing it, or review a plan
      *  the agent wrote without calling `resolve`. There is no fixed plan filename:
@@ -218,7 +238,6 @@ export declare class InteractiveMode implements InteractiveModeContext {
     ensureLoadingAnimation(): void;
     setWorkingMessage(message?: string): void;
     applyPendingWorkingMessage(): void;
-    notifyInterrupting(): void;
     showNewVersionNotification(newVersion: string): void;
     clearEditor(): void;
     updatePendingMessagesDisplay(): void;
@@ -264,13 +283,15 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleMemoryCommand(text: string): Promise<void>;
     handleSTTToggle(): Promise<void>;
     showDebugSelector(): Promise<void>;
-    showAgentHub(): void;
+    showAgentHub(options?: {
+        requireContent?: boolean;
+    }): void;
     resetObserverRegistry(): void;
     handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
     handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
     handleMCPCommand(text: string): Promise<void>;
     handleSSHCommand(text: string): Promise<void>;
-    handleCompactCommand(customInstructions?: string): Promise<CompactionOutcome>;
+    handleCompactCommand(customInstructions?: string, beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>): Promise<CompactionOutcome>;
     handleHandoffCommand(customInstructions?: string): Promise<void>;
     handleShakeCommand(mode: ShakeMode): Promise<void>;
     executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean): Promise<CompactionOutcome>;

package/dist/types/modes/magic-keywords.d.ts

@@ -10,5 +10,17 @@
  * pass the surrounding text color when decorating already-colored content (e.g.
  * a themed message bubble) so the gradient does not bleed into the rest of the
  * line. Defaults to a plain foreground reset for default-colored editor text.
+ *
+ * `phase` ∈ [0, 1) cyclically rotates each gradient — the editor passes a
+ * `Date.now()`-derived value to animate a Claude-Code-style shimmer while a
+ * keyword is on screen and the prompt is focused; sent message bubbles omit it
+ * to keep the static gradient.
+ */
+export declare function highlightMagicKeywords(text: string, resetTo?: string, phase?: number): string;
+/**
+ * Cheap test for "does this text contain any magic keyword as standalone prose?".
+ * Short-circuits on a substring probe before paying for the markdown-aware
+ * prose check, so the common "no keyword in buffer" path is just three
+ * `String#indexOf`s. Used by the live editor to gate the shimmer timer.
  */
-export declare function highlightMagicKeywords(text: string, resetTo?: string): string;
+export declare function hasMagicKeyword(text: string): boolean;

package/dist/types/modes/rpc/rpc-mode.d.ts

@@ -35,7 +35,41 @@ export type RpcSessionChangeResult = {
 };
 export type RpcSessionChangeSession = Pick<AgentSession, "newSession" | "switchSession" | "branch">;
 export type RpcSkillCommandSession = Pick<AgentSession, "promptCustomMessage" | "skills" | "skillsSettings">;
-export declare function tryRunRpcSkillCommand(session: RpcSkillCommandSession, text: string): Promise<boolean>;
+export type RpcSkillCommandResult = {
+    agentInvoked: true;
+};
+export declare function tryRunRpcSkillCommand(session: RpcSkillCommandSession, text: string): Promise<RpcSkillCommandResult | false>;
+export declare function reportLocalOnlyPromptResult(input: {
+    id: string | undefined;
+    prompt: Promise<boolean>;
+    output: (obj: object) => void;
+    onError: (error: Error) => void;
+    hasExtensionAgentMessageTask?: () => boolean;
+    waitForExtensionAgentMessageTasks?: () => Promise<void>;
+}): void;
+/**
+ * Tracks extension-originated messages while an RPC prompt is executing.
+ * A slash command can resolve the outer prompt as local-only while also
+ * scheduling agent work through pi.sendUserMessage() or pi.sendMessage()
+ * with triggerTurn; that prompt must not report agentInvoked:false to the host.
+ */
+export declare class RpcExtensionUserMessageTracker {
+    #private;
+    markAgentMessageTask(): void;
+    trackAgentMessageTask(task: Promise<unknown>): void;
+    watchPrompt<T>(startPrompt: () => Promise<T>): {
+        prompt: Promise<T>;
+        hasAgentMessageTask: () => boolean;
+        waitForAgentMessageTasks: () => Promise<void>;
+    };
+}
+export declare function watchAndReportLocalOnlyPromptResult(input: {
+    id: string | undefined;
+    startPrompt: () => Promise<boolean>;
+    output: (obj: object) => void;
+    onError: (error: Error) => void;
+    extensionUserMessageTracker: RpcExtensionUserMessageTracker;
+}): void;
 export type RpcSubagentResetRegistry = Pick<RpcSubagentRegistry, "clear">;
 export declare function handleRpcSessionChange(session: RpcSessionChangeSession, command: RpcSessionChangeCommand, subagentRegistry?: RpcSubagentResetRegistry): Promise<RpcSessionChangeResult>;
 export declare function requestRpcEditor(pendingRequests: Map<string, PendingExtensionRequest>, output: RpcOutput, title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {

package/dist/types/modes/rpc/rpc-types.d.ts

@@ -10,7 +10,7 @@ import type { Effort, ImageContent, Model } from "@oh-my-pi/pi-ai";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ContextUsage } from "../../extensibility/extensions/types";
 import type { AgentSessionEvent, SessionStats } from "../../session/agent-session";
-import type { FileEntry } from "../../session/session-manager";
+import type { FileEntry } from "../../session/session-entries";
 import type { AvailableSlashCommandSource } from "../../slash-commands/available-commands";
 import type { AgentProgress, SubagentEventPayload, SubagentLifecyclePayload, SubagentProgressPayload } from "../../task";
 import type { TodoPhase } from "../../tools/todo";
@@ -208,6 +208,11 @@ export interface RpcAvailableCommandsUpdateFrame {
     type: "available_commands_update";
     commands: RpcAvailableSlashCommand[];
 }
+export interface RpcPromptResultFrame {
+    type: "prompt_result";
+    id?: string;
+    agentInvoked: boolean;
+}
 export interface RpcHandoffResult {
     savedPath?: string;
 }
@@ -239,6 +244,9 @@ export type RpcResponse = {
     type: "response";
     command: "prompt";
     success: true;
+    data?: {
+        agentInvoked: boolean;
+    };
 } | {
     id?: string;
     type: "response";

package/dist/types/modes/runtime-init.d.ts

@@ -11,6 +11,10 @@ export interface InitializeExtensionsOptions {
     onShutdown?: () => void;
     /** Optional UI context (rpc supplies one; print runs headless). */
     uiContext?: ExtensionUIContext;
+    /** Optional lifecycle hook for extension-originated messages that can start an agent turn. */
+    markAgentInvokingMessage?: () => void;
+    /** Optional lifecycle hook for extension-originated sends whose success/failure determines turn ownership. */
+    trackAgentInvokingMessage?: (task: Promise<unknown>) => void;
 }
 /**
  * Initialize the session's extension runner with the standard action set

package/dist/types/modes/theme/theme.d.ts

@@ -246,6 +246,8 @@ export declare function getThemeByName(name: string): Promise<Theme | undefined>
 export declare var theme: Theme;
 /** Get the name of the currently active theme. */
 export declare function getCurrentThemeName(): string | undefined;
+/** Returns unstyled `text` before `initTheme()` assigns the global theme; use only for early-render paths. */
+export declare function fgOrPlain(color: ThemeColor, text: string, styledText?: string): string;
 export declare function initTheme(enableWatcher?: boolean, symbolPreset?: SymbolPreset, colorBlindMode?: boolean, darkTheme?: string, lightTheme?: string): Promise<void>;
 export declare function setTheme(name: string, enableWatcher?: boolean): Promise<{
     success: boolean;
@@ -289,6 +291,14 @@ export declare function setColorBlindMode(enabled: boolean): Promise<void>;
  */
 export declare function getColorBlindMode(): boolean;
 export declare function onThemeChange(callback: () => void): void;
+/**
+ * Monotonic counter bumped on any theme-affecting change that should invalidate
+ * cached renders: theme swaps and reloads (including the invalid-theme dark
+ * fallback), theme previews, symbol-preset changes, and color-blind-mode
+ * changes — everything that routes through {@link notifyThemeChange}. Consumers
+ * key cached renders on it so the next render re-shapes their output.
+ */
+export declare function getThemeEpoch(): number;
 /**
  * Get available symbol presets.
  */
@@ -304,8 +314,9 @@ export declare function stopThemeWatcher(): void;
  */
 export declare function getResolvedThemeColors(themeName?: string): Promise<Record<string, string>>;
 /**
- * Check if a theme is a "light" theme by analyzing its background color luminance.
- * Loads theme JSON synchronously (built-in or custom file) and resolves userMessageBg.
+ * Check if a theme is a "light" theme by analyzing its status-line background
+ * luminance. Loads theme JSON synchronously (built-in or custom file on disk)
+ * for callers in synchronous flows (settings migration, setup wizard).
  */
 export declare function isLightTheme(themeName?: string): boolean;
 /**

package/dist/types/modes/types.d.ts

@@ -12,7 +12,8 @@ import type { MCPManager } from "../mcp";
 import type { PlanApprovalDetails } from "../plan-mode/approved-plan";
 import type { AgentSession } from "../session/agent-session";
 import type { HistoryStorage } from "../session/history-storage";
-import type { SessionContext, SessionManager } from "../session/session-manager";
+import type { SessionContext } from "../session/session-context";
+import type { SessionManager } from "../session/session-manager";
 import type { ShakeMode } from "../session/shake-types";
 import type { LspStartupServerInfo } from "../tools";
 import type { EventBus } from "../utils/event-bus";
@@ -74,6 +75,7 @@ export interface InteractiveModeContext {
     btwContainer: Container;
     omfgContainer: Container;
     errorBannerContainer: Container;
+    modelCycleContainer: Container;
     editor: CustomEditor;
     editorContainer: Container;
     hookWidgetContainerAbove: Container;
@@ -130,8 +132,6 @@ export interface InteractiveModeContext {
     loadingAnimation: Loader | undefined;
     autoCompactionLoader: Loader | undefined;
     retryLoader: Loader | undefined;
-    autoCompactionEscapeHandler?: () => void;
-    retryEscapeHandler?: () => void;
     unsubscribe?: () => void;
     onInputCallback?: (input: SubmittedUserInput) => void;
     optimisticUserMessageSignature: string | undefined;
@@ -173,6 +173,7 @@ export interface InteractiveModeContext {
     showStatus(message: string, options?: {
         dim?: boolean;
     }): void;
+    showModelCycleTrack(track: string): void;
     showError(message: string): void;
     showPinnedError(message: string): void;
     clearPinnedError(): void;
@@ -188,9 +189,6 @@ export interface InteractiveModeContext {
     flushPendingModelSwitch(): Promise<void>;
     setWorkingMessage(message?: string): void;
     applyPendingWorkingMessage(): void;
-    /** Acknowledge a user interrupt (Esc) by switching the loader to an
-     *  "Interrupting…" label until the agent turn unwinds. */
-    notifyInterrupting(): void;
     ensureLoadingAnimation(): void;
     startPendingSubmission(input: {
         text: string;
@@ -289,7 +287,9 @@ export interface InteractiveModeContext {
     showProviderSetup(): Promise<void>;
     showHookConfirm(title: string, message: string): Promise<boolean>;
     showDebugSelector(): Promise<void>;
-    showAgentHub(): void;
+    showAgentHub(options?: {
+        requireContent?: boolean;
+    }): void;
     resetObserverRegistry(): void;
     handleCtrlC(): void;
     handleCtrlD(): void;
@@ -312,6 +312,7 @@ export interface InteractiveModeContext {
     registerExtensionShortcuts(): void;
     handlePlanModeCommand(initialPrompt?: string): Promise<void>;
     handleGoalModeCommand(rest?: string): Promise<void>;
+    handleGuidedGoalCommand(rest?: string): Promise<void>;
     handleLoopCommand(args?: string): Promise<void>;
     disableLoopMode(): void;
     pauseLoop(): void;

package/dist/types/modes/utils/ui-helpers.d.ts

@@ -2,7 +2,7 @@ import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { AssistantMessage, ImageContent, Message } from "@oh-my-pi/pi-ai";
 import { type Component } from "@oh-my-pi/pi-tui";
 import type { InteractiveModeContext } from "../../modes/types";
-import type { SessionContext } from "../../session/session-manager";
+import type { SessionContext } from "../../session/session-context";
 interface RenderInitialMessagesOptions {
     preserveExistingChat?: boolean;
     clearTerminalHistory?: boolean;

package/dist/types/registry/agent-registry.d.ts

@@ -30,6 +30,8 @@ export interface AgentRef {
     sessionFile: string | null;
     createdAt: number;
     lastActivity: number;
+    /** Short gist of what the agent is currently doing (latest intent or tool), for the work-aware roster. Display-only. */
+    activity?: string;
 }
 export type RegistryEvent = {
     type: "registered";
@@ -58,6 +60,21 @@ export declare class AgentRegistry {
     static resetGlobalForTests(): void;
     register(input: RegisterInput): AgentRef;
     setStatus(id: string, status: AgentStatus): void;
+    /**
+     * Record a short activity gist for the work-aware roster. Display-only and
+     * read on demand (`irc list`, peer roster), so it emits no event — keeping
+     * the per-tool-call update rate off the registry listener path (same as
+     * `attachSession`, which also bumps `lastActivity` without emitting). Only a
+     * `running` agent has current work: a heartbeat for any other status is
+     * dropped, so a late progress flush can't resurrect activity on a ref that
+     * `setStatus` just cleared. Every running heartbeat refreshes `lastActivity`
+     * — even when the gist text is unchanged — so the roster's "active … ago" and
+     * recency sort track real work, not just the last status change.
+     * The gist is normalized to one bounded line (`oneLineLabel`) so model-derived
+     * intent text can neither break the roster nor smuggle terminal escapes —
+     * every caller is safe without sanitizing at its own call site.
+     */
+    setActivity(id: string, activity: string): void;
     attachSession(id: string, session: AgentSession, sessionFile?: string | null): void;
     detachSession(id: string): void;
     unregister(id: string): void;

package/dist/types/secrets/obfuscator.d.ts

@@ -1,5 +1,5 @@
 import type { Context, Message, Tool } from "@oh-my-pi/pi-ai";
-import type { SessionContext } from "../session/session-manager";
+import type { SessionContext } from "../session/session-context";
 export interface SecretEntry {
     type: "plain" | "regex";
     content: string;