@code-yeongyu/senpi 2026.8.28 → 2026.8.30-2

package/dist/modes/rpc/connection-handler.d.ts

@@ -14,6 +14,7 @@
  * go to `sink.writeRaw` instead of `writeRawStdout`, and the caller decides how
  * (and whether) to end the process.
  */
+import type { AgentAbortSource } from "../../core/agent-abort-provenance.ts";
 import type { AgentSession } from "../../core/agent-session.ts";
 import type { AgentSessionRuntime } from "../../core/agent-session-runtime.ts";
 import type { RpcSessionState } from "./rpc-types.ts";
@@ -50,6 +51,8 @@ export interface RpcConnectionHandler {
      * host polls this after each command and decides how to tear down.
      */
     isShutdownRequested(): boolean;
+    /** Cancel UI requests that can no longer be answered by this connection. */
+    cancelPendingExtensionUiRequests(): void;
     /** Tear down subscriptions and dispose the runtime. Never calls process.exit. */
     dispose(): Promise<void>;
 }
@@ -59,8 +62,12 @@ export interface RpcConnectionHandler {
  * Shared with `open_session` (session-command-router) so both surfaces answer with the SAME
  * fields: a second hand-rolled literal silently drifts, which is how `serviceTier`/`fastMode`
  * would otherwise be missing from an opened session's initial state.
+ *
+ * `lastAbortSource` is passed in rather than read from the session: `session.currentAbortSource`
+ * is cleared once the turn settles, so only the caller that observed `agent_end` still knows
+ * who owned the abort.
  */
-export declare function buildRpcSessionState(session: AgentSession): RpcSessionState;
+export declare function buildRpcSessionState(session: AgentSession, lastAbortSource?: AgentAbortSource): RpcSessionState;
 /**
  * Create a per-connection RPC handler bound to one runtime host and one sink.
  *

package/dist/modes/rpc/connection-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection-handler.d.ts","sourceRoot":"","sources":["../../../src/modes/rpc/connection-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAMH,OAAO,KAAK,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AACnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAwC/E,OAAO,KAAK,EAWX,eAAe,EAEf,MAAM,gBAAgB,CAAC;AAGxB,kFAAkF;AAClF,MAAM,WAAW,oBAAoB;IACpC,mFAAmF;IACnF,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,iFAAiF;IACjF,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B,0DAA0D;IAC1D,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,oBAAoB;IACpC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,sEAAsE;IACtE,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C;;;OAGG;IACH,mBAAmB,IAAI,OAAO,CAAC;IAC/B,iFAAiF;IACjF,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AA4BD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,YAAY,GAAG,eAAe,CAiB3E;AA4BD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACzC,WAAW,EAAE,mBAAmB,EAChC,IAAI,EAAE,iBAAiB,EACvB,OAAO,GAAE,oBAAyB,GAChC,oBAAoB,CAyiCtB"}
+{"version":3,"file":"connection-handler.d.ts","sourceRoot":"","sources":["../../../src/modes/rpc/connection-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AACnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAyC/E,OAAO,KAAK,EAYX,eAAe,EAEf,MAAM,gBAAgB,CAAC;AAGxB,kFAAkF;AAClF,MAAM,WAAW,oBAAoB;IACpC,mFAAmF;IACnF,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,iFAAiF;IACjF,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B,0DAA0D;IAC1D,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,oBAAoB;IACpC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,sEAAsE;IACtE,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C;;;OAGG;IACH,mBAAmB,IAAI,OAAO,CAAC;IAC/B,4EAA4E;IAC5E,gCAAgC,IAAI,IAAI,CAAC;IACzC,iFAAiF;IACjF,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AA4BD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,YAAY,EAAE,eAAe,CAAC,EAAE,gBAAgB,GAAG,eAAe,CAkD/G;AA4BD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACzC,WAAW,EAAE,mBAAmB,EAChC,IAAI,EAAE,iBAAiB,EACvB,OAAO,GAAE,oBAAyB,GAChC,oBAAoB,CA4uCtB"}

package/dist/modes/rpc/connection-handler.js

@@ -15,6 +15,7 @@
  * (and whether) to end the process.
  */
 import * as crypto from "node:crypto";
+import { existsSync } from "node:fs";
 import { basename, dirname, extname } from "node:path";
 import { VERSION } from "../../config.js";
 import { buildLoginProviderInfos } from "../../core/auth-providers.js";
@@ -24,11 +25,12 @@ import { CLAUDE_SDK_OAUTH_PROVIDER_ID } from "../../core/extensions/builtin/clau
 import { isMcpControlInventoryChanged, MCP_CONTROL_INVENTORY_CHANGED_EVENT, MCP_CONTROL_INVENTORY_REQUEST_EVENT, } from "../../core/extensions/builtin/mcp/control-inventory.js";
 import { applyFastMode, resolveServiceTierMemoryModel, } from "../../core/extensions/builtin/service-tier.js";
 import { getSupportedThinkingLevels } from "../../core/thinking-levels.js";
+import { ProjectTrustStore } from "../../core/trust-manager.js";
 import { theme } from "../interactive/theme/theme.js";
 import { buildCustomUnsupportedRequest, DEFAULT_CUSTOM_EXTENSION_LABEL, EXTENSION_EVENTS_CAPABILITY, } from "./custom-capability.js";
 import { createRpcEventOutputBuffer } from "./event-output-buffer.js";
 import { buildRpcCommandsForSession, createCommandsChangedEvent, rpcCommandListDigest } from "./rpc-command-surface.js";
-import { rpcCommandShapeError, rpcMessageLengthError } from "./rpc-input-validation.js";
+import { rpcCommandPayloadError, rpcCommandShapeError, rpcMessageLengthError } from "./rpc-input-validation.js";
 import { SessionExtensionUiRequests } from "./session-extension-ui-requests.js";
 function loadedExtensionName(path) {
     const synthetic = /^<(?:builtin|inline):([^>]+)>$/.exec(path);
@@ -64,23 +66,56 @@ function loadedMcpStatus(server) {
  * Shared with `open_session` (session-command-router) so both surfaces answer with the SAME
  * fields: a second hand-rolled literal silently drifts, which is how `serviceTier`/`fastMode`
  * would otherwise be missing from an opened session's initial state.
+ *
+ * `lastAbortSource` is passed in rather than read from the session: `session.currentAbortSource`
+ * is cleared once the turn settles, so only the caller that observed `agent_end` still knows
+ * who owned the abort.
  */
-export function buildRpcSessionState(session) {
+export function buildRpcSessionState(session, lastAbortSource) {
+    const cwd = session.sessionManager.getCwd();
+    // Trust gates project-source settings (shell prefixes, project resources), so every
+    // session state projection must have an authoritative store to consult.
+    if (!session.agentDir) {
+        throw new Error("RPC session invariant violated: agentDir is required");
+    }
+    const projectTrusted = new ProjectTrustStore(session.agentDir).get(cwd) === true;
     return {
         model: session.model,
         thinkingLevel: session.thinkingLevel,
+        ...(session.thinkingSelection ? { thinkingSelection: session.thinkingSelection } : {}),
+        ...(lastAbortSource ? { lastAbortSource } : {}),
         serviceTier: session.effectiveServiceTier,
         fastMode: session.isFastModeActive(),
         isStreaming: session.isStreaming,
         isCompacting: session.isCompacting,
+        retryAttempt: session.retryAttempt,
+        isBashRunning: session.isBashRunning,
         steeringMode: session.steeringMode,
         followUpMode: session.followUpMode,
         sessionFile: session.sessionFile,
         sessionId: session.sessionId,
         sessionName: session.sessionName,
+        cwd,
+        projectTrusted,
+        ...(session.sessionFile &&
+            !existsSync(session.sessionFile) &&
+            session.sessionManager
+                .getEntries()
+                .some((entry) => entry.type !== "model_change" && entry.type !== "thinking_level_change")
+            ? { entries: session.sessionManager.getEntries() }
+            : {}),
+        steering: typeof session.getSteeringMessages === "function" ? [...session.getSteeringMessages()] : [],
+        followUp: typeof session.getFollowUpMessages === "function" ? [...session.getFollowUpMessages()] : [],
+        ordered: [
+            ...(session._queuedInputOrder ?? []),
+        ].sort((a, b) => a.enqueueOrder - b.enqueueOrder),
         autoCompactionEnabled: session.autoCompactionEnabled,
         messageCount: session.messages.length,
         pendingMessageCount: session.pendingMessageCount,
+        usageTotals: session.sessionManager.getUsageTotals(),
+        contextUsage: typeof session.getContextUsage === "function" ? session.getContextUsage() : undefined,
+        favoriteModels: session.favoriteModels?.map((entry) => ({ ...entry })) ?? [],
+        scopedModels: session.scopedModels?.map((entry) => ({ ...entry })) ?? [],
     };
 }
 function loadedMcpServers(snapshot) {
@@ -113,12 +148,17 @@ function loadedSurfacesFingerprint(session, extensions, mcpServers) {
 export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
     const clientCapabilities = options.capabilities;
     const routingSessionId = options.sessionId;
+    // True only while THIS connection's own command drives a replacement; the issuer
+    // already learns the new identity from its command response.
+    let replacementIssuedHere = false;
     let session = runtimeHost.session;
     let unsubscribe;
     let unsubscribeBackpressure;
     let unsubscribeLoadedSurfaces;
     let unsubscribeExtensionEvents;
     let mcpWireStatus = { servers: [] };
+    /** Abort owner of the last settled turn; `session.currentAbortSource` clears on settle. */
+    let lastAbortSource;
     let loadedSurfacesDigest;
     let rpcCommandsDigest;
     let suppressLoadedSurfaceEvents = false;
@@ -191,8 +231,16 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
         }
         return { id, type: "response", command, success: true, data };
     };
-    const error = (id, command, message) => {
-        return { id, type: "response", command, success: false, error: message };
+    const error = (id, command, message, errorCode, errorData) => {
+        return {
+            id,
+            type: "response",
+            command,
+            success: false,
+            error: message,
+            ...(errorCode ? { errorCode } : {}),
+            ...(errorData === undefined ? {} : { errorData }),
+        };
     };
     // Pending extension UI requests waiting for response
     const pendingExtensionRequests = new SessionExtensionUiRequests();
@@ -280,7 +328,6 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             // Hidden thinking label not supported in RPC mode - requires TUI message rendering access
         },
         setWidget(key, content, options) {
-            // Only support string arrays in RPC mode - factory functions are ignored
             if (content === undefined || Array.isArray(content)) {
                 output({
                     type: "extension_ui_request",
@@ -290,8 +337,14 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     widgetLines: content,
                     widgetPlacement: options?.placement,
                 });
+                return;
             }
-            // Component factories are not supported in RPC mode - would need TUI access
+            // A component factory closes over live TUI/theme state and cannot cross
+            // the RPC boundary. Never drop it silently: an opted-in client can show
+            // the same explicit degradation notice used by ctx.ui.custom.
+            const request = buildCustomUnsupportedRequest(clientCapabilities, "widget component");
+            if (request)
+                output(request);
         },
         setFooter(_factory) {
             // Custom footer not supported in RPC mode - requires TUI access
@@ -417,19 +470,49 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
         }
     };
     runtimeHost.setRebindSession(async () => {
-        await rebindSession();
+        // AgentSessionRuntime invokes this callback while completing a replacement.
+        // Do not await extension binding here: extensions may wait for session work
+        // that the replacement still owns. The command response must acknowledge the
+        // committed replacement; derived surfaces refresh out of band afterwards.
+        await rebindSession(true);
     });
-    const rebindSession = async () => {
+    const rebindAfterLocalReplacement = async () => {
+        replacementIssuedHere = true;
+        try {
+            await rebindSession();
+        }
+        finally {
+            replacementIssuedHere = false;
+        }
+    };
+    const rebindSession = async (deferRefresh = false) => {
         unsubscribeLoadedSurfaces?.();
         unsubscribeExtensionEvents?.();
+        const replacedSession = session !== runtimeHost.session;
         session = runtimeHost.session;
+        if (replacedSession) {
+            lastAbortSource = undefined;
+            if (routingSessionId !== undefined || !replacementIssuedHere) {
+                // A replacement can be driven by ANY attached client, so every connection must be
+                // told the live binding moved and given the new authoritative identity. Emitted
+                // before the derived-surface refresh so a client cannot act on the old identity in
+                // the window the refresh takes.
+                outputEvent({
+                    type: "session_replaced",
+                    durableSessionId: session.sessionId,
+                    sessionFile: session.sessionFile,
+                    cwd: session.sessionManager.getCwd(),
+                    sessionName: session.sessionName,
+                });
+            }
+        }
         unsubscribeExtensionEvents = clientCapabilities?.includes(EXTENSION_EVENTS_CAPABILITY)
             ? session.extensionRunner.onRpcEvent(({ name, data }) => {
                 outputEvent({ type: "extension_event", name, data });
             })
             : undefined;
         subscribeLoadedSurfaceEvents();
-        await refreshLoadedSurfacesAfter(() => session.bindExtensions({
+        const refresh = refreshLoadedSurfacesAfter(() => session.bindExtensions({
             uiContext: createExtensionUIContext(),
             mode: "rpc",
             commandContextActions: {
@@ -474,22 +557,50 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 });
             },
         }), true);
-        unsubscribe?.();
-        unsubscribeBackpressure?.();
-        unsubscribe = session.subscribe((event) => {
-            if (event.type === "skill_invocation") {
-                outputEvent(event);
-                return;
-            }
-            if (event.type === "command_invocation") {
+        const installSessionSubscriptions = () => {
+            unsubscribe?.();
+            unsubscribeBackpressure?.();
+            unsubscribe = session.subscribe((event) => {
+                if (event.type === "skill_invocation") {
+                    outputEvent(event);
+                    return;
+                }
+                if (event.type === "command_invocation") {
+                    outputEvent(event);
+                    return;
+                }
+                if (event.type === "thinking_level_changed" || event.type === "model_changed") {
+                    // Core emits the effective level only; the selection provenance lives beside it
+                    // on the session and is what distinguishes an explicit choice from a default.
+                    const thinkingSelection = session.thinkingSelection;
+                    outputEvent(thinkingSelection === undefined ? event : { ...event, thinkingSelection });
+                    return;
+                }
+                if (event.type === "agent_end") {
+                    // The subscribe-path `agent_end` carries only { type, messages, willRetry };
+                    // the abort provenance the extension hook receives is stripped from it. Read
+                    // it from the session, which still reports the owner at this point, and retain
+                    // it for `get_state` because the getter clears once the turn settles.
+                    const abortSource = session.currentAbortSource;
+                    if (abortSource !== undefined)
+                        lastAbortSource = abortSource;
+                    outputEvent(abortSource === undefined ? event : { ...event, aborted: true, abortSource });
+                    return;
+                }
                 outputEvent(event);
-                return;
-            }
-            outputEvent(event);
-        });
-        unsubscribeBackpressure = session.agent.subscribe(async () => {
-            await waitForRpcBackpressure();
-        });
+            });
+            unsubscribeBackpressure = session.agent.subscribe(async () => {
+                await waitForRpcBackpressure();
+            });
+        };
+        if (deferRefresh) {
+            void refresh.then(installSessionSubscriptions, (cause) => {
+                outputEvent({ type: "rpc_error", error: String(cause) });
+            });
+            return;
+        }
+        await refresh;
+        installSessionSubscriptions();
     };
     /**
      * Drive an OAuth login for one provider as fire-command-then-subscribe.
@@ -597,6 +708,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     images: command.images,
                     streamingBehavior: command.streamingBehavior,
                     thinkingLevel: command.thinkingLevel,
+                    sessionTitlePrompt: command.sessionTitlePrompt,
+                    expandPromptTemplates: command.expandPromptTemplates,
                     source: "rpc",
                     promptDisposition: (nextDisposition) => {
                         disposition = nextDisposition;
@@ -615,34 +728,78 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 });
                 return undefined;
             }
+            case "append_user_message": {
+                const content = command.content;
+                const message = typeof content === "string"
+                    ? { role: "user", content, timestamp: Date.now() }
+                    : { role: "user", content, timestamp: Date.now() };
+                session.sessionManager.appendMessage(message);
+                session.agent.state.messages = session.sessionManager.buildSessionContext().messages;
+                return success(id, "append_user_message");
+            }
+            case "append_session_entry": {
+                session.appendSessionEntry(command.entry);
+                return success(id, "append_session_entry");
+            }
+            case "send_custom_message": {
+                await session.sendCustomMessage({
+                    customType: command.customType,
+                    content: command.content,
+                    display: command.display,
+                    details: command.details,
+                }, { triggerTurn: command.triggerTurn, deliverAs: command.deliverAs });
+                return success(id, "send_custom_message");
+            }
             case "steer": {
-                await session.steer(command.message, command.images);
+                await session.steer(command.message, command.images, { enqueueOrder: command.enqueueOrder });
                 return success(id, "steer");
             }
             case "follow_up": {
-                await session.followUp(command.message, command.images);
+                await session.followUp(command.message, command.images, { enqueueOrder: command.enqueueOrder });
                 return success(id, "follow_up");
             }
             case "abort": {
                 await session.abort();
                 return success(id, "abort");
             }
+            case "abort_compaction": {
+                session.abortCompaction();
+                return success(id, "abort_compaction");
+            }
+            case "reload": {
+                const result = await session.reload();
+                return success(id, "reload", result);
+            }
+            case "check_reload_veto": {
+                return success(id, "check_reload_veto", await session.checkReloadVeto());
+            }
             case "clear_queue": {
-                return success(id, "clear_queue", session.clearQueue());
+                const cleared = session.clearQueue({ abortWillFollow: command.abortWillFollow ?? false });
+                return success(id, "clear_queue", {
+                    steering: cleared.steering,
+                    followUp: cleared.followUp,
+                    ordered: [...cleared.ordered],
+                });
             }
+            case "get_steering_messages":
+                return success(id, "get_steering_messages", { messages: [...session.getSteeringMessages()] });
+            case "get_follow_up_messages":
+                return success(id, "get_follow_up_messages", { messages: [...session.getFollowUpMessages()] });
+            case "abort_branch_summary":
+                session.abortBranchSummary();
+                return success(id, "abort_branch_summary");
             case "new_session": {
                 const options = command.parentSession ? { parentSession: command.parentSession } : undefined;
                 const result = await runtimeHost.newSession(options);
-                if (!result.cancelled) {
-                    await rebindSession();
-                }
+                if (routingSessionId === undefined && !result.cancelled && session !== runtimeHost.session)
+                    await rebindAfterLocalReplacement();
                 return success(id, "new_session", result);
             }
             // =================================================================
             // State
             // =================================================================
             case "get_state":
-                return success(id, "get_state", buildRpcSessionState(session));
+                return success(id, "get_state", buildRpcSessionState(session, lastAbortSource));
             // =================================================================
             // Model
             // =================================================================
@@ -652,11 +809,17 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 if (!model) {
                     return error(id, "set_model", `Model not found: ${command.provider}/${command.modelId}`);
                 }
-                await session.setModel(model);
-                return success(id, "set_model", model);
+                const systemPromptChange = await session.setModel(model);
+                return success(id, "set_model", { ...model, systemPromptName: systemPromptChange?.systemPromptName });
             }
+            case "set_favorite_models":
+                session.setFavoriteModels(command.models);
+                return success(id, "set_favorite_models");
+            case "set_scoped_models":
+                session.setScopedModels(command.models);
+                return success(id, "set_scoped_models");
             case "cycle_model": {
-                const result = await session.cycleModel();
+                const result = await session.cycleModel(command.direction);
                 if (!result) {
                     return success(id, "cycle_model", null);
                 }
@@ -769,29 +932,60 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             // =================================================================
             // Bash
             // =================================================================
-            case "bash": {
-                const eventResult = await session.extensionRunner.emitUserBash({
-                    type: "user_bash",
-                    command: command.command,
-                    excludeFromContext: command.excludeFromContext ?? false,
-                    cwd: session.sessionManager.getCwd(),
+            case "navigate_tree": {
+                const result = await session.navigateTree(command.targetId, {
+                    summarize: command.summarize,
+                    customInstructions: command.customInstructions,
+                    replaceInstructions: command.replaceInstructions,
+                    label: command.label,
                 });
-                if (eventResult?.result) {
-                    session.recordBashResult(command.command, eventResult.result, {
+                return success(id, "navigate_tree", result);
+            }
+            case "record_bash_result":
+                session.recordBashResult(command.command, command.result, {
+                    excludeFromContext: command.excludeFromContext,
+                });
+                return success(id, "record_bash_result");
+            case "set_label":
+                session.sessionManager.appendLabelChange(command.entryId, command.label);
+                return success(id, "set_label");
+            case "bash": {
+                if (routingSessionId !== undefined)
+                    outputEvent({ type: "bash_start" });
+                try {
+                    const eventResult = await session.extensionRunner.emitUserBash({
+                        type: "user_bash",
+                        command: command.command,
+                        excludeFromContext: command.excludeFromContext ?? false,
+                        cwd: session.sessionManager.getCwd(),
+                    });
+                    if (eventResult?.result) {
+                        session.recordBashResult(command.command, eventResult.result, {
+                            excludeFromContext: command.excludeFromContext,
+                        });
+                        return success(id, "bash", eventResult.result);
+                    }
+                    const result = await session.executeBash(command.command, undefined, {
                         excludeFromContext: command.excludeFromContext,
+                        id: command.executionId,
+                        // Functions cannot cross JSONL. Host extensions may still provide the
+                        // executable operations object; client-supplied data is only a wire-safe hint.
+                        operations: eventResult?.operations,
                     });
-                    return success(id, "bash", eventResult.result);
+                    return success(id, "bash", result);
+                }
+                finally {
+                    if (routingSessionId !== undefined)
+                        outputEvent({ type: "bash_end" });
                 }
-                const result = await session.executeBash(command.command, undefined, {
-                    excludeFromContext: command.excludeFromContext,
-                    operations: eventResult?.operations,
-                });
-                return success(id, "bash", result);
             }
             case "abort_bash": {
                 session.abortBash();
                 return success(id, "abort_bash");
             }
+            case "cleanup_bash_output":
+                await session.cleanupBashOutput(command.path);
+                return success(id, "cleanup_bash_output");
             // =================================================================
             // Session
             // =================================================================
@@ -800,21 +994,22 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 return success(id, "get_session_stats", stats);
             }
             case "export_html": {
-                const path = await session.exportToHtml(command.outputPath);
+                const path = await session.exportToHtml(command.outputPath, { themeName: command.themeName });
                 return success(id, "export_html", { path });
             }
+            case "export_jsonl": {
+                return success(id, "export_jsonl", { path: session.exportToJsonl(command.outputPath) });
+            }
             case "switch_session": {
-                const result = await runtimeHost.switchSession(command.sessionPath);
-                if (!result.cancelled) {
-                    await rebindSession();
-                }
+                const result = await runtimeHost.switchSession(command.sessionPath, { cwdOverride: command.cwdOverride });
+                if (routingSessionId === undefined && !result.cancelled && session !== runtimeHost.session)
+                    await rebindAfterLocalReplacement();
                 return success(id, "switch_session", result);
             }
             case "fork": {
-                const result = await runtimeHost.fork(command.entryId);
-                if (!result.cancelled) {
-                    await rebindSession();
-                }
+                const result = await runtimeHost.fork(command.entryId, { position: command.position });
+                if (routingSessionId === undefined && !result.cancelled && session !== runtimeHost.session)
+                    await rebindAfterLocalReplacement();
                 return success(id, "fork", { text: result.selectedText, cancelled: result.cancelled });
             }
             case "clone": {
@@ -823,9 +1018,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     return error(id, "clone", "Cannot clone session: no current entry selected");
                 }
                 const result = await runtimeHost.fork(leafId, { position: "at" });
-                if (!result.cancelled) {
-                    await rebindSession();
-                }
+                if (routingSessionId === undefined && !result.cancelled && session !== runtimeHost.session)
+                    await rebindAfterLocalReplacement();
                 return success(id, "clone", { cancelled: result.cancelled });
             }
             case "get_fork_messages": {
@@ -852,6 +1046,12 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 const text = session.getLastAssistantText();
                 return success(id, "get_last_assistant_text", { text });
             }
+            case "import_jsonl": {
+                const result = await runtimeHost.importFromJsonl(command.inputPath, command.cwdOverride);
+                if (routingSessionId === undefined && !result.cancelled && session !== runtimeHost.session)
+                    await rebindAfterLocalReplacement();
+                return success(id, "import_jsonl", result);
+            }
             case "set_session_name": {
                 const name = command.name.trim();
                 if (!name) {
@@ -971,9 +1171,10 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             return;
         }
         const command = parsed;
+        const payloadError = rpcCommandPayloadError(command);
         const messageLengthError = rpcMessageLengthError(command);
-        if (messageLengthError) {
-            output(error(command.id, command.type, messageLengthError));
+        if (payloadError || messageLengthError) {
+            output(error(command.id, command.type, payloadError ?? messageLengthError));
             await waitForRpcBackpressure();
             return;
         }
@@ -985,7 +1186,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             }
         }
         catch (commandError) {
-            output(error(command.id, command.type, commandError instanceof Error ? commandError.message : String(commandError)));
+            const missingCwd = commandError instanceof Error && commandError.name === "MissingSessionCwdError" && "issue" in commandError;
+            output(error(command.id, command.type, commandError instanceof Error ? commandError.message : String(commandError), missingCwd ? "missing_session_cwd" : undefined, missingCwd ? commandError.issue : undefined));
             await waitForRpcBackpressure();
         }
     };
@@ -1016,6 +1218,9 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
         isShutdownRequested() {
             return shutdownRequested;
         },
+        cancelPendingExtensionUiRequests() {
+            pendingExtensionRequests.cancelAll();
+        },
         async dispose() {
             await ready;
             await dispose();