@code-yeongyu/senpi 2026.8.28 → 2026.8.30-2

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

@@ -1,3 +1,8 @@
+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";
 export const INTERACTIVE_HOST_FALLBACK_WARNING = "Warning: shared interactive host unavailable; continuing locally";
@@ -23,7 +28,15 @@ export async function createInteractiveHostRuntime(localRuntime, options) {
             modelId: localRuntime.session.model?.id,
             thinkingLevel: localRuntime.session.thinkingLevel,
         });
-        const remoteSession = createRemoteSessionProxy(localRuntime.session, client, opened.state, options.onWarning);
+        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) {
@@ -36,25 +49,25 @@ export async function createInteractiveHostRuntime(localRuntime, options) {
         return localRuntime;
     }
 }
-class RemoteInteractiveRuntime {
+export class RemoteInteractiveRuntime {
     #local;
-    #session;
+    #remoteSession;
     #client;
     #rebindSession;
     #beforeSessionInvalidate;
-    constructor(local, session, client) {
+    constructor(local, remoteSession, client) {
         this.#local = local;
-        this.#session = session;
+        this.#remoteSession = remoteSession;
         this.#client = client;
     }
     get session() {
-        return this.#session;
+        return this.#remoteSession.session;
     }
     get services() {
         return this.#local.services;
     }
     get cwd() {
-        return this.#local.cwd;
+        return this.#remoteSession.session.sessionManager.getCwd();
     }
     get diagnostics() {
         return this.#local.diagnostics;
@@ -71,37 +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() {
-        this.#beforeSessionInvalidate?.();
-        const result = await this.#client.newSession();
-        if (!result.cancelled)
-            await this.#rebindSession?.();
-        return result;
+    async 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.#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());
+            }
+            return result;
+        });
+    }
+    async 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.#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 switchSession(sessionPath) {
-        this.#beforeSessionInvalidate?.();
-        const result = await this.#client.switchSession(sessionPath);
-        if (!result.cancelled)
-            await this.#rebindSession?.();
-        return result;
+    async fork(entryId, options) {
+        // 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 fork(entryId) {
-        this.#beforeSessionInvalidate?.();
-        const result = await this.#client.fork(entryId);
-        if (!result.cancelled)
-            await this.#rebindSession?.();
-        return { cancelled: result.cancelled, selectedText: result.text };
+    async importFromJsonl(inputPath, cwdOverride) {
+        // 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 importFromJsonl() {
-        throw new Error("Session import is not available while connected to the shared host");
+    async #refreshAndRebind() {
+        await this.#remoteSession.refresh();
+        await this.#rebindSession?.();
     }
 }
-function createRemoteSessionProxy(local, 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.
@@ -112,36 +192,296 @@ function createRemoteSessionProxy(local, client, initialState, onWarning) {
             cause: error,
         });
     };
-    let state = initialState;
+    let state = { ...initialState };
+    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,
+    });
+    const updateBashState = () => {
+        state = { ...state, isBashRunning: localBashRunning || hostBashRunning };
+    };
+    const remoteSessionManager = new Proxy({}, {
+        get(_target, property, _receiver) {
+            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")
+                return () => state.usageTotals;
+            const value = Reflect.get(sessionManager, property, sessionManager);
+            return typeof value === "function" ? value.bind(sessionManager) : value;
+        },
+    });
     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 };
+            state = { ...state, isStreaming: false, retryAttempt: 0 };
+        if (wireEvent.type === "bash_start") {
+            hostBashRunning = true;
+            updateBashState();
+        }
+        if (wireEvent.type === "bash_end") {
+            hostBashRunning = false;
+            updateBashState();
+        }
+        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")
+            state = { ...state, isCompacting: true };
+        if (wireEvent.type === "compaction_end")
+            state = { ...state, isCompacting: false };
+        if (wireEvent.type === "auto_retry_start")
+            state = { ...state, retryAttempt: wireEvent.attempt };
+        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],
+                followUp: [...wireEvent.followUp],
+                ordered: [...wireEvent.ordered],
+                pendingMessageCount: wireEvent.steering.length + wireEvent.followUp.length,
+            };
+        }
         if (wireEvent.type === "model_changed") {
             state = { ...state, model: wireEvent.model, thinkingLevel: wireEvent.thinkingLevel };
         }
         if (wireEvent.type === "thinking_level_changed")
             state = { ...state, thinkingLevel: wireEvent.level };
+        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") {
-            if (wireEvent.message.role === "assistant")
+            if (wireEvent.message.role === "assistant") {
                 streamingAssistant = structuredClone(wireEvent.message);
+                mirroredCurrentAssistantUsage = false;
+            }
             local.agent.state.messages.push(structuredClone(wireEvent.message));
         }
         if (wireEvent.type === "message_end") {
-            if (wireEvent.message.role === "assistant")
+            if (wireEvent.message.role === "assistant") {
                 streamingAssistant = structuredClone(wireEvent.message);
+                const usage = wireEvent.message.usage;
+                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,
+                            output: state.usageTotals.output + usage.output,
+                            cacheRead: state.usageTotals.cacheRead + usage.cacheRead,
+                            cacheWrite: state.usageTotals.cacheWrite + usage.cacheWrite,
+                            cost: state.usageTotals.cost + (usage.cost?.total ?? 0),
+                            latestCacheHitRate: latestPromptTokens > 0 ? (usage.cacheRead / latestPromptTokens) * 100 : undefined,
+                        },
+                    };
+                }
+            }
             const messages = local.agent.state.messages;
             const previous = messages.at(-1);
             if (previous?.role === wireEvent.message.role)
                 messages[messages.length - 1] = structuredClone(wireEvent.message);
         }
+        if (wireEvent.type === "compaction_end" && wireEvent.accepted && !wireEvent.aborted) {
+            try {
+                local.sessionManager.reloadFromDisk?.();
+                if (sessionManager !== local.sessionManager)
+                    sessionManager.reloadFromDisk?.();
+                local.agent.state.messages = sessionManager.buildSessionContext().messages;
+            }
+            catch {
+                // Non-fatal if session file is transiently locked or unavailable
+            }
+        }
         const event = hydrateMessageUpdate(wireEvent, streamingAssistant);
         for (const listener of listeners)
             listener(event);
     });
+    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) {
+            // 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);
+            }
+            messages = sessionManager.buildSessionContext().messages;
+        }
+        else {
+            messages = await 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")
@@ -149,25 +489,74 @@ function createRemoteSessionProxy(local, client, initialState, onWarning) {
                     ...(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 } : {}),
                 });
             if (property === "abort")
                 return () => client.abort();
+            if (property === "abortCompaction")
+                return () => void client.abortCompaction();
             if (property === "steer")
-                return (message, images) => client.steer(message, images);
+                return (message, images, recovery) => {
+                    const enqueueOrder = recovery?.enqueueOrder ?? Math.max(0, ...state.ordered.map((item) => item.enqueueOrder)) + 1;
+                    state = {
+                        ...state,
+                        steering: [...state.steering, message],
+                        ordered: [...state.ordered, { text: message, mode: "steer", enqueueOrder }],
+                        pendingMessageCount: state.pendingMessageCount + 1,
+                    };
+                    return client.steer(message, images, { ...recovery, enqueueOrder });
+                };
             if (property === "followUp")
-                return (message, images) => client.followUp(message, images);
+                return (message, images, recovery) => {
+                    const enqueueOrder = recovery?.enqueueOrder ?? Math.max(0, ...state.ordered.map((item) => item.enqueueOrder)) + 1;
+                    state = {
+                        ...state,
+                        followUp: [...state.followUp, message],
+                        ordered: [...state.ordered, { text: message, mode: "followUp", enqueueOrder }],
+                        pendingMessageCount: state.pendingMessageCount + 1,
+                    };
+                    return 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) => {
-                    await client.setModel(model.provider, model.id);
+                    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")
@@ -183,15 +572,81 @@ function createRemoteSessionProxy(local, client, initialState, onWarning) {
             if (property === "setAutoCompactionEnabled")
                 return (enabled) => void client.setAutoCompaction(enabled).catch(reportActionFailure("setAutoCompaction"));
             if (property === "executeBash")
-                return (command) => client.bash(command);
+                return async (command, onChunk, options) => {
+                    if (options?.operations && typeof options.operations.exec === "function") {
+                        const abortController = new AbortController();
+                        localBashAbortController = abortController;
+                        localBashRunning = true;
+                        updateBashState();
+                        const sessionAtStart = state.sessionId;
+                        const prefix = settingsManager.getShellCommandPrefix();
+                        const resolvedCommand = prefix ? `${prefix}\n${command}` : command;
+                        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);
+                            }
+                            return result;
+                        }
+                        finally {
+                            localBashAbortController = undefined;
+                            localBashRunning = false;
+                            updateBashState();
+                        }
+                    }
+                    const executionId = `bash-${executionNamespace}-${++nextBashExecutionId}`;
+                    const execution = {
+                        chunk: onChunk,
+                        promises: new Set(),
+                        error: undefined,
+                        hasError: false,
+                    };
+                    bashExecutions.set(executionId, execution);
+                    try {
+                        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 {
+                        bashExecutions.delete(executionId);
+                    }
+                };
             if (property === "abortBash")
-                return () => void client.abortBash().catch(reportActionFailure("abortBash"));
+                return () => {
+                    if (localBashAbortController)
+                        localBashAbortController.abort();
+                    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) => void client.setSessionName(name).catch(reportActionFailure("setSessionName"));
+                return (name) => client.setSessionName(name).catch(reportActionFailure("setSessionName"));
+            if (property === "navigateTree")
+                return async (targetId, options) => {
+                    const result = await client.navigateTree(targetId, options);
+                    if (!result.cancelled)
+                        await refresh();
+                    return result;
+                };
             if (property === "getUserMessagesForForking")
                 return () => client.getForkMessages();
             if (property === "subscribe")
@@ -205,6 +660,45 @@ function createRemoteSessionProxy(local, client, initialState, onWarning) {
                 };
             if (property === "isStreaming")
                 return state.isStreaming;
+            if (property === "isIdle")
+                return !state.isStreaming;
+            if (property === "isCompacting")
+                return state.isCompacting;
+            if (property === "pendingMessageCount")
+                return state.pendingMessageCount;
+            if (property === "getSteeringMessages")
+                return () => state.steering;
+            if (property === "getFollowUpMessages")
+                return () => state.followUp;
+            if (property === "clearQueue")
+                return (options) => {
+                    const result = {
+                        steering: [...state.steering],
+                        followUp: [...state.followUp],
+                        ordered: [...state.ordered],
+                    };
+                    Object.defineProperty(result, "ordered", { value: result.ordered, enumerable: false });
+                    void client.clearQueue(options).catch(reportActionFailure("clearQueue"));
+                    return result;
+                };
+            if (property === "abortBranchSummary")
+                return () => void client.abortBranchSummary().catch(reportActionFailure("abortBranchSummary"));
+            if (property === "recordBashResult")
+                return (command, result, options) => void client
+                    .recordBashResult(command, result, options?.excludeFromContext)
+                    .catch(reportActionFailure("recordBashResult"));
+            if (property === "set_label")
+                return undefined;
+            if (property === "retryAttempt")
+                return state.retryAttempt;
+            if (property === "isBashRunning")
+                return state.isBashRunning;
+            if (property === "reload")
+                return (_options) => client.reload();
+            if (property === "checkReloadVeto")
+                return () => client.checkReloadVeto();
+            if (property === "exportToJsonl")
+                return (outputPath) => 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") {
@@ -214,14 +708,35 @@ function createRemoteSessionProxy(local, client, initialState, onWarning) {
                     model: state.model ?? localState.model,
                     thinkingLevel: state.thinkingLevel,
                     isStreaming: state.isStreaming,
+                    isCompacting: state.isCompacting,
                 };
             }
             if (property === "sessionFile")
                 return state.sessionFile;
             if (property === "sessionId")
                 return state.sessionId;
+            if (property === "sessionName")
+                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")
@@ -229,7 +744,53 @@ function createRemoteSessionProxy(local, client, initialState, onWarning) {
             return Reflect.get(target, property, receiver);
         },
     });
-    return session;
+    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();
+            Object.defineProperty(context, "cwd", { value: state.cwd });
+            Object.defineProperty(context, "sessionManager", { value: remoteSessionManager });
+            context.sendMessage = (message, options) => client.sendCustomMessage(message, {
+                triggerTurn: options?.triggerTurn,
+                deliverAs: options?.deliverAs,
+            });
+            context.sendUserMessage = (content, options) => {
+                if (typeof content === "string")
+                    return 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, {
+                    images,
+                    streamingBehavior: options?.deliverAs,
+                    expandPromptTemplates: options?.expandPromptTemplates,
+                });
+            };
+            return context;
+        },
+    };
 }
 function hydrateMessageUpdate(event, streamingAssistant) {
     if (event.type !== "message_update" || !streamingAssistant)