@code-yeongyu/senpi 2026.8.29 → 2026.8.30-2

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

@@ -1,3 +1,5 @@
+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";
@@ -27,6 +29,14 @@ export async function createInteractiveHostRuntime(localRuntime, options) {
             thinkingLevel: localRuntime.session.thinkingLevel,
         });
         const remoteSession = createRemoteSessionProxy(localRuntime.session, localRuntime.services.agentDir, client, opened.state, options.onWarning);
+        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();
         return new RemoteInteractiveRuntime(localRuntime, remoteSession, client);
     }
     catch (cause) {
@@ -39,7 +49,7 @@ export async function createInteractiveHostRuntime(localRuntime, options) {
         return localRuntime;
     }
 }
-class RemoteInteractiveRuntime {
+export class RemoteInteractiveRuntime {
     #local;
     #remoteSession;
     #client;
@@ -74,71 +84,104 @@ class RemoteInteractiveRuntime {
     setRebindSession(callback) {
         this.#rebindSession = callback;
     }
+    setHostUiHandler(callback) {
+        this.#remoteSession.setHostUiHandler(callback);
+    }
     async dispose() {
-        await this.#client.closeSession();
-        await this.#client.stop();
-        await this.#local.dispose();
+        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);
+        // 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.#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;
+        });
     }
     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;
+        // 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.#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;
+        });
     }
     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 };
+        // See newSession: the suppression must cover the command itself.
+        return this.#remoteSession.aroundLocalReplacement(async () => {
+            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 };
+        });
     }
     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;
+        // See newSession: the suppression must cover the command itself.
+        return this.#remoteSession.aroundLocalReplacement(async () => {
+            const result = await this.#client.importJsonl(inputPath, cwdOverride);
+            if (!result.cancelled) {
+                this.#beforeSessionInvalidate?.();
+                this.#remoteSession.abortLocalBash();
+                await this.#refreshAndRebind();
+            }
+            return result;
+        });
     }
     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) {
     // 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.
@@ -150,10 +193,65 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
         });
     };
     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,
@@ -166,6 +264,8 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
             if (property === "appendLabelChange") {
                 return (entryId, label) => void client.setLabel(entryId, label);
             }
+            if (property === "getCwd")
+                return () => state.cwd;
             if (property === "getSessionName")
                 return () => state.sessionName;
             if (property === "getUsageTotals")
@@ -176,8 +276,36 @@ 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));
+            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 +316,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 +351,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 +368,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 +401,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 +427,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,17 +440,26 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
         for (const listener of listeners)
             listener(event);
     });
-    const refresh = async () => {
+    const performRefresh = async () => {
         const nextState = await client.getState();
         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);
+            // 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);
+            }
             if (nextState.entries?.length && !sessionManager.getEntries().length) {
                 for (const entry of nextState.entries)
                     sessionManager.appendEntry(entry);
@@ -288,6 +472,16 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
         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")
@@ -295,6 +489,12 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
                     ...(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 } : {}),
                 });
@@ -328,13 +528,35 @@ function createRemoteSessionProxy(local, agentDir, client, initialState, onWarni
                 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 };
                 };
+            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) => client.cycleModel(direction);
             if (property === "setThinkingLevel")
                 return (level) => void client.setThinkingLevel(level).catch(reportActionFailure("setThinkingLevel"));
             if (property === "cycleThinkingLevel")
@@ -372,15 +594,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 client.bash(command, {
                             excludeFromContext: options?.excludeFromContext,
+                            executionId,
                             operations: options?.operations,
                         });
+                        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,10 +632,12 @@ 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();
             if (property === "exportToHtml")
-                return (outputPath) => client.exportHtml(outputPath).then((result) => result.path);
+                return (outputPath, options) => client.exportHtml(outputPath, options?.themeName).then((result) => result.path);
             if (property === "setSessionName")
                 return (name) => client.setSessionName(name).catch(reportActionFailure("setSessionName"));
             if (property === "navigateTree")
@@ -416,10 +660,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")
@@ -475,12 +719,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,7 +746,22 @@ 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));
+        },
         refresh,
+        aroundLocalReplacement: async (body) => {
+            localReplacementDepth++;
+            try {
+                return await body();
+            }
+            finally {
+                localReplacementDepth--;
+            }
+        },
         abortLocalBash: () => localBashAbortController?.abort(),
         createReplacedSessionContext: () => {
             const context = local.createReplacedSessionContext();