@prometheus-ai/agent 0.5.3 → 0.5.8

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

@@ -1,11 +1,22 @@
 import type { AgentTool } from "@prometheus-ai/agent-core";
 import type { SnapshotStore } from "@prometheus-ai/hashline";
-import { Container, type TUI } from "@prometheus-ai/tui";
+import { type Component, Container, type NativeScrollbackLiveRegion, type TUI } from "@prometheus-ai/tui";
+/**
+ * Transcript-side probe telling a block whether it is still inside the live
+ * (repaintable) region. Implemented by `TranscriptContainer`; injected rather
+ * than imported so the component stays decoupled from the transcript.
+ */
+export interface TranscriptLiveRegionProbe {
+    isBlockInLiveRegion(component: Component): boolean;
+}
 export interface ToolExecutionOptions {
     snapshots?: SnapshotStore;
     showImages?: boolean;
     editFuzzyThreshold?: number;
     editAllowFuzzy?: boolean;
+    /** Live-region probe used to settle detached task progress once the block
+     * leaves the repaintable transcript region. */
+    liveRegion?: TranscriptLiveRegionProbe;
 }
 export interface ToolExecutionHandle {
     updateArgs(args: any, toolCallId?: string): void;
@@ -22,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;
@@ -52,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
@@ -61,12 +90,30 @@ export declare class ToolExecutionComponent extends Container {
      * past, or an explicit {@link seal} flips it to `true`.
      */
     isTranscriptBlockFinalized(): boolean;
+    /**
+     * Whether this still-live block's settled rows may enter native scrollback
+     * (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;
     /**
      * Mark the tool terminal even though no result arrived (the turn aborted or
      * abandoned it) and stop animating, so it can freeze and stops pinning the
      * transcript live region.
      */
     seal(): void;
+    /**
+     * Whether this block is a waiting `job` poll (every watched job still
+     * running) that has not been sealed. Such a block never finalized, so none
+     * of its rows entered native scrollback (the ticking spinner keeps the
+     * stable-prefix ratchet at zero) and the whole block can be removed when a
+     * follow-up `job` call supersedes it.
+     */
+    isDisplaceableBlock(): boolean;
     /**
      * Stop spinner animation and cleanup resources.
      */

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

@@ -1,38 +1,88 @@
-import { Container, type NativeScrollbackLiveRegion } from "@prometheus-ai/tui";
+import { type Component, Container, type NativeScrollbackCommittedRows, type NativeScrollbackLiveRegion, type RenderStablePrefix, type ViewportTailProvider } from "@prometheus-ai/tui";
 /**
- * Transcript container that freezes the rendered output of every block except
- * the bottom-most (live) one on terminals where committed native scrollback is
- * immutable.
+ * Transcript container that renders every block's current content each frame
+ * and reports the live-region seam (`NativeScrollbackLiveRegion`) that gates
+ * the engine's append-only scrollback commits.
  *
- * On ED3-risk terminals with an unobservable viewport (ghostty/kitty/iTerm2/…)
- * the renderer cannot clear saved lines (`\x1b[3J` may yank a reader) or query
- * whether the user has scrolled, so any block that re-lays-out *after* it has
- * scrolled past the viewport leaves a stale duplicate above the live region
- * (a finalized assistant message re-wrapping, a tool preview collapsing to its
- * compact result, a late async tool completion). The renderer's only safe move
- * for such an offscreen edit is to not repaint — which is correct only if the
- * committed region never changes underneath it.
+ * The engine never rewrites committed history: rows above the seam that have
+ * entered the tape keep whatever bytes they were committed with ("let the
+ * history be"), while the visible window always repaints from each block's
+ * latest render — a late tool result, a post-finalize error pin, or an expand
+ * toggle is always reflected on screen. Blocks that are still mutating (an
+ * unfinalized tool, a streaming assistant message) stay below the seam so
+ * their rows do not enter history while they can still change; a streaming
+ * block whose render grows append-only deepens the seam through its settled
+ * head so a long reply's scrolled-off rows still reach scrollback mid-stream.
  *
- * This container provides that guarantee: a block's render is snapshotted while
- * it is the live (bottom-most) block, and once a newer block is appended it
- * replays the snapshot instead of recomputing. Mutations after a block leaves
- * live are intentionally deferred until the next checkpoint {@link thaw} (prompt
- * submit → native-scrollback rebuild), where the whole transcript is replayed
- * and any drift reconciles safely. On terminals that can rebuild history this
- * freezing is unnecessary, so it renders every block live for full fidelity.
+ * Assembly is incremental: the returned array is persistent and mutated in
+ * place. Each block's render is still called every frame, but a block whose
+ * render returned the same array reference at an unchanged offset reuses its
+ * previously assembled rows; the array is truncated and re-pushed only from
+ * the first divergent block. The leading byte-identical row count is reported
+ * 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 {
+export declare class TranscriptContainer extends Container implements NativeScrollbackLiveRegion, NativeScrollbackCommittedRows, RenderStablePrefix, ViewportTailProvider {
     #private;
     invalidate(): void;
     clear(): void;
+    setNativeScrollbackCommittedRows(rows: number): void;
+    getRenderStablePrefixRows(): number;
     getNativeScrollbackLiveRegionStart(): number | undefined;
     getNativeScrollbackCommitSafeEnd(): number | undefined;
+    getNativeScrollbackSnapshotSafeEnd(): number | undefined;
     /**
-     * Retire all frozen snapshots so the next render reflects each block's current
-     * state. Call at reconciliation checkpoints (prompt submit) where the whole
-     * transcript is replayed into native scrollback and any drift a frozen block
-     * accumulated is reconciled.
+     * Whether `component` sits below a still-mutating block — i.e. inside the
+     * live region, where its rows cannot have been committed to native
+     * scrollback yet (commits are prefix-only and stop at the first
+     * still-live block). Callers that retract ephemeral blocks (IRC cards)
+     * must check this: removing a block whose rows may already be in history
+     * is an interior deletion of the committed prefix, which the engine can
+     * only repair by recommitting everything below it — duplication.
      */
-    thaw(): void;
-    render(width: number): string[];
+    isWithinLiveRegion(component: Component): boolean;
+    /**
+     * Whether `component` is inside the live (repaintable) region exactly as
+     * {@link render} computes it: at/after the first still-mutating block, or
+     * the transcript tail when every block has finalized. Unlike
+     * {@link isWithinLiveRegion} (strictly below a still-mutating block, i.e.
+     * guaranteed-uncommitted), this also counts the trailing block that anchors
+     * the live region. Self-animating finalized blocks (a detached task's
+     * shimmering progress rows) poll this to stop animating — and settle on
+     * static bytes — the moment they sit above the seam, where their rows
+     * 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[];
+}
+/**
+ * Groups a run of sibling rows (an IRC card's header + body, a file-mention
+ * list, a bordered command/version panel) into a single transcript child so the
+ * container spaces it as one block — one blank line above, none injected between
+ * its rows. Without this wrapper the rows would be top-level children and the
+ * container would put a blank line between each (and inside any border box).
+ * It is a plain {@link Container}; the named subclass documents intent and makes
+ * every manual block grouping greppable.
+ */
+export declare class TranscriptBlock extends Container {
 }

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

@@ -1,6 +1,6 @@
 import { type Component, Container } from "@prometheus-ai/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 {
@@ -15,7 +15,7 @@ declare class TreeList implements Component {
     getSearchQuery(): string;
     getSelectedNode(): SessionTreeNode | undefined;
     updateNodeLabel(entryId: string, label: string | undefined): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
     handleInput(keyData: string): void;
 }
 /**

package/dist/types/modes/components/ttsr-notification.d.ts

@@ -3,11 +3,15 @@ import type { Rule } from "../../capability/rule";
 /**
  * Component that renders a TTSR (Time Traveling Stream Rules) notification.
  * Shows when a rule violation is detected and the stream is being rewound.
+ * One block can carry several rules: a single event may match multiple rules,
+ * and consecutive notifications merge into the previous block via
+ * {@link addRules} while it is still the live transcript tail.
  */
 export declare class TtsrNotificationComponent extends Container {
     #private;
-    private readonly rules;
     constructor(rules: Rule[]);
+    /** Merge additional rules into this block (deduped by rule name). */
+    addRules(rules: Rule[]): void;
     setExpanded(expanded: boolean): void;
     isExpanded(): boolean;
 }

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

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

package/dist/types/modes/components/user-message-selector.d.ts

@@ -14,7 +14,7 @@ declare class UserMessageList implements Component {
     onCancel?: () => void;
     constructor(messages: UserMessageItem[]);
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
     handleInput(keyData: string): void;
 }
 /**

package/dist/types/modes/components/user-message.d.ts

@@ -3,6 +3,7 @@ import { Container } from "@prometheus-ai/tui";
  * Component that renders a user message
  */
 export declare class UserMessageComponent extends Container {
+    #private;
     constructor(text: string, synthetic?: boolean, imageLinks?: readonly (string | undefined)[]);
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }

package/dist/types/modes/components/visual-truncate.d.ts

@@ -1,6 +1,6 @@
 export interface VisualTruncateResult {
     /** The visual lines to display */
-    visualLines: string[];
+    visualLines: readonly string[];
     /** Number of visual lines that were skipped (hidden) */
     skippedCount: number;
 }

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

@@ -1,4 +1,14 @@
 import { type Component } from "@prometheus-ai/tui";
+/**
+ * Fixed number of session rows in the welcome box so its height stays stable
+ * across recent-session updates.
+ */
+export declare const WELCOME_SESSION_SLOTS = 4;
+/**
+ * Fixed number of LSP-server rows, for the same reason. Overflow is sliced so
+ * the box height is constant regardless of how many servers a project has.
+ */
+export declare const WELCOME_LSP_SLOTS = 4;
 export declare function renderWelcomeTip(tip: string, boxWidth: number): string[];
 export interface RecentSession {
     name: string;
@@ -6,7 +16,7 @@ export interface RecentSession {
 }
 export interface LspServerInfo {
     name: string;
-    status: "ready" | "error" | "connecting";
+    status: "ready" | "error" | "connecting" | "available";
     fileTypes: string[];
 }
 /**
@@ -30,7 +40,7 @@ export declare class WelcomeComponent implements Component {
     setModel(modelName: string, providerName: string): void;
     setRecentSessions(sessions: RecentSession[]): void;
     setLspServers(servers: LspServerInfo[]): void;
-    render(termWidth: number): string[];
+    render(termWidth: number): readonly string[];
 }
 export declare const PROMETHEUS_LOGO: string[];
 export interface ShineConfig {

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

@@ -22,20 +22,21 @@ export declare class CommandController {
     handleContextCommand(): void;
     handleMemoryCommand(text: string): Promise<void>;
     handleClearCommand(): Promise<void>;
+    handleFreshCommand(): Promise<void>;
     handleDropCommand(): Promise<void>;
     handleForkCommand(): Promise<void>;
     handleMoveCommand(targetPath: string): Promise<void>;
     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

@@ -6,7 +6,13 @@ export declare class EventController {
     constructor(ctx: InteractiveModeContext);
     dispose(): void;
     subscribeToAgent(): void;
+    /**
+     * Clear every transcript-anchored/turn-scoped piece of state. Used by the
+     * session focus proxy when re-pointing the transcript at another session:
+     * components, timers, and stream-reveal state all reference the previous
+     * session's transcript and must not bleed into the new one.
+     */
+    resetTranscriptAnchors(): void;
     handleEvent(event: AgentSessionEvent): Promise<void>;
     sendCompletionNotification(): void;
-    handleBackgroundEvent(event: AgentSessionEvent): Promise<void>;
 }

package/dist/types/modes/controllers/extension-ui-controller.d.ts

@@ -14,7 +14,6 @@ export declare class ExtensionUiController {
     initHooksAndCustomTools(): Promise<void>;
     setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
     initializeHookRunner(uiContext: ExtensionUIContext, _hasUI: boolean): void;
-    createBackgroundUiContext(): ExtensionUIContext;
     /**
      * Emit session event to all extension tools.
      */

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

@@ -1,9 +1,17 @@
-import type { AutocompleteProvider, SlashCommand } from "@prometheus-ai/tui";
+import { type AutocompleteProvider, type SlashCommand } from "@prometheus-ai/tui";
 import type { InteractiveModeContext } from "../../modes/types";
+import { readImageFromClipboard, readTextFromClipboard } from "../../utils/clipboard";
 export declare class InputController {
     #private;
     private ctx;
-    constructor(ctx: InteractiveModeContext);
+    /** Injectable clipboard reads so tests can drive paste flows without a real clipboard. */
+    private clipboard;
+    constructor(ctx: InteractiveModeContext, 
+    /** Injectable clipboard reads so tests can drive paste flows without a real clipboard. */
+    clipboard?: {
+        readImage: typeof readImageFromClipboard;
+        readText: typeof readTextFromClipboard;
+    });
     setupKeyHandlers(): void;
     setupEditorSubmitHandler(): void;
     handleCtrlC(): void;
@@ -16,9 +24,23 @@ export declare class InputController {
         abort?: boolean;
         currentText?: string;
     }): number;
-    handleBackgroundCommand(): void;
+    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/mcp-command-controller.d.ts

@@ -1,4 +1,12 @@
+import { type Component } from "@prometheus-ai/tui";
 import type { InteractiveModeContext } from "../types";
+/** Renders the MCP OAuth fallback URL without hard-wrapping the copy target. */
+export declare class MCPAuthorizationLinkPrompt implements Component {
+    #private;
+    constructor(url: string);
+    invalidate(): void;
+    render(_width: number): readonly string[];
+}
 export declare class MCPCommandController {
     #private;
     private ctx;

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

@@ -41,6 +41,9 @@ export declare class SelectorController {
     handleResumeSession(sessionPath: string): Promise<void>;
     handleSessionDeleteCommand(): Promise<void>;
     showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
-    showDebugSelector(): void;
-    showSessionObserver(registry: SessionObserverRegistry): void;
+    showResetUsageSelector(): Promise<void>;
+    showDebugSelector(): Promise<void>;
+    showAgentHub(observers: SessionObserverRegistry, options?: {
+        requireContent?: boolean;
+    }): void;
 }

package/dist/types/modes/controllers/session-focus-controller.d.ts

@@ -0,0 +1,31 @@
+/**
+ * SessionFocusController - Weak retargeting primitive between the rendering/
+ * input layer and the AgentSession it displays.
+ *
+ * Focusing re-points the transcript, streaming event subscription, status
+ * line, and editor prompt/interrupt at a subagent's live AgentSession (from
+ * AgentRegistry) without touching the main session underneath; unfocusing
+ * re-attaches the main session and rebuilds the transcript from its
+ * authoritative state.
+ */
+import { AgentLifecycleManager } from "../../registry/agent-lifecycle";
+import { AgentRegistry } from "../../registry/agent-registry";
+import type { AgentSession } from "../../session/agent-session";
+import type { InteractiveModeContext } from "../types";
+export declare class SessionFocusController {
+    #private;
+    private ctx;
+    private registry;
+    private lifecycle;
+    constructor(ctx: InteractiveModeContext, registry?: AgentRegistry, lifecycle?: () => AgentLifecycleManager);
+    get focusedAgentId(): string | undefined;
+    /** Focused live session, undefined when unfocused. */
+    get target(): AgentSession | undefined;
+    /** Focus the main view on an agent's live session. Throws an Error with a user-displayable message. */
+    focusAgent(id: string): Promise<void>;
+    /** Focus the focused agent's parent agent, falling back to the main session. No-op when unfocused. */
+    focusParent(): Promise<void>;
+    /** Return to the main session. No-op when unfocused. */
+    unfocus(): Promise<void>;
+    dispose(): void;
+}

package/dist/types/modes/controllers/streaming-reveal.d.ts

@@ -0,0 +1,22 @@
+import type { AssistantMessage } from "@prometheus-ai/ai";
+import type { AssistantMessageComponent } from "../components/assistant-message";
+export declare const STREAMING_REVEAL_FRAME_MS: number;
+export declare const MIN_STEP = 3;
+export declare const CATCHUP_FRAMES = 8;
+type StreamingRevealComponent = Pick<AssistantMessageComponent, "updateContent">;
+type StreamingRevealControllerOptions = {
+    getSmoothStreaming(): boolean;
+    getHideThinkingBlock(): boolean;
+    requestRender(): void;
+};
+export declare function visibleUnits(message: AssistantMessage, hideThinking: boolean): number;
+export declare function buildDisplayMessage(target: AssistantMessage, revealed: number, hideThinking: boolean, countOf?: (index: number, text: string) => number): AssistantMessage;
+export declare function nextStep(backlog: number): number;
+export declare class StreamingRevealController {
+    #private;
+    constructor(options: StreamingRevealControllerOptions);
+    begin(component: StreamingRevealComponent, message: AssistantMessage): void;
+    setTarget(message: AssistantMessage): void;
+    stop(): void;
+}
+export {};

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

@@ -0,0 +1,6 @@
+import type { InteractiveModeContext } from "../types";
+export declare class TanCommandController {
+    private readonly ctx;
+    constructor(ctx: InteractiveModeContext);
+    start(work: string): Promise<void>;
+}

package/dist/types/modes/controllers/tool-args-reveal.d.ts

@@ -0,0 +1,43 @@
+/** Minimal component surface the reveal pushes frames into. */
+type ToolArgsRevealComponent = {
+    updateArgs(args: unknown, toolCallId?: string): void;
+};
+type ToolArgsRevealControllerOptions = {
+    getSmoothStreaming(): boolean;
+    requestRender(): void;
+};
+/**
+ * Paces streamed tool-call arguments the same way StreamingRevealController
+ * paces assistant text: providers that deliver `partialJson` in large batches
+ * (or throttle their partial parses) would otherwise make write/edit/bash
+ * streaming previews jump in chunks. Each pending tool call reveals its raw
+ * argument stream at the shared 30fps cadence with the same adaptive
+ * catch-up step, re-parsing the revealed prefix per frame.
+ *
+ * Reveal units are UTF-16 code units of the raw stream, not graphemes —
+ * the prefix goes through a JSON parser rather than straight to the screen,
+ * so only surrogate-pair integrity matters (see {@link clampSliceEnd}).
+ */
+export declare class ToolArgsRevealController {
+    #private;
+    constructor(options: ToolArgsRevealControllerOptions);
+    /**
+     * Record the latest streamed argument text for a tool call and return the
+     * args to render right now. With smoothing disabled the full target passes
+     * through in the caller's legacy shape (`{ ...args, __partialJson }`).
+     */
+    setTarget(id: string, partialJson: string, rawInput: boolean, fullArgs: Record<string, unknown>): Record<string, unknown>;
+    /** Attach the component future ticks push frames into. */
+    bind(id: string, component: ToolArgsRevealComponent): void;
+    /** Final arguments arrived (the JSON closed): drop the reveal so the
+     *  caller's final-args render wins immediately, mirroring how assistant
+     *  text snaps to the full message at message_end. */
+    finish(id: string): void;
+    /** Snap every live entry to its full received stream and clear. Used at
+     *  message_end (abort/error mid-stream) so sealed components freeze showing
+     *  everything that arrived rather than a mid-reveal prefix. */
+    flushAll(): void;
+    /** Clear without pushing (teardown). */
+    stop(): void;
+}
+export {};

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

@@ -1,16 +1,27 @@
 import type { ImageContent } from "@prometheus-ai/ai";
 import { type BlobPutResult } from "../session/blob-store";
+/** Matches `[Image #N]`/`[Image #N, WxH]` and `[Paste #N, +X lines]`/`[Paste #N, Y chars]` tokens.
+ *  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>;
 type ImageBlobWriterSync = (data: Buffer, options?: {
     extension?: string;
 }) => BlobPutResult;
-export interface ImageReferenceRenderers {
+export type PlaceholderKind = "image" | "paste";
+export interface PlaceholderRenderers {
     renderText: (text: string) => string;
-    renderReference: (label: string, index: number) => string;
+    renderReference: (label: string, kind: PlaceholderKind, index: number) => string;
 }
-export declare function renderImageReferences(text: string, renderers: ImageReferenceRenderers): string;
+export declare function renderPlaceholders(text: string, renderers: PlaceholderRenderers): string;
 export declare function imageReferenceHyperlink(label: string, index: number, imageLinks: readonly (string | undefined)[] | undefined, renderLabel: (text: string) => string): string;
 export declare function materializeImageReferenceLinks(images: readonly ImageContent[] | undefined, putBlob: ImageBlobWriter): Promise<(string | undefined)[] | undefined>;
 export declare function materializeImageReferenceLinksSync(images: readonly ImageContent[] | undefined, putBlob: ImageBlobWriterSync): (string | undefined)[] | undefined;

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

@@ -1,9 +1,10 @@
 /**
- * Run modes for the coding agent.
+ * Interactive mode and embeddable RPC client exports for the coding agent.
+ *
+ * Branch-specific runners live in their concrete modules so importing this
+ * barrel does not pull print, RPC server, or ACP server mode into the normal
+ * TUI graph.
  */
-export { runAcpMode } from "./acp";
-export { InteractiveMode, type InteractiveModeOptions } from "./interactive-mode";
-export { type PrintModeOptions, runPrintMode } from "./print-mode";
-export { defineRpcClientTool, type ModelInfo, RpcClient, type RpcClientCustomTool, type RpcClientOptions, type RpcClientToolContext, type RpcClientToolResult, type RpcEventListener, } from "./rpc/rpc-client";
-export { runRpcMode } from "./rpc/rpc-mode";
-export type { RpcCommand, RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostToolDefinition, RpcHostToolResult, RpcHostToolUpdate, RpcResponse, RpcSessionState, } from "./rpc/rpc-types";
+export * from "./interactive-mode";
+export * from "./rpc/rpc-client";
+export * from "./rpc/rpc-types";