@prometheus-ai/agent 0.5.4 → 0.5.8

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

@@ -1,16 +1,24 @@
+/**
+ * Interactive mode for the coding agent.
+ * Handles TUI rendering and user interaction, delegating business logic to AgentSession.
+ */
 import { type Agent, type AgentMessage } from "@prometheus-ai/agent-core";
 import type { CompactionOutcome } from "@prometheus-ai/agent-core/compaction";
-import { type AssistantMessage, type ImageContent, type Message, type UsageReport } from "@prometheus-ai/ai";
+import type { AssistantMessage, ImageContent, Message, UsageReport } from "@prometheus-ai/ai";
 import type { Component, EditorTheme } from "@prometheus-ai/tui";
 import { Container, Loader, Spacer, Text, TUI } from "@prometheus-ai/tui";
+import type { CollabGuestLink } from "../collab/guest";
+import type { CollabHost } from "../collab/host";
 import { KeybindingsManager } from "../config/keybindings";
 import { Settings } from "../config/settings";
 import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions } from "../extensibility/extensions";
 import type { CompactOptions } from "../extensibility/extensions/types";
+import type { MCPManager } from "../mcp";
 import { type PlanApprovalDetails } from "../plan-mode/approved-plan";
-import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
+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";
@@ -24,10 +32,24 @@ import type { HookSelectorComponent, HookSelectorSlider } from "./components/hoo
 import { StatusLineComponent } from "./components/status-line";
 import type { ToolExecutionHandle } from "./components/tool-execution";
 import { TranscriptContainer } from "./components/transcript-container";
+import { EventController } from "./controllers/event-controller";
 import { type LoopLimitRuntime } from "./loop-limit";
 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 */
@@ -41,6 +63,16 @@ export interface InteractiveModeOptions {
     /** Additional initial messages to queue */
     initialMessages?: string[];
 }
+/**
+ * Build the anchored subagent HUD block: a bold accent "Subagents" header plus
+ * one hooked row per running agent in the same `Id: description` shape the
+ * inline task rows use (muted task preview when no description was given).
+ * Only detached background spawns are listed: a sync task call blocks the
+ * parent turn and its inline tool block already renders progress live, and
+ * eval `agent()` spawns are rendered by their own eval cell tree.
+ * Returns an empty array when nothing is running so the container can clear.
+ */
+export declare function renderSubagentHudLines(sessions: ObservableSession[], columns: number): string[];
 export declare class InteractiveMode implements InteractiveModeContext {
     #private;
     session: AgentSession;
@@ -49,21 +81,23 @@ export declare class InteractiveMode implements InteractiveModeContext {
     keybindings: KeybindingsManager;
     agent: Agent;
     historyStorage?: HistoryStorage;
+    titleSystemPrompt?: string;
     ui: TUI;
     chatContainer: TranscriptContainer;
     pendingMessagesContainer: Container;
     statusContainer: Container;
     todoContainer: Container;
+    subagentContainer: Container;
     btwContainer: Container;
     omfgContainer: Container;
     errorBannerContainer: Container;
+    modelCycleContainer: Container;
     editor: CustomEditor;
     editorContainer: Container;
     hookWidgetContainerAbove: Container;
     hookWidgetContainerBelow: Container;
     statusLine: StatusLineComponent;
     isInitialized: boolean;
-    isBackgrounded: boolean;
     isBashMode: boolean;
     toolOutputExpanded: boolean;
     todoExpanded: boolean;
@@ -91,14 +125,13 @@ 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;
     locallySubmittedUserSignatures: Set<string>;
     lastSigintTime: number;
     lastEscapeTime: number;
+    lastLeftTapTime: number;
     shutdownRequested: boolean;
     hookSelector: HookSelectorComponent | undefined;
     hookInput: HookInputComponent | undefined;
@@ -108,11 +141,23 @@ export declare class InteractiveMode implements InteractiveModeContext {
     fileSlashCommands: Set<string>;
     skillCommands: Map<string, string>;
     oauthManualInput: OAuthManualInputManager;
+    collabHost?: CollabHost;
+    collabGuest?: CollabGuestLink;
     readonly lspServers: LspStartupServerInfo[] | undefined;
-    mcpManager?: import("../mcp").MCPManager;
-    constructor(session: AgentSession, version: string, changelogMarkdown?: string | undefined, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, lspServers?: LspStartupServerInfo[] | undefined, mcpManager?: import("../mcp").MCPManager, eventBus?: EventBus);
+    mcpManager?: MCPManager;
+    get eventController(): EventController;
+    get eventBus(): EventBus | undefined;
+    get viewSession(): AgentSession;
+    get focusedAgentId(): string | undefined;
+    focusAgentSession(id: string): Promise<void>;
+    focusParentSession(): Promise<void>;
+    unfocusSession(): Promise<void>;
+    clearTransientSessionUi(): void;
+    constructor(session: AgentSession, version: string, changelogMarkdown?: string | undefined, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, lspServers?: LspStartupServerInfo[] | undefined, mcpManager?: MCPManager, eventBus?: EventBus, titleSystemPrompt?: string);
     playWelcomeIntro(): void;
     init(options?: InteractiveModeInitOptions): Promise<void>;
+    /** Reload the title-generation system prompt override for the provided working directory. */
+    refreshTitleSystemPrompt(cwd?: string): Promise<void>;
     /** Reload slash commands and autocomplete for the provided working directory. */
     refreshSlashCommandState(cwd?: string): Promise<void>;
     /**
@@ -148,19 +193,45 @@ 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?: {
+        helpText?: string;
+        disabledIndices?: number[];
+        onExternalEditor?: () => void;
+        onPlanEdited?: (content: string) => void;
+        onFeedbackChange?: (feedback: string) => void;
+        initialIndex?: number;
+    }, extra?: {
+        slider?: HookSelectorSlider;
+    }): 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:
+     *  `getPlanReferencePath()` is empty until a plan is actually approved (and does
+     *  not survive a restart), so this drives off the newest `local://<slug>-plan.md`
+     *  the agent wrote — the files persist in the session artifacts dir, so the scan
+     *  works before any review and across restarts. */
+    openPlanReview(): Promise<void>;
     handlePlanApproval(details: PlanApprovalDetails): Promise<void>;
     stop(): void;
     shutdown(): Promise<void>;
     checkShutdownRequested(): Promise<void>;
     setToolUIContext(uiContext: ExtensionUIContext, hasUI: boolean): void;
     initializeHookRunner(uiContext: ExtensionUIContext, hasUI: boolean): void;
-    createBackgroundUiContext(): ExtensionUIContext;
     setEditorComponent(factory: ((tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) => CustomEditor) | undefined): void;
-    handleBackgroundEvent(event: AgentSessionEvent): Promise<void>;
+    present(content: Component | readonly Component[]): void;
+    resetTranscript(): void;
     showStatus(message: string, options?: {
         dim?: boolean;
     }): void;
@@ -174,7 +245,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     showNewVersionNotification(newVersion: string): void;
     clearEditor(): void;
     updatePendingMessagesDisplay(): void;
-    queueCompactionMessage(text: string, mode: "steer" | "followUp"): void;
+    queueCompactionMessage(text: string, mode: "steer" | "followUp", images?: ImageContent[]): void;
     flushCompactionQueue(options?: {
         willRetry?: boolean;
     }): Promise<void>;
@@ -188,7 +259,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
         updateFooter?: boolean;
         populateHistory?: boolean;
     }): void;
-    renderInitialMessages(prebuiltContext?: SessionContext, options?: {
+    renderInitialMessages(options?: {
         preserveExistingChat?: boolean;
         clearTerminalHistory?: boolean;
     }): void;
@@ -208,20 +279,23 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleToolsCommand(): void;
     handleContextCommand(): void;
     handleClearCommand(): Promise<void>;
+    handleFreshCommand(): Promise<void>;
     handleDropCommand(): Promise<void>;
     handleForkCommand(): Promise<void>;
     handleMoveCommand(targetPath: string): Promise<void>;
     handleRenameCommand(title: string): Promise<void>;
     handleMemoryCommand(text: string): Promise<void>;
     handleSTTToggle(): Promise<void>;
-    showDebugSelector(): void;
-    showSessionObserver(): void;
+    showDebugSelector(): Promise<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>;
@@ -241,14 +315,16 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleResumeSession(sessionPath: string): Promise<void>;
     handleSessionDeleteCommand(): Promise<void>;
     showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
+    showResetUsageSelector(): Promise<void>;
+    showProviderSetup(): Promise<void>;
     showHookConfirm(title: string, message: string): Promise<boolean>;
     handleCtrlC(): void;
     handleCtrlD(): void;
     handleCtrlZ(): void;
     handleDequeue(): void;
-    handleBackgroundCommand(): void;
     handleImagePaste(): Promise<boolean>;
     handleBtwCommand(question: string): Promise<void>;
+    handleTanCommand(work: string): Promise<void>;
     hasActiveBtw(): boolean;
     handleBtwEscape(): boolean;
     handleOmfgCommand(complaint: string): Promise<void>;

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

@@ -1,6 +1,6 @@
 /**
  * Gradient-highlight every magic keyword ("ultrathink", "orchestrate",
- * "workflow") that appears as standalone prose, skipping any occurrence inside a
+ * "workflowz") that appears as standalone prose, skipping any occurrence inside a
  * code block, inline code span, or XML/HTML section. Each highlighter paints its
  * own keyword with its own gradient, so chaining is order-independent — the
  * earlier passes only inject zero-width SGR escapes (no backticks or angle
@@ -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/markdown-prose.d.ts

@@ -1,6 +1,6 @@
 /**
  * Markdown structure awareness for the magic-keyword affordances
- * ("ultrathink"/"orchestrate"/"workflow").
+ * ("ultrathink"/"orchestrate"/"workflowz").
  *
  * Keyword detection and editor/transcript highlighting must fire only on prose
  * the user is actually addressing to the model — never on a word that happens to

package/dist/types/modes/oauth-manual-input.d.ts

@@ -1,8 +1,15 @@
+type ClaimedInput = {
+    promise: Promise<string>;
+    clear: (reason?: string) => void;
+};
 export declare class OAuthManualInputManager {
     #private;
     waitForInput(providerId: string): Promise<string>;
+    tryWaitForInput(providerId: string): Promise<string> | undefined;
+    tryClaimInput(providerId: string): ClaimedInput | undefined;
     submit(input: string): boolean;
     clear(reason?: string): void;
     hasPending(): boolean;
     get pendingProviderId(): string | undefined;
 }
+export {};

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

@@ -7,8 +7,8 @@ import type { AgentEvent, AgentMessage, AgentToolResult, ThinkingLevel } from "@
 import type { CompactionResult } from "@prometheus-ai/agent-core/compaction";
 import type { ImageContent, Model } from "@prometheus-ai/ai";
 import type { BashResult } from "../../exec/bash-executor";
-import type { SessionStats } from "../../session/agent-session";
-import type { RpcHandoffResult, RpcHostToolDefinition, RpcSessionState } from "./rpc-types";
+import type { AgentSessionEvent, SessionStats } from "../../session/agent-session";
+import type { RpcAvailableSlashCommand, RpcHandoffResult, RpcHostToolDefinition, RpcSessionState, RpcSubagentEventFrame, RpcSubagentLifecycleFrame, RpcSubagentMessagesResult, RpcSubagentProgressFrame, RpcSubagentSnapshot, RpcSubagentSubscriptionLevel } from "./rpc-types";
 export interface RpcClientOptions {
     /** Path to the CLI entry point (default: searches for dist/cli.js) */
     cliPath?: string;
@@ -29,6 +29,11 @@ export interface RpcClientOptions {
 }
 export type ModelInfo = Pick<Model, "provider" | "id" | "contextWindow" | "reasoning" | "thinking">;
 export type RpcEventListener = (event: AgentEvent) => void;
+export type RpcSessionEventListener = (event: AgentSessionEvent) => void;
+export type RpcSubagentLifecycleListener = (payload: RpcSubagentLifecycleFrame["payload"]) => void;
+export type RpcSubagentProgressListener = (payload: RpcSubagentProgressFrame["payload"]) => void;
+export type RpcSubagentEventListener = (payload: RpcSubagentEventFrame["payload"]) => void;
+export type RpcAvailableCommandsUpdateListener = (commands: RpcAvailableSlashCommand[]) => void;
 export interface RpcClientToolContext<TDetails = unknown> {
     toolCallId: string;
     signal: AbortSignal;
@@ -60,6 +65,26 @@ export declare class RpcClient {
      * Subscribe to agent events.
      */
     onEvent(listener: RpcEventListener): () => void;
+    /**
+     * Subscribe to all top-level session events, including non-core session state events.
+     */
+    onSessionEvent(listener: RpcSessionEventListener): () => void;
+    /**
+     * Subscribe to subagent lifecycle frames after setSubagentSubscription("progress" | "events").
+     */
+    onSubagentLifecycle(listener: RpcSubagentLifecycleListener): () => void;
+    /**
+     * Subscribe to aggregated subagent progress frames after setSubagentSubscription("progress" | "events").
+     */
+    onSubagentProgress(listener: RpcSubagentProgressListener): () => void;
+    /**
+     * Subscribe to raw subagent session events. Call setSubagentSubscription(\"events\") to enable them server-side.
+     */
+    onSubagentEvent(listener: RpcSubagentEventListener): () => void;
+    /**
+     * Subscribe to slash-command availability updates emitted by the RPC server.
+     */
+    onAvailableCommandsUpdate(listener: RpcAvailableCommandsUpdateListener): () => void;
     /**
      * Get collected stderr output (useful for debugging).
      */
@@ -98,6 +123,23 @@ export declare class RpcClient {
      * Get current session state.
      */
     getState(): Promise<RpcSessionState>;
+    /**
+     * Configure subagent frames emitted by the RPC server. Servers default to "off".
+     * "progress" emits lifecycle/progress frames; "events" additionally emits raw subagent session events.
+     */
+    setSubagentSubscription(level: RpcSubagentSubscriptionLevel): Promise<RpcSubagentSubscriptionLevel>;
+    /**
+     * Return the RPC server's current subagent snapshot.
+     */
+    getSubagents(): Promise<RpcSubagentSnapshot[]>;
+    /**
+     * Read persisted transcript entries for a tracked subagent session.
+     */
+    getSubagentMessages(selector: {
+        subagentId?: string;
+        sessionFile?: string;
+        fromByte?: number;
+    }): Promise<RpcSubagentMessagesResult>;
     /**
      * Set model by provider and ID.
      */
@@ -120,6 +162,10 @@ export declare class RpcClient {
      * Get list of available models.
      */
     getAvailableModels(): Promise<ModelInfo[]>;
+    /**
+     * Get list of available slash commands.
+     */
+    getAvailableCommands(): Promise<RpcAvailableSlashCommand[]>;
     /**
      * Set thinking level.
      */

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

@@ -1,12 +1,77 @@
 import { type ExtensionUIContext, type ExtensionUIDialogOptions } from "../../extensibility/extensions";
 import type { AgentSession } from "../../session/agent-session";
-import type { RpcExtensionUIRequest, RpcExtensionUIResponse, RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostUriCancelRequest, RpcHostUriRequest, RpcResponse } from "./rpc-types";
+import type { EventBus } from "../../utils/event-bus";
+import { RpcSubagentRegistry } from "./rpc-subagents";
+import type { RpcCommand, RpcExtensionUIRequest, RpcExtensionUIResponse, RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostUriCancelRequest, RpcHostUriRequest, RpcResponse } from "./rpc-types";
 export type * from "./rpc-types";
 export type PendingExtensionRequest = {
     resolve: (response: RpcExtensionUIResponse) => void;
     reject: (error: Error) => void;
 };
 type RpcOutput = (obj: RpcResponse | RpcExtensionUIRequest | RpcHostToolCallRequest | RpcHostToolCancelRequest | RpcHostUriRequest | RpcHostUriCancelRequest | object) => void;
+export type RpcSessionChangeCommand = Extract<RpcCommand, {
+    type: "new_session";
+} | {
+    type: "switch_session";
+} | {
+    type: "branch";
+}>;
+export type RpcSessionChangeResult = {
+    type: "new_session";
+    data: {
+        cancelled: boolean;
+    };
+} | {
+    type: "switch_session";
+    data: {
+        cancelled: boolean;
+    };
+} | {
+    type: "branch";
+    data: {
+        text: string;
+        cancelled: boolean;
+    };
+};
+export type RpcSessionChangeSession = Pick<AgentSession, "newSession" | "switchSession" | "branch">;
+export type RpcSkillCommandSession = Pick<AgentSession, "promptCustomMessage" | "skills" | "skillsSettings">;
+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?: {
     promptStyle?: boolean;
 }): Promise<string | undefined>;
@@ -14,4 +79,4 @@ export declare function requestRpcEditor(pendingRequests: Map<string, PendingExt
  * Run in RPC mode.
  * Listens for JSON commands on stdin, outputs events and responses on stdout.
  */
-export declare function runRpcMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void): Promise<never>;
+export declare function runRpcMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, eventBus?: EventBus): Promise<never>;

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

@@ -0,0 +1,24 @@
+import { type SubagentEventPayload, type SubagentLifecyclePayload, type SubagentProgressPayload } from "../../task";
+import type { EventBus } from "../../utils/event-bus";
+import type { RpcSubagentFrame, RpcSubagentMessagesResult, RpcSubagentSnapshot, RpcSubagentSubscriptionLevel } from "./rpc-types";
+export interface RpcSubagentTranscriptSelector {
+    subagentId?: string;
+    sessionFile?: string;
+    fromByte?: number;
+}
+type RpcSubagentOutput = (frame: RpcSubagentFrame) => void;
+export declare function readRpcSubagentTranscript(sessionFile: string, fromByte?: number): Promise<RpcSubagentMessagesResult>;
+export declare class RpcSubagentRegistry {
+    #private;
+    constructor(eventBus: EventBus, output: RpcSubagentOutput);
+    dispose(): void;
+    clear(): void;
+    setSubscriptionLevel(level: RpcSubagentSubscriptionLevel): void;
+    getSubscriptionLevel(): RpcSubagentSubscriptionLevel;
+    getSubagents(): RpcSubagentSnapshot[];
+    handleLifecycle(payload: SubagentLifecyclePayload): void;
+    handleProgress(payload: SubagentProgressPayload): void;
+    handleEvent(payload: SubagentEventPayload): void;
+    resolveSessionFile(selector: RpcSubagentTranscriptSelector): string;
+}
+export {};

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

@@ -9,7 +9,10 @@ import type { CompactionResult } from "@prometheus-ai/agent-core/compaction";
 import type { Effort, ImageContent, Model } from "@prometheus-ai/ai";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ContextUsage } from "../../extensibility/extensions/types";
-import type { SessionStats } from "../../session/agent-session";
+import type { AgentSessionEvent, SessionStats } from "../../session/agent-session";
+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";
 export type RpcCommand = {
     id?: string;
@@ -42,6 +45,9 @@ export type RpcCommand = {
 } | {
     id?: string;
     type: "get_state";
+} | {
+    id?: string;
+    type: "get_available_commands";
 } | {
     id?: string;
     type: "set_todos";
@@ -54,6 +60,19 @@ export type RpcCommand = {
     id?: string;
     type: "set_host_uri_schemes";
     schemes: RpcHostUriSchemeDefinition[];
+} | {
+    id?: string;
+    type: "set_subagent_subscription";
+    level: RpcSubagentSubscriptionLevel;
+} | {
+    id?: string;
+    type: "get_subagents";
+} | {
+    id?: string;
+    type: "get_subagent_messages";
+    subagentId?: string;
+    sessionFile?: string;
+    fromByte?: number;
 } | {
     id?: string;
     type: "set_model";
@@ -171,14 +190,63 @@ export interface RpcSessionState {
     /** Current context window usage. Null tokens/percent when unknown (e.g. right after compaction). */
     contextUsage?: ContextUsage;
 }
+export interface RpcAvailableSlashCommand {
+    name: string;
+    aliases?: string[];
+    description?: string;
+    input?: {
+        hint?: string;
+    };
+    subcommands?: Array<{
+        name: string;
+        description?: string;
+        usage?: string;
+    }>;
+    source: AvailableSlashCommandSource;
+}
+export interface RpcAvailableCommandsUpdateFrame {
+    type: "available_commands_update";
+    commands: RpcAvailableSlashCommand[];
+}
+export interface RpcPromptResultFrame {
+    type: "prompt_result";
+    id?: string;
+    agentInvoked: boolean;
+}
 export interface RpcHandoffResult {
     savedPath?: string;
 }
+export type RpcSubagentSubscriptionLevel = "off" | "progress" | "events";
+export interface RpcSubagentSnapshot {
+    id: string;
+    index: number;
+    agent: string;
+    agentSource: AgentProgress["agentSource"];
+    description?: string;
+    status: AgentProgress["status"];
+    task?: string;
+    assignment?: string;
+    sessionFile?: string;
+    lastUpdate: number;
+    progress?: AgentProgress;
+    parentToolCallId?: string;
+}
+export interface RpcSubagentMessagesResult {
+    sessionFile: string;
+    fromByte: number;
+    nextByte: number;
+    reset: boolean;
+    entries: FileEntry[];
+    messages: AgentMessage[];
+}
 export type RpcResponse = {
     id?: string;
     type: "response";
     command: "prompt";
     success: true;
+    data?: {
+        agentInvoked: boolean;
+    };
 } | {
     id?: string;
     type: "response";
@@ -213,6 +281,14 @@ export type RpcResponse = {
     command: "get_state";
     success: true;
     data: RpcSessionState;
+} | {
+    id?: string;
+    type: "response";
+    command: "get_available_commands";
+    success: true;
+    data: {
+        commands: RpcAvailableSlashCommand[];
+    };
 } | {
     id?: string;
     type: "response";
@@ -237,6 +313,28 @@ export type RpcResponse = {
     data: {
         schemes: string[];
     };
+} | {
+    id?: string;
+    type: "response";
+    command: "set_subagent_subscription";
+    success: true;
+    data: {
+        level: RpcSubagentSubscriptionLevel;
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_subagents";
+    success: true;
+    data: {
+        subagents: RpcSubagentSnapshot[];
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_subagent_messages";
+    success: true;
+    data: RpcSubagentMessagesResult;
 } | {
     id?: string;
     type: "response";
@@ -418,6 +516,20 @@ export type RpcResponse = {
     success: false;
     error: string;
 };
+export interface RpcSubagentLifecycleFrame {
+    type: "subagent_lifecycle";
+    payload: SubagentLifecyclePayload;
+}
+export interface RpcSubagentProgressFrame {
+    type: "subagent_progress";
+    payload: SubagentProgressPayload;
+}
+export interface RpcSubagentEventFrame {
+    type: "subagent_event";
+    payload: SubagentEventPayload;
+}
+export type RpcSubagentFrame = RpcSubagentLifecycleFrame | RpcSubagentProgressFrame | RpcSubagentEventFrame;
+export type RpcSessionEventFrame = AgentSessionEvent | RpcSubagentFrame;
 /** Emitted when an extension needs user input */
 export type RpcExtensionUIRequest = {
     type: "extension_ui_request";

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