@code-yeongyu/senpi 2026.8.29 → 2026.8.30-3

package/dist/modes/interactive/interactive-host-runtime.js

@@ -1,9 +1,12 @@
+import { randomUUID } from "node:crypto";
+import { rm } from "node:fs/promises";
 import { executeBashWithOperations } from "../../core/bash-executor.js";
 import { SessionManager } from "../../core/session-manager.js";
 import { SettingsManager } from "../../core/settings-manager.js";
 import { ensureHost } from "../rpc/host-ensure.js";
-import { RpcClient } from "../rpc/rpc-client.js";
+import { isTransportGoneError, RpcClient } from "../rpc/rpc-client.js";
 export const INTERACTIVE_HOST_FALLBACK_WARNING = "Warning: shared interactive host unavailable; continuing locally";
+export const INTERACTIVE_HOST_RECONNECTING_WARNING = "Warning: shared interactive host connection lost; reconnecting";
 /**
  * Replace only the transport-facing session operations. The object returned is
  * deliberately still an AgentSessionRuntime: InteractiveMode and extensions
@@ -15,7 +18,82 @@ export async function createInteractiveHostRuntime(localRuntime, options) {
     if (!sessionPath)
         return localRuntime;
     const startHost = options.ensureHost ?? ((hostOptions) => ensureHost(hostOptions));
-    const client = new RpcClient({ socketPath: options.socket });
+    let remoteSession;
+    let remoteRuntime;
+    let reconnecting;
+    let disconnectQueued = false;
+    let disposed = false;
+    let fallbackWarned = false;
+    let reconnectWarningShown = false;
+    const warnReconnect = (cause) => {
+        if (reconnectWarningShown)
+            return;
+        reconnectWarningShown = true;
+        options.onWarning?.({
+            type: "interactive_host_action_failed",
+            message: INTERACTIVE_HOST_RECONNECTING_WARNING,
+            cause,
+        });
+    };
+    const warnFallback = (cause) => {
+        if (fallbackWarned)
+            return;
+        fallbackWarned = true;
+        options.onWarning?.({ type: "interactive_host_fallback", message: INTERACTIVE_HOST_FALLBACK_WARNING, cause });
+    };
+    let scheduleReconnect = () => { };
+    const client = new RpcClient({
+        socketPath: options.socket,
+        onDisconnect: () => {
+            disconnectQueued = true;
+            scheduleReconnect();
+        },
+    });
+    scheduleReconnect = () => {
+        if (!remoteSession || reconnecting || disposed || remoteRuntime?.isFallback)
+            return;
+        remoteRuntime?.enterReconnecting();
+        reconnecting = (async () => {
+            let cause;
+            for (let attempt = 0; attempt < 3; attempt++) {
+                if (disposed)
+                    return;
+                disconnectQueued = false;
+                try {
+                    await startHost({ socket: options.socket, agentDir: options.agentDir });
+                    if (disposed)
+                        return;
+                    await client.start();
+                    if (disposed)
+                        return;
+                    await client.openSession({ sessionPath, cwd: localRuntime.cwd });
+                    if (disposed)
+                        return;
+                    await remoteSession.refresh();
+                    if (disposed)
+                        return;
+                    fallbackWarned = false;
+                    reconnectWarningShown = false;
+                    remoteRuntime?.enterConnected();
+                    return;
+                }
+                catch (error) {
+                    cause = error;
+                    await client.stop().catch(() => { });
+                    if (disposed)
+                        return;
+                }
+            }
+            if (!disposed) {
+                await remoteRuntime?.enterFallback();
+                warnFallback(cause);
+            }
+        })().finally(() => {
+            reconnecting = undefined;
+            if (disconnectQueued && !disposed && !remoteRuntime?.isFallback)
+                scheduleReconnect();
+        });
+    };
     try {
         await startHost({ socket: options.socket, agentDir: options.agentDir });
         await client.start();
@@ -26,38 +104,108 @@ export async function createInteractiveHostRuntime(localRuntime, options) {
             modelId: localRuntime.session.model?.id,
             thinkingLevel: localRuntime.session.thinkingLevel,
         });
-        const remoteSession = createRemoteSessionProxy(localRuntime.session, localRuntime.services.agentDir, client, opened.state, options.onWarning);
-        return new RemoteInteractiveRuntime(localRuntime, remoteSession, client);
+        remoteSession = createRemoteSessionProxy(localRuntime.session, localRuntime.services.agentDir, client, opened.state, options.onWarning, (cause) => {
+            if (remoteRuntime?.isReconnecting)
+                warnReconnect(cause);
+            else
+                warnFallback(cause);
+        });
+        if (opened.state.isBashRunning && !opened.attached) {
+            // Only a newly opened session can have an execution orphaned by a
+            // previous connection. An attach is an observer of the same live runtime;
+            // aborting it would cancel work owned by the surviving attachment.
+            await client.abortBash().catch(() => { });
+        }
+        if (opened.attached)
+            await remoteSession.refresh();
+        remoteRuntime = new RemoteInteractiveRuntime(localRuntime, remoteSession, client, {
+            onTransportGone: (cause) => {
+                if (remoteRuntime?.isReconnecting)
+                    warnReconnect(cause);
+                else
+                    warnFallback(cause);
+            },
+            get reconnecting() {
+                return reconnecting;
+            },
+            dispose: () => {
+                disposed = true;
+            },
+        });
+        return remoteRuntime;
     }
     catch (cause) {
         await client.stop().catch(() => { });
-        options.onWarning?.({
-            type: "interactive_host_fallback",
-            message: `${INTERACTIVE_HOST_FALLBACK_WARNING}: ${cause instanceof Error ? cause.message : String(cause)}`,
-            cause,
-        });
+        warnFallback(cause);
         return localRuntime;
     }
 }
-class RemoteInteractiveRuntime {
+export class RemoteInteractiveRuntime {
     #local;
     #remoteSession;
     #client;
+    #lifecycle;
+    #onTransportGone;
     #rebindSession;
     #beforeSessionInvalidate;
-    constructor(local, remoteSession, client) {
+    #state = "connected";
+    #fallbackHandoff;
+    get isReconnecting() {
+        return this.#state === "reconnecting";
+    }
+    get isFallback() {
+        return this.#state === "fallback";
+    }
+    constructor(local, remoteSession, client, lifecycle) {
         this.#local = local;
         this.#remoteSession = remoteSession;
         this.#client = client;
+        this.#lifecycle = lifecycle;
+        this.#onTransportGone = lifecycle?.onTransportGone ?? (() => { });
+    }
+    async #call(call) {
+        try {
+            return await call();
+        }
+        catch (error) {
+            if (isTransportGoneError(error)) {
+                this.#onTransportGone(error);
+                return { cancelled: true };
+            }
+            throw error;
+        }
+    }
+    enterConnected() {
+        if (this.#state !== "disposed" && this.#state !== "fallback")
+            this.#state = "connected";
+    }
+    enterReconnecting() {
+        if (this.#state !== "disposed" && this.#state !== "fallback")
+            this.#state = "reconnecting";
+    }
+    async enterFallback() {
+        if (this.#state === "disposed" || this.#state === "fallback")
+            return;
+        this.#state = "fallback";
+        this.#beforeSessionInvalidate?.();
+        const rebind = this.#rebindSession?.();
+        if (rebind) {
+            this.#fallbackHandoff = rebind.catch((error) => {
+                this.#onTransportGone(error);
+            });
+            await this.#fallbackHandoff;
+        }
     }
     get session() {
-        return this.#remoteSession.session;
+        return this.#state === "fallback" || this.#state === "disposed"
+            ? this.#local.session
+            : this.#remoteSession.session;
     }
     get services() {
         return this.#local.services;
     }
     get cwd() {
-        return this.#remoteSession.session.sessionManager.getCwd();
+        return this.session.sessionManager.getCwd();
     }
     get diagnostics() {
         return this.#local.diagnostics;
@@ -70,90 +218,238 @@ class RemoteInteractiveRuntime {
     }
     setBeforeSessionInvalidate(callback) {
         this.#beforeSessionInvalidate = callback;
+        this.#local.setBeforeSessionInvalidate(callback);
     }
     setRebindSession(callback) {
         this.#rebindSession = callback;
+        this.#local.setRebindSession(callback);
+        if (callback && this.#state === "fallback" && !this.#fallbackHandoff) {
+            this.#fallbackHandoff = callback().catch((error) => {
+                this.#onTransportGone(error);
+            });
+        }
+    }
+    setHostUiHandler(callback) {
+        this.#remoteSession.setHostUiHandler(callback);
     }
     async dispose() {
-        await this.#client.closeSession();
-        await this.#client.stop();
-        await this.#local.dispose();
+        if (this.#state === "disposed")
+            return;
+        this.#state = "disposed";
+        this.#lifecycle?.dispose();
+        await this.#lifecycle?.reconnecting?.catch(() => { });
+        await this.#fallbackHandoff?.catch(() => { });
+        const errors = [];
+        for (const cleanup of [
+            () => this.#remoteSession.abortLocalBash(),
+            () => this.#client.closeSession(),
+            () => this.#client.stop(),
+            () => this.#local.dispose(),
+        ]) {
+            try {
+                await cleanup();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (errors.length > 0)
+            throw errors[0];
     }
     async newSession(options) {
-        const result = await this.#client.newSession(options?.parentSession);
-        if (!result.cancelled) {
-            this.#beforeSessionInvalidate?.();
-            this.#remoteSession.abortLocalBash();
-            await this.#remoteSession.refresh();
-            if (options?.setup) {
-                const capture = SessionManager.inMemory(this.#remoteSession.session.sessionManager.getCwd());
-                await options.setup(capture);
-                for (const entry of capture.getEntries())
-                    await this.#client.appendSessionEntry(entry);
+        if (this.#state === "fallback")
+            return this.#local.newSession(options);
+        // Suppresses for the ENTIRE command, not just the refresh tail: a
+        // multi-session host emits session_replaced while completing it, so the echo
+        // can arrive before the refresh/rebind sequence below starts and race it -
+        // newSession transports setup entries between two refreshes.
+        return this.#remoteSession
+            .aroundLocalReplacement(async () => {
+            const result = await this.#call(() => this.#client.newSession(options?.parentSession));
+            if (!result.cancelled) {
+                this.#beforeSessionInvalidate?.();
+                this.#remoteSession.abortLocalBash();
                 await this.#remoteSession.refresh();
+                if (options?.setup) {
+                    const capture = SessionManager.inMemory(this.#remoteSession.session.sessionManager.getCwd());
+                    await options.setup(capture);
+                    for (const entry of capture.getEntries())
+                        await this.#client.appendSessionEntry(entry);
+                    await this.#remoteSession.refresh();
+                }
+                await this.#rebindSession?.();
+                if (options?.withSession)
+                    await options.withSession(this.#remoteSession.createReplacedSessionContext());
             }
-            await this.#rebindSession?.();
-            if (options?.withSession)
-                await options.withSession(this.#remoteSession.createReplacedSessionContext());
-        }
-        return result;
+            return result;
+        })
+            .catch((error) => {
+            if (isTransportGoneError(error))
+                return { cancelled: true };
+            throw error;
+        });
     }
     async switchSession(sessionPath, options) {
-        const result = await this.#client.switchSession(sessionPath, options);
-        if (!result.cancelled) {
-            this.#beforeSessionInvalidate?.();
-            this.#remoteSession.abortLocalBash();
-            await this.#remoteSession.refresh();
-            await this.#rebindSession?.();
-            // The shared host already resolved trust; this callback is retained for
-            // compatibility, but its result cannot override host-authoritative state.
-            options?.projectTrustContextFactory?.(this.#remoteSession.session.sessionManager.getCwd());
-            if (options?.withSession)
-                await options.withSession(this.#remoteSession.createReplacedSessionContext());
-        }
-        return result;
+        if (this.#state === "fallback")
+            return this.#local.switchSession(sessionPath, options);
+        // See newSession: the suppression must cover the command itself, since the
+        // host emits session_replaced while completing it.
+        return this.#remoteSession
+            .aroundLocalReplacement(async () => {
+            const result = await this.#call(() => this.#client.switchSession(sessionPath, options?.cwdOverride === undefined ? undefined : { cwdOverride: options.cwdOverride }));
+            if (!result.cancelled) {
+                this.#beforeSessionInvalidate?.();
+                this.#remoteSession.abortLocalBash();
+                await this.#remoteSession.refresh();
+                await this.#rebindSession?.();
+                // The shared host already resolved trust; this callback is retained for
+                // compatibility, but its result cannot override host-authoritative state.
+                options?.projectTrustContextFactory?.(this.#remoteSession.session.sessionManager.getCwd());
+                if (options?.withSession)
+                    await options.withSession(this.#remoteSession.createReplacedSessionContext());
+            }
+            return result;
+        })
+            .catch((error) => {
+            if (isTransportGoneError(error))
+                return { cancelled: true };
+            throw error;
+        });
     }
     async fork(entryId, options) {
-        const result = await this.#client.fork(entryId, options);
-        if (!result.cancelled) {
-            this.#beforeSessionInvalidate?.();
-            this.#remoteSession.abortLocalBash();
-            await this.#refreshAndRebind();
-            if (options?.withSession)
-                await options.withSession(this.#remoteSession.createReplacedSessionContext());
-        }
-        return { cancelled: result.cancelled, selectedText: result.text };
+        if (this.#state === "fallback")
+            return this.#local.fork(entryId, options);
+        // See newSession: the suppression must cover the command itself.
+        return this.#remoteSession
+            .aroundLocalReplacement(async () => {
+            const result = await this.#call(() => this.#client.fork(entryId, options));
+            if (!result.cancelled) {
+                this.#beforeSessionInvalidate?.();
+                this.#remoteSession.abortLocalBash();
+                await this.#refreshAndRebind();
+                if (options?.withSession)
+                    await options.withSession(this.#remoteSession.createReplacedSessionContext());
+            }
+            return { cancelled: result.cancelled, selectedText: result.text };
+        })
+            .catch((error) => {
+            if (isTransportGoneError(error))
+                return { cancelled: true };
+            throw error;
+        });
     }
     async importFromJsonl(inputPath, cwdOverride) {
-        const result = await this.#client.importJsonl(inputPath, cwdOverride);
-        if (!result.cancelled) {
-            this.#beforeSessionInvalidate?.();
-            this.#remoteSession.abortLocalBash();
-            await this.#refreshAndRebind();
-        }
-        return result;
+        if (this.#state === "fallback")
+            return this.#local.importFromJsonl(inputPath, cwdOverride);
+        // See newSession: the suppression must cover the command itself.
+        return this.#remoteSession
+            .aroundLocalReplacement(async () => {
+            const result = await this.#call(() => this.#client.importJsonl(inputPath, cwdOverride));
+            if (!result.cancelled) {
+                this.#beforeSessionInvalidate?.();
+                this.#remoteSession.abortLocalBash();
+                await this.#refreshAndRebind();
+            }
+            return result;
+        })
+            .catch((error) => {
+            if (isTransportGoneError(error))
+                return { cancelled: true };
+            throw error;
+        });
     }
     async #refreshAndRebind() {
         await this.#remoteSession.refresh();
         await this.#rebindSession?.();
     }
 }
-function createRemoteSessionProxy(local, agentDir, client, initialState, onWarning) {
+/** Exported for direct coverage of the wire-event handling below. */
+export function createRemoteSessionProxy(local, agentDir, client, initialState, onWarning, onTransportGone) {
     // Fire-and-forget setters keep the sync AgentSession signature, but their RPC
     // failures must not vanish: the matching *_changed wire event confirms success,
     // and a rejection here is the only signal of failure.
     const reportActionFailure = (action) => (error) => {
-        onWarning?.({
-            type: "interactive_host_action_failed",
-            message: `Warning: shared interactive host ${action} failed: ${error instanceof Error ? error.message : String(error)}`,
-            cause: error,
-        });
+        const transportGone = isTransportGoneError(error);
+        if (transportGone)
+            onTransportGone?.(error);
+        else
+            onWarning?.({
+                type: "interactive_host_action_failed",
+                message: `Warning: shared interactive host ${action} failed: ${error instanceof Error ? error.message : String(error)}`,
+                cause: error,
+            });
+    };
+    const transportCall = async (action, call, cancelledValue) => {
+        try {
+            return await call();
+        }
+        catch (error) {
+            if (!isTransportGoneError(error))
+                throw error;
+            reportActionFailure(action)(error);
+            return cancelledValue;
+        }
     };
     let state = { ...initialState };
-    let bashChunk;
+    const waitForBashCallbacks = async (promises, allowAbandonment) => {
+        if (promises.size === 0)
+            return true;
+        const settled = Promise.allSettled([...promises]).then(() => true);
+        let timeout;
+        const bounded = new Promise((resolve) => {
+            timeout = setTimeout(resolve, allowAbandonment ? 100 : 5_000, false);
+            timeout.unref?.();
+        });
+        try {
+            return await Promise.race([settled, bounded]);
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+        }
+    };
+    const executionNamespace = randomUUID();
+    const cleanupRemoteBashOutput = async (path) => {
+        let cleanupTimeout;
+        try {
+            await Promise.race([
+                client.cleanupBashOutput(path),
+                new Promise((_, reject) => {
+                    cleanupTimeout = setTimeout(() => reject(new Error("RPC cleanup timed out")), 1_000);
+                }),
+            ]);
+            return;
+        }
+        catch (transportError) {
+            // Spill paths are shared host filesystem paths. If the RPC transport is
+            // already unavailable, remove locally as a bounded best-effort fallback;
+            // a later reconnect is not required to prevent this callback failure from
+            // permanently leaking the host-owned artifact.
+            try {
+                await rm(path, { force: true });
+                return;
+            }
+            catch (localError) {
+                onWarning?.({
+                    type: "interactive_host_action_failed",
+                    message: `Warning: failed to clean up shared bash output spill: ${localError instanceof Error ? localError.message : String(localError)}`,
+                    cause: new AggregateError([transportError, localError]),
+                });
+            }
+        }
+        finally {
+            if (cleanupTimeout)
+                clearTimeout(cleanupTimeout);
+        }
+    };
+    let nextBashExecutionId = 0;
+    const bashExecutions = new Map();
+    let hostUiHandler;
+    const pendingUiRequests = [];
     let localBashAbortController;
     let localBashRunning = false;
     let hostBashRunning = initialState.isBashRunning;
+    let nextQueuedInputOrder = Math.max(0, ...initialState.ordered.map((item) => item.enqueueOrder));
     let sessionManager = local.sessionManager;
     let settingsManager = SettingsManager.create(initialState.cwd, agentDir, {
         projectTrusted: initialState.projectTrusted,
@@ -164,8 +460,10 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
     const remoteSessionManager = new Proxy({}, {
         get(_target, property, _receiver) {
             if (property === "appendLabelChange") {
-                return (entryId, label) => void client.setLabel(entryId, label);
+                return (entryId, label) => void client.setLabel(entryId, label).catch(reportActionFailure("appendLabelChange"));
             }
+            if (property === "getCwd")
+                return () => state.cwd;
             if (property === "getSessionName")
                 return () => state.sessionName;
             if (property === "getUsageTotals")
@@ -176,8 +474,38 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
     });
     let streamingAssistant;
     let mirroredCurrentAssistantUsage = false;
+    /** Non-zero while this runtime is driving its own replacement sequence. */
+    let localReplacementDepth = 0;
     const listeners = new Set();
     client.onEvent((wireEvent) => {
+        if (wireEvent.type === "extension_ui_request") {
+            const request = wireEvent;
+            if (hostUiHandler)
+                void Promise.resolve(hostUiHandler(request))
+                    .then((response) => response && client.sendExtensionUIResponse(response))
+                    .catch(reportActionFailure("host UI response"));
+            else
+                pendingUiRequests.push(request);
+            return;
+        }
+        if (wireEvent.type === "session_replaced") {
+            // The host swapped the live session behind this connection - another
+            // attached client issued the replacement, or an extension drove one that no
+            // client issued. Nothing else re-reads the binding, so without this the
+            // proxy keeps serving the previous session's manager, settings and message
+            // mirror while the host has already moved on. The command response carries
+            // only `{ cancelled }`, so this event is the only signal available here.
+            //
+            // A multi-session host broadcasts the event to every connection including
+            // the one that issued the replacement, and this runtime's own replacement
+            // methods already run an ordered refresh/rebind - newSession additionally
+            // transports setup entries between two refreshes. Refreshing again from
+            // here would race that sequence, so self-driven replacements are skipped.
+            if (localReplacementDepth === 0) {
+                void refresh().catch(reportActionFailure("session refresh after replacement"));
+            }
+            return;
+        }
         if (wireEvent.type === "agent_settled")
             state = { ...state, isStreaming: false, retryAttempt: 0 };
         if (wireEvent.type === "bash_start") {
@@ -188,8 +516,30 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
             hostBashRunning = false;
             updateBashState();
         }
-        if (wireEvent.type === "bash_execution_update")
-            bashChunk?.(wireEvent.delta);
+        if (wireEvent.type === "bash_execution_update" && wireEvent.id) {
+            const execution = bashExecutions.get(wireEvent.id);
+            if (execution?.chunk && !execution.hasError) {
+                try {
+                    const callbackPromise = Promise.resolve(execution.chunk(wireEvent.delta)).catch((error) => {
+                        if (!execution.hasError) {
+                            execution.error = error;
+                            execution.hasError = true;
+                            void client.abortBash().catch(() => { });
+                        }
+                        throw error;
+                    });
+                    execution.promises.add(callbackPromise);
+                    void callbackPromise.catch(() => { }).finally(() => execution.promises.delete(callbackPromise));
+                }
+                catch (error) {
+                    if (!execution.hasError) {
+                        execution.error = error;
+                        execution.hasError = true;
+                        void client.abortBash().catch(() => { });
+                    }
+                }
+            }
+        }
         if (wireEvent.type === "agent_start")
             state = { ...state, isStreaming: true };
         if (wireEvent.type === "compaction_start")
@@ -201,6 +551,7 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
         if (wireEvent.type === "auto_retry_end")
             state = { ...state, retryAttempt: 0 };
         if (wireEvent.type === "queue_update") {
+            nextQueuedInputOrder = Math.max(nextQueuedInputOrder, ...wireEvent.ordered.map((item) => item.enqueueOrder));
             state = {
                 ...state,
                 steering: [...wireEvent.steering],
@@ -217,6 +568,23 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
         if (wireEvent.type === "service_tier_changed") {
             state = { ...state, serviceTier: wireEvent.tier, fastMode: wireEvent.fastMode };
         }
+        if (wireEvent.type === "session_settings_changed") {
+            state = {
+                ...state,
+                steeringMode: wireEvent.steeringMode,
+                followUpMode: wireEvent.followUpMode,
+                autoCompactionEnabled: wireEvent.autoCompactionEnabled,
+            };
+        }
+        if (wireEvent.type === "entry_appended") {
+            try {
+                sessionManager.appendEntry(wireEvent.entry);
+                local.agent.state.messages = sessionManager.buildSessionContext().messages;
+            }
+            catch {
+                // Non-fatal if the local snapshot cannot accept a concurrent entry.
+            }
+        }
         if (wireEvent.type === "session_info_changed")
             state = { ...state, sessionName: wireEvent.name };
         if (wireEvent.type === "message_start") {
@@ -233,8 +601,13 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
                 if (usage && !mirroredCurrentAssistantUsage) {
                     mirroredCurrentAssistantUsage = true;
                     const latestPromptTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+                    const contextWindow = state.model?.contextWindow ?? 0;
+                    const contextTokens = usage.input + usage.cacheRead + usage.cacheWrite;
                     state = {
                         ...state,
+                        contextUsage: contextWindow > 0
+                            ? { tokens: contextTokens, contextWindow, percent: (contextTokens / contextWindow) * 100 }
+                            : undefined,
                         usageTotals: {
                             ...state.usageTotals,
                             input: state.usageTotals.input + usage.input,
@@ -254,7 +627,9 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
         }
         if (wireEvent.type === "compaction_end" && wireEvent.accepted && !wireEvent.aborted) {
             try {
-                sessionManager.reloadFromDisk?.();
+                local.sessionManager.reloadFromDisk?.();
+                if (sessionManager !== local.sessionManager)
+                    sessionManager.reloadFromDisk?.();
                 local.agent.state.messages = sessionManager.buildSessionContext().messages;
             }
             catch {
@@ -265,43 +640,109 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
         for (const listener of listeners)
             listener(event);
     });
-    const refresh = async () => {
-        const nextState = await client.getState();
+    const performRefresh = async () => {
+        // Captured before the first await: entries that arrive via `entry_appended`
+        // while this refresh is in flight are newer than the snapshot it reconciles
+        // against, and must survive the rebuild below.
+        const idsAtRefreshStart = new Set(sessionManager.getEntries().map((entry) => entry.id));
+        const nextState = await transportCall("refresh", () => client.getState());
+        if (!nextState)
+            return;
         state = { ...stateFromRpc(nextState) };
+        nextQueuedInputOrder = Math.max(0, ...nextState.ordered.map((item) => item.enqueueOrder));
         let messages;
         settingsManager = SettingsManager.create(nextState.cwd, agentDir, {
             projectTrusted: nextState.projectTrusted,
         });
         if (nextState.sessionFile) {
-            // SessionManager.open retains the explicit path even when the host has
-            // deferred creating the file for a setup-only session.
-            sessionManager = SessionManager.open(nextState.sessionFile, undefined, nextState.cwd);
-            if (nextState.entries?.length && !sessionManager.getEntries().length) {
-                for (const entry of nextState.entries)
-                    sessionManager.appendEntry(entry);
+            // Keep the caller-owned manager identity when refreshing the same session.
+            // Navigation and host-side mutations must update every existing mirror, not
+            // leave the interactive runtime holding the pre-refresh snapshot.
+            if (sessionManager.getSessionFile() === nextState.sessionFile) {
+                sessionManager.reloadFromDisk?.();
+            }
+            else {
+                // SessionManager.open retains the explicit path even when the host has
+                // deferred creating the file for a setup-only session.
+                sessionManager = SessionManager.open(nextState.sessionFile, undefined, nextState.cwd);
+            }
+            // The host ships its complete entry list while the session file is still
+            // deferred (no assistant message yet, so nothing has been written), which
+            // makes that list the only authoritative view of the session. Reconcile the
+            // mirror to it exactly: `entry_appended` notifications that cross a
+            // concurrent refresh land on whichever manager is current, so the mirror
+            // can hold an arbitrary partial set rather than a prefix, and a snapshot
+            // taken mid-bind can simply be short. Backfilling only an empty mirror
+            // wedged it at whatever partial set it happened to hold.
+            const authoritative = nextState.entries;
+            if (authoritative?.length) {
+                const mirror = sessionManager.getEntries();
+                const matches = mirror.length === authoritative.length &&
+                    mirror.every((entry, index) => entry.id === authoritative[index]?.id);
+                if (!matches) {
+                    const rebuilt = SessionManager.open(nextState.sessionFile, undefined, nextState.cwd);
+                    for (const entry of authoritative)
+                        rebuilt.appendEntry(entry);
+                    // A notification that crossed this refresh refers to an entry the
+                    // snapshot predates, so it is newer than the snapshot; dropping it
+                    // would strand the entry until an unrelated refresh happened to
+                    // run. Keep it, in arrival order, after the authoritative list.
+                    const authoritativeIds = new Set(authoritative.map((entry) => entry.id));
+                    for (const entry of mirror) {
+                        if (!idsAtRefreshStart.has(entry.id) && !authoritativeIds.has(entry.id)) {
+                            rebuilt.appendEntry(entry);
+                        }
+                    }
+                    sessionManager = rebuilt;
+                }
             }
             messages = sessionManager.buildSessionContext().messages;
         }
         else {
-            messages = await client.getMessages();
+            messages = await transportCall("refresh", () => client.getMessages(), []);
         }
         local.agent.state.messages.splice(0, local.agent.state.messages.length, ...structuredClone(messages));
         streamingAssistant = undefined;
     };
+    // Refreshes must not interleave: each one reassigns sessionManager,
+    // settingsManager and the mirrored message list, so two in flight can commit a
+    // mixed snapshot of two different sessions. A replacement-driven refresh races
+    // exactly that way against a caller-driven one, so run them in order.
+    let refreshChain = Promise.resolve();
+    const refresh = () => {
+        const next = refreshChain.then(performRefresh, performRefresh);
+        refreshChain = next.then(() => { }, () => { });
+        return next;
+    };
     const session = new Proxy(local, {
         get(target, property, receiver) {
             if (property === "prompt")
-                return (message, options) => client.prompt(message, {
-                    ...(options?.images ? { images: options.images } : {}),
-                    ...(options?.streamingBehavior ? { streamingBehavior: options.streamingBehavior } : {}),
-                    ...(options?.thinkingLevel ? { thinkingLevel: options.thinkingLevel } : {}),
-                    ...(options?.promptDisposition ? { promptDisposition: options.promptDisposition } : {}),
-                    ...(options?.preflightResult ? { preflightResult: options.preflightResult } : {}),
-                });
+                return async (message, options) => {
+                    try {
+                        await client.prompt(message, {
+                            ...(options?.images ? { images: options.images } : {}),
+                            ...(options?.streamingBehavior ? { streamingBehavior: options.streamingBehavior } : {}),
+                            ...(options?.thinkingLevel ? { thinkingLevel: options.thinkingLevel } : {}),
+                            ...(options?.sessionTitlePrompt !== undefined
+                                ? { sessionTitlePrompt: options.sessionTitlePrompt }
+                                : {}),
+                            ...(options?.expandPromptTemplates !== undefined
+                                ? { expandPromptTemplates: options.expandPromptTemplates }
+                                : {}),
+                            ...(options?.promptDisposition ? { promptDisposition: options.promptDisposition } : {}),
+                            ...(options?.preflightResult ? { preflightResult: options.preflightResult } : {}),
+                        });
+                    }
+                    catch (error) {
+                        if (!isTransportGoneError(error))
+                            throw error;
+                        reportActionFailure("prompt")(error);
+                    }
+                };
             if (property === "abort")
                 return () => client.abort();
             if (property === "abortCompaction")
-                return () => void client.abortCompaction();
+                return () => void client.abortCompaction().catch(reportActionFailure("abortCompaction"));
             if (property === "steer")
                 return (message, images, recovery) => {
                     const enqueueOrder = recovery?.enqueueOrder ?? Math.max(0, ...state.ordered.map((item) => item.enqueueOrder)) + 1;
@@ -311,7 +752,7 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
                         ordered: [...state.ordered, { text: message, mode: "steer", enqueueOrder }],
                         pendingMessageCount: state.pendingMessageCount + 1,
                     };
-                    return client.steer(message, images, { ...recovery, enqueueOrder });
+                    return transportCall("steer", () => client.steer(message, images, { ...recovery, enqueueOrder }));
                 };
             if (property === "followUp")
                 return (message, images, recovery) => {
@@ -322,31 +763,53 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
                         ordered: [...state.ordered, { text: message, mode: "followUp", enqueueOrder }],
                         pendingMessageCount: state.pendingMessageCount + 1,
                     };
-                    return client.followUp(message, images, { ...recovery, enqueueOrder });
+                    return transportCall("followUp", () => client.followUp(message, images, { ...recovery, enqueueOrder }));
                 };
             if (property === "waitForIdle")
                 return () => client.waitForIdle();
             if (property === "getLastAssistantText")
                 return () => target.getLastAssistantText();
-            if (property === "setModel")
+            if (property === "setModel" || property === "setSessionModel")
                 return async (model) => {
-                    const next = await client.setModel(model.provider, model.id);
-                    return { systemPromptName: next.systemPromptName, model: next };
+                    const next = await transportCall("setModel", () => client.setModel(model.provider, model.id), undefined);
+                    return next ? { systemPromptName: next.systemPromptName, model: next } : undefined;
+                };
+            if (property === "setSessionThinkingLevel")
+                return (level) => void client
+                    .setThinkingLevel(level, { scope: "turn" })
+                    .catch(reportActionFailure("setSessionThinkingLevel"));
+            if (property === "setSessionFastMode")
+                return (enabled) => void client.setFastMode(enabled).catch(reportActionFailure("setSessionFastMode"));
+            if (property === "abortRetry")
+                return () => void client.abortRetry().catch(reportActionFailure("abortRetry"));
+            if (property === "setAutoRetryEnabled")
+                return (enabled) => void client.setAutoRetry(enabled).catch(reportActionFailure("setAutoRetryEnabled"));
+            if (property === "reserveQueuedInputOrder")
+                return () => ++nextQueuedInputOrder;
+            if (property === "setFavoriteModels")
+                return (models) => {
+                    state = { ...state, favoriteModels: [...models] };
+                    void client.setFavoriteModels(models).catch(reportActionFailure("setFavoriteModels"));
+                };
+            if (property === "setScopedModels")
+                return (models) => {
+                    state = { ...state, scopedModels: [...models] };
+                    void client.setScopedModels(models).catch(reportActionFailure("setScopedModels"));
                 };
             if (property === "cycleModel")
-                return () => client.cycleModel();
+                return (direction) => transportCall("cycleModel", () => client.cycleModel(direction), undefined);
             if (property === "setThinkingLevel")
                 return (level) => void client.setThinkingLevel(level).catch(reportActionFailure("setThinkingLevel"));
             if (property === "cycleThinkingLevel")
-                return () => client.cycleThinkingLevel().then((result) => result?.level);
+                return () => transportCall("cycleThinkingLevel", () => client.cycleThinkingLevel(), undefined).then((result) => result?.level);
             if (property === "getAvailableThinkingLevels")
-                return () => client.getAvailableThinkingLevels();
+                return () => transportCall("getAvailableThinkingLevels", () => client.getAvailableThinkingLevels(), []);
             if (property === "setSteeringMode")
                 return (mode) => void client.setSteeringMode(mode).catch(reportActionFailure("setSteeringMode"));
             if (property === "setFollowUpMode")
                 return (mode) => void client.setFollowUpMode(mode).catch(reportActionFailure("setFollowUpMode"));
             if (property === "compact")
-                return (instructions) => client.compact(instructions);
+                return (instructions) => transportCall("compact", () => client.compact(instructions));
             if (property === "setAutoCompactionEnabled")
                 return (enabled) => void client.setAutoCompaction(enabled).catch(reportActionFailure("setAutoCompaction"));
             if (property === "executeBash")
@@ -362,7 +825,7 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
                         try {
                             const result = await executeBashWithOperations(resolvedCommand, state.cwd, options.operations, { onChunk, signal: abortController.signal });
                             if (state.sessionId === sessionAtStart) {
-                                await client.recordBashResult(command, result, options.excludeFromContext);
+                                await transportCall("recordBashResult", () => client.recordBashResult(command, result, options.excludeFromContext));
                             }
                             return result;
                         }
@@ -372,15 +835,35 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
                             updateBashState();
                         }
                     }
-                    bashChunk = onChunk;
+                    const executionId = `bash-${executionNamespace}-${++nextBashExecutionId}`;
+                    const execution = {
+                        chunk: onChunk,
+                        promises: new Set(),
+                        error: undefined,
+                        hasError: false,
+                    };
+                    bashExecutions.set(executionId, execution);
                     try {
-                        return await client.bash(command, {
+                        const result = await transportCall("bash", () => client.bash(command, {
                             excludeFromContext: options?.excludeFromContext,
+                            executionId,
                             operations: options?.operations,
-                        });
+                        }), { output: "", exitCode: undefined, cancelled: true, truncated: false });
+                        const callbacksSettled = await waitForBashCallbacks(execution.promises, false);
+                        if (!callbacksSettled) {
+                            if (result.fullOutputPath)
+                                await cleanupRemoteBashOutput(result.fullOutputPath);
+                            throw new Error("Bash output callback did not settle within 5000ms");
+                        }
+                        if (execution.hasError) {
+                            if (result.fullOutputPath)
+                                await cleanupRemoteBashOutput(result.fullOutputPath);
+                            throw execution.error;
+                        }
+                        return result;
                     }
                     finally {
-                        bashChunk = undefined;
+                        bashExecutions.delete(executionId);
                     }
                 };
             if (property === "abortBash")
@@ -390,21 +873,25 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
                     else
                         void client.abortBash().catch(reportActionFailure("abortBash"));
                 };
+            if (property === "getContextUsage")
+                return () => state.contextUsage;
             if (property === "getSessionStats")
-                return () => client.getSessionStats();
+                return () => transportCall("getSessionStats", () => client.getSessionStats(), local.getSessionStats());
             if (property === "exportToHtml")
-                return (outputPath) => client.exportHtml(outputPath).then((result) => result.path);
+                return (outputPath, options) => transportCall("exportToHtml", () => client.exportHtml(outputPath, options?.themeName)).then((result) => result?.path);
             if (property === "setSessionName")
                 return (name) => client.setSessionName(name).catch(reportActionFailure("setSessionName"));
             if (property === "navigateTree")
                 return async (targetId, options) => {
-                    const result = await client.navigateTree(targetId, options);
+                    const result = await transportCall("navigateTree", () => client.navigateTree(targetId, options), {
+                        cancelled: true,
+                    });
                     if (!result.cancelled)
                         await refresh();
                     return result;
                 };
             if (property === "getUserMessagesForForking")
-                return () => client.getForkMessages();
+                return () => transportCall("getUserMessagesForForking", () => client.getForkMessages(), []);
             if (property === "subscribe")
                 return (listener) => {
                     listeners.add(listener);
@@ -416,10 +903,10 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
                 };
             if (property === "isStreaming")
                 return state.isStreaming;
+            if (property === "isIdle")
+                return !state.isStreaming;
             if (property === "isCompacting")
                 return state.isCompacting;
-            if (property === "isFastModeActive")
-                return () => state.fastMode;
             if (property === "pendingMessageCount")
                 return state.pendingMessageCount;
             if (property === "getSteeringMessages")
@@ -450,11 +937,11 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
             if (property === "isBashRunning")
                 return state.isBashRunning;
             if (property === "reload")
-                return (_options) => client.reload();
+                return (_options) => transportCall("reload", () => client.reload(), { cancelled: true });
             if (property === "checkReloadVeto")
-                return () => client.checkReloadVeto();
+                return () => transportCall("checkReloadVeto", () => client.checkReloadVeto(), { cancelled: true });
             if (property === "exportToJsonl")
-                return (outputPath) => client.exportJsonl(outputPath).then((result) => result.path);
+                return (outputPath) => transportCall("exportToJsonl", () => client.exportJsonl(outputPath)).then((result) => result?.path);
             // The footer and other renderers read session.state.*; surface the
             // host-authoritative fields there too, not only via the direct getters.
             if (property === "state") {
@@ -475,12 +962,24 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
                 return state.sessionName;
             if (property === "serviceTier")
                 return state.serviceTier;
+            if (property === "steeringMode")
+                return state.steeringMode;
+            if (property === "followUpMode")
+                return state.followUpMode;
+            if (property === "autoCompactionEnabled")
+                return state.autoCompactionEnabled;
+            if (property === "isFastModeActive")
+                return () => state.fastMode;
             if (property === "sessionManager")
                 return remoteSessionManager;
             if (property === "settingsManager")
                 return settingsManager;
             if (property === "messages")
                 return target.messages;
+            if (property === "favoriteModels")
+                return state.favoriteModels;
+            if (property === "scopedModels")
+                return state.scopedModels;
             if (property === "model")
                 return state.model ?? target.model;
             if (property === "thinkingLevel")
@@ -490,32 +989,49 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
     });
     return {
         session,
+        setHostUiHandler: (callback) => {
+            hostUiHandler = callback;
+            if (callback)
+                for (const request of pendingUiRequests.splice(0))
+                    void Promise.resolve(callback(request))
+                        .then((response) => response && client.sendExtensionUIResponse(response))
+                        .catch(reportActionFailure("host UI response"));
+        },
         refresh,
+        aroundLocalReplacement: async (body) => {
+            localReplacementDepth++;
+            try {
+                return await body();
+            }
+            finally {
+                localReplacementDepth--;
+            }
+        },
         abortLocalBash: () => localBashAbortController?.abort(),
         createReplacedSessionContext: () => {
             const context = local.createReplacedSessionContext();
             Object.defineProperty(context, "cwd", { value: state.cwd });
             Object.defineProperty(context, "sessionManager", { value: remoteSessionManager });
-            context.sendMessage = (message, options) => client.sendCustomMessage(message, {
+            context.sendMessage = (message, options) => transportCall("sendMessage", () => client.sendCustomMessage(message, {
                 triggerTurn: options?.triggerTurn,
                 deliverAs: options?.deliverAs,
-            });
+            }));
             context.sendUserMessage = (content, options) => {
                 if (typeof content === "string")
-                    return client.prompt(content, {
+                    return transportCall("sendUserMessage", () => client.prompt(content, {
                         streamingBehavior: options?.deliverAs,
                         expandPromptTemplates: options?.expandPromptTemplates,
-                    });
+                    }));
                 const text = content
                     .filter((part) => part.type === "text")
                     .map((part) => part.text)
                     .join("\n");
                 const images = content.filter((part) => part.type === "image");
-                return client.prompt(text, {
+                return transportCall("sendUserMessage", () => client.prompt(text, {
                     images,
                     streamingBehavior: options?.deliverAs,
                     expandPromptTemplates: options?.expandPromptTemplates,
-                });
+                }));
             };
             return context;
         },