@code-yeongyu/senpi 2026.8.28 → 2026.8.29

package/dist/modes/interactive/interactive-host-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interactive-host-runtime.d.ts","sourceRoot":"","sources":["../../../src/modes/interactive/interactive-host-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAgD,MAAM,6BAA6B,CAAC;AAC9G,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAE/E,OAAO,EAAE,KAAK,WAAW,EAAc,MAAM,uBAAuB,CAAC;AACrE,OAAO,EAAa,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtE,eAAO,MAAM,iCAAiC,qEAAqE,CAAC;AAEpH,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,IAAI,EAAE,2BAA2B,GAAG,gCAAgC,CAAC;IAC9E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG,IAAI,CACpC,YAAY,EACZ,oBAAoB,GAAG,4BAA4B,GAAG,iBAAiB,GAAG,2BAA2B,CACrG,GAAG;IACH,kBAAkB,IAAI,aAAa,GAAG,SAAS,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAAC;IACrF,0BAA0B,IAAI,aAAa,EAAE,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;IACzE,eAAe,IACZ,UAAU,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC,GAC3C,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;IACxD,yBAAyB,IACtB,UAAU,CAAC,YAAY,CAAC,2BAA2B,CAAC,CAAC,GACrD,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,2BAA2B,CAAC,CAAC,CAAC,CAAC;CAClE,CAAC;AAEF,MAAM,WAAW,6BAA6B;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC;IAC3G,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,IAAI,CAAC;CACtD;AAED;;;;;GAKG;AACH,wBAAsB,4BAA4B,CACjD,YAAY,EAAE,mBAAmB,EACjC,OAAO,EAAE,6BAA6B,GACpC,OAAO,CAAC,mBAAmB,CAAC,CA0B9B;AAoOD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,cAAc,GAAG,KAAK,IAAI,OAAO,CAAC,cAAc,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAEhH"}
+{"version":3,"file":"interactive-host-runtime.d.ts","sourceRoot":"","sources":["../../../src/modes/interactive/interactive-host-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAgD,MAAM,6BAA6B,CAAC;AAC9G,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAO/E,OAAO,EAAE,KAAK,WAAW,EAAc,MAAM,uBAAuB,CAAC;AACrE,OAAO,EAAa,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtE,eAAO,MAAM,iCAAiC,qEAAqE,CAAC;AAEpH,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,IAAI,EAAE,2BAA2B,GAAG,gCAAgC,CAAC;IAC9E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG,IAAI,CACpC,YAAY,EACZ,oBAAoB,GAAG,4BAA4B,GAAG,iBAAiB,GAAG,2BAA2B,CACrG,GAAG;IACH,kBAAkB,IAAI,aAAa,GAAG,SAAS,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAAC;IACrF,0BAA0B,IAAI,aAAa,EAAE,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;IACzE,eAAe,IACZ,UAAU,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC,GAC3C,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;IACxD,yBAAyB,IACtB,UAAU,CAAC,YAAY,CAAC,2BAA2B,CAAC,CAAC,GACrD,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,2BAA2B,CAAC,CAAC,CAAC,CAAC;CAClE,CAAC;AAEF,MAAM,WAAW,6BAA6B;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC;IAC3G,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,IAAI,CAAC;CACtD;AAED;;;;;GAKG;AACH,wBAAsB,4BAA4B,CACjD,YAAY,EAAE,mBAAmB,EACjC,OAAO,EAAE,6BAA6B,GACpC,OAAO,CAAC,mBAAmB,CAAC,CAgC9B;AAqiBD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,cAAc,GAAG,KAAK,IAAI,OAAO,CAAC,cAAc,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAEhH"}

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

@@ -1,3 +1,6 @@
+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 +26,7 @@ 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);
         return new RemoteInteractiveRuntime(localRuntime, remoteSession, client);
     }
     catch (cause) {
@@ -38,23 +41,23 @@ export async function createInteractiveHostRuntime(localRuntime, options) {
 }
 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;
@@ -76,32 +79,66 @@ class RemoteInteractiveRuntime {
         await this.#client.stop();
         await this.#local.dispose();
     }
-    async newSession() {
-        this.#beforeSessionInvalidate?.();
-        const result = await this.#client.newSession();
-        if (!result.cancelled)
+    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);
+                await this.#remoteSession.refresh();
+            }
             await this.#rebindSession?.();
+            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)
+    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;
     }
-    async fork(entryId) {
-        this.#beforeSessionInvalidate?.();
-        const result = await this.#client.fork(entryId);
-        if (!result.cancelled)
-            await this.#rebindSession?.();
+    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 };
     }
-    async importFromJsonl() {
-        throw new Error("Session import is not available while connected to the shared host");
+    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;
+    }
+    async #refreshAndRebind() {
+        await this.#remoteSession.refresh();
+        await this.#rebindSession?.();
     }
 }
-function createRemoteSessionProxy(local, client, initialState, onWarning) {
+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 +149,145 @@ function createRemoteSessionProxy(local, client, initialState, onWarning) {
             cause: error,
         });
     };
-    let state = initialState;
+    let state = { ...initialState };
+    let bashChunk;
+    let localBashAbortController;
+    let localBashRunning = false;
+    let hostBashRunning = initialState.isBashRunning;
+    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 === "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;
     const listeners = new Set();
     client.onEvent((wireEvent) => {
         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")
+            bashChunk?.(wireEvent.delta);
         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") {
+            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_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;
+                    state = {
+                        ...state,
+                        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 {
+                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 refresh = async () => {
+        const nextState = await client.getState();
+        state = { ...stateFromRpc(nextState) };
+        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);
+            }
+            messages = sessionManager.buildSessionContext().messages;
+        }
+        else {
+            messages = await client.getMessages();
+        }
+        local.agent.state.messages.splice(0, local.agent.state.messages.length, ...structuredClone(messages));
+        streamingAssistant = undefined;
+    };
     const session = new Proxy(local, {
         get(target, property, receiver) {
             if (property === "prompt")
@@ -154,17 +300,38 @@ function createRemoteSessionProxy(local, client, initialState, onWarning) {
                 });
             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")
                 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 === "cycleModel")
                 return () => client.cycleModel();
@@ -183,15 +350,59 @@ 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();
+                        }
+                    }
+                    bashChunk = onChunk;
+                    try {
+                        return await client.bash(command, {
+                            excludeFromContext: options?.excludeFromContext,
+                            operations: options?.operations,
+                        });
+                    }
+                    finally {
+                        bashChunk = undefined;
+                    }
+                };
             if (property === "abortBash")
-                return () => void client.abortBash().catch(reportActionFailure("abortBash"));
+                return () => {
+                    if (localBashAbortController)
+                        localBashAbortController.abort();
+                    else
+                        void client.abortBash().catch(reportActionFailure("abortBash"));
+                };
             if (property === "getSessionStats")
                 return () => client.getSessionStats();
             if (property === "exportToHtml")
                 return (outputPath) => client.exportHtml(outputPath).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 +416,45 @@ function createRemoteSessionProxy(local, client, initialState, onWarning) {
                 };
             if (property === "isStreaming")
                 return state.isStreaming;
+            if (property === "isCompacting")
+                return state.isCompacting;
+            if (property === "isFastModeActive")
+                return () => state.fastMode;
+            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,12 +464,21 @@ 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 === "sessionManager")
+                return remoteSessionManager;
+            if (property === "settingsManager")
+                return settingsManager;
             if (property === "messages")
                 return target.messages;
             if (property === "model")
@@ -229,7 +488,38 @@ function createRemoteSessionProxy(local, client, initialState, onWarning) {
             return Reflect.get(target, property, receiver);
         },
     });
-    return session;
+    return {
+        session,
+        refresh,
+        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)