cli-wechat-bridge 1.0.5 → 1.0.7

package/dist/bridge/bridge-utils.js

@@ -16,10 +16,12 @@ const WECHAT_ATTACHMENT_PROMPT_PREFIX = [
     "[WeChat bridge note]",
     "Your final reply will be forwarded back to a WeChat chat.",
     "If the user asks you to send a local file or media to WeChat and you know the local path, do not say that you lack a WeChat sending tool.",
-    "For a real send request, prefer locating and sending the file directly instead of opening or reading it unless the user explicitly asked for that.",
+    "For a real send request, locate the original local file path and reference that path directly in the attachment block.",
+    "Do not create, copy, move, or write files into ~/.claude/channels/wechat, ~/.cli-bridge, or any outbound-attachments directory.",
+    "Do not call Write, cp, copy, xcopy, robocopy, mv, move, or shell redirection to stage outbound files for WeChat.",
     "Put any brief visible reply text first, then end the message with exactly one trailing block like:",
     "```wechat-attachments",
-    "file C:\\Users\\name\\Desktop\\document.pdf",
+    "file C:\\Users\\name\\Desktop\\document.docx",
     "```",
     "Valid kinds: image, file, video, voice.",
     "Use `file` for PDFs and ordinary documents. Only include files you truly intend to upload.",
@@ -27,6 +29,10 @@ const WECHAT_ATTACHMENT_PROMPT_PREFIX = [
     "[User request]",
 ].join("\n");
 const WECHAT_ATTACHMENT_BLOCK_RE = /\n```wechat-attachments[ \t]*\n([\s\S]*?)\n```[ \t]*$/;
+export const WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE = "The WeChat bridge does not use outbound attachment directories. Do not create or copy files under .claude/channels/wechat/outbound-attachments or .cli-bridge/outbound-attachments. To send a file, put the original absolute local file path in the final ```wechat-attachments``` block.";
+const WECHAT_OUTBOUND_ATTACHMENT_PATH_RE = /(?:^|\/)(?:(?:\.claude\/channels\/wechat\/|\.cli-bridge\/)?outbound-attachments)(?:\/|$)/i;
+const WECHAT_OUTBOUND_ATTACHMENT_WRITE_COMMAND_RE = /\b(cp|copy|copy-item|xcopy|robocopy|mv|move|move-item|mkdir|md|new-item|ni|set-content|add-content|out-file|write-output|touch)\b|>\s*["']?[^&|]*outbound-attachments/i;
+const WECHAT_OUTBOUND_ATTACHMENT_MUTATION_TOOL_RE = /^(?:write|edit|multiedit|notebookedit|patch|create|mkdir|move|copy|file[_-]?change|external_directory)$/i;
 const WECHAT_ATTACHMENT_KINDS = ["image", "file", "video", "voice"];
 const INLINE_IMAGE_EXTENSIONS = new Set([
     ".png",
@@ -211,6 +217,43 @@ export function shouldInjectWechatAttachmentPrompt(text) {
         mentionsLocalPath ||
         looksLikeShortSendCommand);
 }
+export function containsWechatOutboundAttachmentPath(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    const normalized = value.trim().replace(/\\/g, "/");
+    return WECHAT_OUTBOUND_ATTACHMENT_PATH_RE.test(normalized);
+}
+export function containsWechatOutboundAttachmentPathDeep(value) {
+    const seen = new WeakSet();
+    const visit = (candidate) => {
+        if (containsWechatOutboundAttachmentPath(candidate)) {
+            return true;
+        }
+        if (!candidate || typeof candidate !== "object") {
+            return false;
+        }
+        if (seen.has(candidate)) {
+            return false;
+        }
+        seen.add(candidate);
+        if (Array.isArray(candidate)) {
+            return candidate.some((item) => visit(item));
+        }
+        return Object.values(candidate).some((item) => visit(item));
+    };
+    return visit(value);
+}
+export function isWechatOutboundAttachmentWriteCommand(command) {
+    return (typeof command === "string" &&
+        containsWechatOutboundAttachmentPath(command) &&
+        WECHAT_OUTBOUND_ATTACHMENT_WRITE_COMMAND_RE.test(command));
+}
+export function isWechatOutboundAttachmentMutationTool(toolName, targetPath) {
+    return (typeof toolName === "string" &&
+        WECHAT_OUTBOUND_ATTACHMENT_MUTATION_TOOL_RE.test(toolName.trim()) &&
+        containsWechatOutboundAttachmentPath(targetPath));
+}
 function formatPromptByteSize(bytes) {
     if (bytes === undefined || !Number.isFinite(bytes) || bytes < 0) {
         return null;
@@ -356,7 +399,11 @@ const HIGH_RISK_PATTERNS = [
     /\b(?:invoke-expression|iex)\b/i,
     /\bcurl\b.*\|\s*(?:iex|powershell)\b/i,
     /\binvoke-webrequest\b.*\|\s*(?:iex|powershell)\b/i,
+    /\brm\b\s+/i,
     /\brm\b\s+-[A-Za-z-]*r[A-Za-z-]*/i,
+    /\bfind\b[^\r\n]*\s-delete\b/i,
+    /\bfind\b[^\r\n]*\s-exec\s+(?:rm|rmdir|del|erase|remove-item)\b/i,
+    /\bxargs\b[^\r\n]*\b(?:rm|rmdir|del|erase|remove-item)\b/i,
     /\bsudo\b/i,
     /\bmkfs(?:\.\w+)?\b/i,
     /\bdd\b/i,

package/dist/bridge/claude-hooks.js

@@ -1,4 +1,19 @@
-import { normalizeOutput, truncatePreview } from "./bridge-utils.js";
+import { WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE, containsWechatOutboundAttachmentPath, isHighRiskShellCommand, isWechatOutboundAttachmentWriteCommand, normalizeOutput, truncatePreview, } from "./bridge-utils.js";
+export const CLAUDE_WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE = WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE;
+const FILE_MUTATION_TOOL_NAMES = new Set([
+    "Write",
+    "Edit",
+    "MultiEdit",
+    "NotebookEdit",
+]);
+const LOW_RISK_READ_TOOL_NAMES = new Set([
+    "Glob",
+    "Grep",
+    "LS",
+    "NotebookRead",
+    "Read",
+    "TodoRead",
+]);
 function quoteWindowsCommandArg(value) {
     return `"${value.replace(/"/g, '""')}"`;
 }
@@ -166,14 +181,60 @@ export function buildClaudePermissionApprovalRequest(payload) {
         detailPreview,
     };
 }
-export function buildClaudePermissionDecisionHookOutput(action) {
+function getClaudeToolInputString(payload, key) {
+    const value = payload.tool_input?.[key];
+    return typeof value === "string" ? value : "";
+}
+export function getClaudeWechatOutboundAttachmentDenyMessage(payload) {
+    const toolName = typeof payload.tool_name === "string" ? payload.tool_name.trim() : "";
+    if (!toolName) {
+        return null;
+    }
+    if (FILE_MUTATION_TOOL_NAMES.has(toolName)) {
+        const filePath = getClaudeToolInputString(payload, "file_path");
+        return containsWechatOutboundAttachmentPath(filePath)
+            ? CLAUDE_WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE
+            : null;
+    }
+    if (toolName === "Bash") {
+        const command = getClaudeToolInputString(payload, "command");
+        if (isWechatOutboundAttachmentWriteCommand(command)) {
+            return CLAUDE_WECHAT_OUTBOUND_ATTACHMENT_DENY_MESSAGE;
+        }
+    }
+    return null;
+}
+export function getClaudePermissionAutoResponse(payload) {
+    const toolName = typeof payload.tool_name === "string" ? payload.tool_name.trim() : "";
+    if (!toolName) {
+        return null;
+    }
+    if (LOW_RISK_READ_TOOL_NAMES.has(toolName)) {
+        return {
+            action: "confirm",
+            reason: `low-risk ${toolName} permission`,
+        };
+    }
+    if (toolName !== "Bash") {
+        return null;
+    }
+    const command = getClaudeToolInputString(payload, "command").trim();
+    if (!command || isHighRiskShellCommand(command)) {
+        return null;
+    }
+    return {
+        action: "confirm",
+        reason: `low-risk command ${truncatePreview(command, 120)}`,
+    };
+}
+export function buildClaudePermissionDecisionHookOutput(action, denyMessage = "Permission denied from WeChat bridge.") {
     const decision = action === "confirm"
         ? {
             behavior: "allow",
         }
         : {
             behavior: "deny",
-            message: "Permission denied from WeChat bridge.",
+            message: denyMessage,
             interrupt: false,
         };
     return JSON.stringify({

package/dist/bridge/wechat-bridge.js

@@ -8,7 +8,7 @@ import { ensureWechatCredentials } from "../wechat/setup.js";
 import { BridgeStateStore } from "./bridge-state.js";
 import { reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses } from "./bridge-process-reaper.js";
 import { createRuntimeHost } from "../runtime/create-runtime-host.js";
-import { buildWechatInboundPrompt, buildOneTimeCode, formatApprovalMessage, formatPendingApprovalReminder, formatDuration, formatMirroredUserInputMessage, formatSessionSwitchMessage, formatStatusReport, formatTaskFailedMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parseWechatControlCommand, truncatePreview, } from "./bridge-utils.js";
+import { buildWechatInboundPrompt, buildOneTimeCode, formatApprovalMessage, formatPendingApprovalReminder, formatPendingUserInputReminder, formatDuration, formatMirroredUserInputMessage, formatSessionSwitchMessage, formatStatusReport, formatTaskFailedMessage, formatUserInputRequestMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parsePendingUserInputAnswerCommand, parseWechatControlCommand, truncatePreview, } from "./bridge-utils.js";
 import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, WeChatTransport, describeWechatTransportError, isWechatContextTokenStaleError, } from "../wechat/wechat-transport.js";
 import { checkForUpdate, formatUpdateMessage, } from "../utils/version-checker.js";
 import { clearDaemonEndpoint, isDaemonEndpointAlive, readDaemonEndpoint, } from "../daemon/daemon-link.js";
@@ -111,6 +111,15 @@ function toPendingApproval(request) {
         createdAt: nowIso(),
     };
 }
+function toPendingUserInput(request) {
+    if (typeof request.createdAt === "string") {
+        return request;
+    }
+    return {
+        ...request,
+        createdAt: nowIso(),
+    };
+}
 export function shouldDeferCodexInboundMessage(params) {
     return (params.adapter === "codex" &&
         !params.hasPendingConfirmation &&
@@ -122,11 +131,13 @@ export function canDrainDeferredCodexInboundQueue(params) {
     return (params.adapter === "codex" &&
         params.deferredCount > 0 &&
         !params.hasPendingConfirmation &&
+        !params.hasPendingUserInput &&
         !params.hasPendingApproval &&
         !params.hasActiveTask &&
         !params.activeTurnId &&
         params.status !== "busy" &&
-        params.status !== "awaiting_approval");
+        params.status !== "awaiting_approval" &&
+        params.status !== "awaiting_input");
 }
 export function formatDeferredCodexInboundQueueMessage(queuePosition) {
     return `Queued for delivery after the current local Codex turn finishes. Queue position: ${queuePosition}.`;
@@ -140,6 +151,7 @@ export function parseCliArgs(argv) {
     let cwd = process.cwd();
     let profile;
     let lifecycle = "persistent";
+    let sessionStartMode = "restore";
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         const next = argv[i + 1];
@@ -179,6 +191,13 @@ export function parseCliArgs(argv) {
                 lifecycle = next;
                 i += 1;
                 break;
+            case "--session-start-mode":
+                if (!next || !["restore", "new"].includes(next)) {
+                    throw new Error(`Invalid session start mode: ${next ?? "(missing)"}`);
+                }
+                sessionStartMode = next;
+                i += 1;
+                break;
             case "--shutdown-on-parent-exit":
                 lifecycle = "companion_bound";
                 break;
@@ -200,11 +219,12 @@ export function parseCliArgs(argv) {
         cwd,
         profile,
         lifecycle,
+        sessionStartMode,
     };
 }
 function printUsageAndExit() {
     process.stdout.write([
-        "Usage: wechat-bridge --adapter <codex|claude|opencode|shell> [--cmd <executable>] [--cwd <path>] [--profile <name-or-path>] [--lifecycle <persistent|companion_bound>]",
+        "Usage: wechat-bridge --adapter <codex|claude|opencode|shell> [--cmd <executable>] [--cwd <path>] [--profile <name-or-path>] [--lifecycle <persistent|companion_bound>] [--session-start-mode <restore|new>]",
         "",
         "Examples:",
         "  wechat-bridge-codex",
@@ -294,6 +314,7 @@ async function main() {
         cwd: options.cwd,
         profile: options.profile,
         lifecycle: options.lifecycle,
+        sessionStartMode: options.sessionStartMode,
         initialSharedSessionId: stateStore.getState().sharedSessionId ?? stateStore.getState().sharedThreadId,
         initialResumeConversationId: stateStore.getState().resumeConversationId,
         initialTranscriptPath: stateStore.getState().transcriptPath,
@@ -394,6 +415,7 @@ async function main() {
             status: adapterState.status,
             activeTurnId: adapterState.activeTurnId,
             hasPendingConfirmation: Boolean(stateStore.getState().pendingConfirmation),
+            hasPendingUserInput: Boolean(stateStore.getState().pendingUserInput),
             hasPendingApproval: Boolean(adapterState.pendingApproval),
             hasActiveTask: Boolean(activeTask),
         })) {
@@ -717,6 +739,9 @@ function wireAdapterEvents(params) {
         if (bridgeState.pendingConfirmation && !adapterState.pendingApproval) {
             stateStore.clearPendingConfirmation();
         }
+        if (bridgeState.pendingUserInput && !adapterState.pendingUserInput) {
+            stateStore.clearPendingUserInput();
+        }
         const authorizedUserId = stateStore.getState().authorizedUserId;
         switch (event.type) {
             case "stdout":
@@ -775,6 +800,14 @@ function wireAdapterEvents(params) {
                     await queueWechatMessage(authorizedUserId, formatApprovalMessage(pending, adapterState), "approval_required");
                 }));
                 break;
+            case "user_input_required":
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
+                    const pending = toPendingUserInput(event.request);
+                    stateStore.setPendingUserInput(pending);
+                    stateStore.appendLog(`User input requested: questions=${pending.questions.length}`);
+                    await queueWechatMessage(authorizedUserId, formatUserInputRequestMessage(pending, adapterState), "user_input_required");
+                }));
+                break;
             case "mirrored_user_input":
                 stateStore.appendLog(`mirrored_local_input: ${truncatePreview(event.text)}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type, { text: event.text })) {
@@ -813,6 +846,7 @@ function wireAdapterEvents(params) {
             case "task_complete":
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
+                    stateStore.clearPendingUserInput();
                     if (options.adapter === "shell") {
                         const summary = buildCompletionSummary({
                             adapter: options.adapter,
@@ -829,6 +863,7 @@ function wireAdapterEvents(params) {
             case "task_failed":
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
+                    stateStore.clearPendingUserInput();
                     clearActiveTask();
                     await queueWechatMessage(authorizedUserId, formatTaskFailedMessage(options.adapter, event.message), "task_failed");
                     await maybeDrainDeferredInboundMessages();
@@ -838,6 +873,7 @@ function wireAdapterEvents(params) {
                 logError(event.message);
                 stateStore.appendLog(`fatal_error: ${event.message}`);
                 stateStore.clearPendingConfirmation();
+                stateStore.clearPendingUserInput();
                 clearActiveTask();
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     await queueWechatMessage(authorizedUserId, formatUserFacingBridgeFatalError(event.message), "fatal_error");
@@ -914,6 +950,7 @@ async function handleInboundMessage(params) {
             await outputBatcher.flushNow();
             outputBatcher.clear();
             stateStore.clearPendingConfirmation();
+            stateStore.clearPendingUserInput();
             stateStore.clearSharedSessionId();
             await adapter.createSession();
             stateStore.appendLog(`New ${options.adapter} session requested by owner.`);
@@ -930,6 +967,7 @@ async function handleInboundMessage(params) {
             await outputBatcher.flushNow();
             outputBatcher.clear();
             stateStore.clearPendingConfirmation();
+            stateStore.clearPendingUserInput();
             stateStore.clearSharedSessionId();
             await adapter.reset();
             stateStore.appendLog("Worker reset by owner.");
@@ -974,11 +1012,39 @@ async function handleInboundMessage(params) {
             await queueWechatMessage(message.senderId, "Approval denied.");
             return null;
         }
+        case "answer": {
+            const pending = state.pendingUserInput;
+            if (!pending) {
+                await queueWechatMessage(message.senderId, "No pending user input request.");
+                return null;
+            }
+            const parsed = parsePendingUserInputAnswerCommand(systemCommand.raw, pending);
+            if ("error" in parsed) {
+                await queueWechatMessage(message.senderId, parsed.error);
+                return null;
+            }
+            const submitted = await adapter.submitUserInput(parsed.answers);
+            if (!submitted) {
+                await queueWechatMessage(message.senderId, "The worker could not apply this answer.");
+                return null;
+            }
+            stateStore.clearPendingUserInput();
+            stateStore.appendLog(`User input answered: ${parsed.preview}`);
+            await queueWechatMessage(message.senderId, "Answer submitted. Continuing...");
+            return {
+                startedAt: Date.now(),
+                inputPreview: parsed.preview,
+            };
+        }
     }
     if (state.pendingConfirmation) {
         await queueWechatMessage(message.senderId, formatPendingApprovalReminder(state.pendingConfirmation, adapter.getState()));
         return null;
     }
+    if (state.pendingUserInput) {
+        await queueWechatMessage(message.senderId, formatPendingUserInputReminder(state.pendingUserInput));
+        return null;
+    }
     const adapterState = adapter.getState();
     if (shouldDeferCodexInboundMessage({
         adapter: options.adapter,

package/dist/commands/check-update.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { checkForUpdate, getCurrentVersion, fetchLatestVersion, compareVersions, } from "../utils/version-checker.js";
+import { checkForUpdate, getCurrentVersion, } from "../utils/version-checker.js";
 async function main() {
     const currentVersion = await getCurrentVersion();
     console.log(`CLI WeChat Bridge Version Check`);

package/dist/companion/local-companion-start.js

@@ -37,6 +37,9 @@ export function formatSwitchFailureMessage(cwd) {
 export function formatRestartUnhealthyMessage(cwd) {
     return `Detected unhealthy companion state for ${cwd}. Restarting bridge...`;
 }
+export function defaultSessionStartMode(adapter) {
+    return adapter === "claude" || adapter === "opencode" ? "new" : "restore";
+}
 export function decideLaunchAction(input) {
     if (input.lockShouldAutoReclaim) {
         return {
@@ -55,6 +58,13 @@ export function decideLaunchAction(input) {
             failureMessage: formatSwitchFailureMessage(input.runningLock.cwd),
         };
     }
+    if (input.sessionStartMode === "new" &&
+        (input.requestedAdapter === "claude" || input.requestedAdapter === "opencode")) {
+        return {
+            kind: "start_bridge",
+            message: `Starting a fresh ${input.requestedAdapter} session for ${input.requestedCwd}...`,
+        };
+    }
     if (!input.endpoint || !input.endpointIsReachable) {
         return {
             kind: "restart_unhealthy",
@@ -99,7 +109,8 @@ export function parseCliArgs(argv) {
                 "       wechat-opencode-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...opencode args]",
                 "       local-companion-start [--adapter <codex|claude|opencode>] [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...cli args]",
                 "",
-                "Starts or reuses a Codex, Claude, or OpenCode bridge for the current directory, waits for the local endpoint, then opens the visible companion or panel.",
+                "Starts a bridge for the current directory, waits for the local endpoint, then opens the visible companion or panel.",
+                "Claude and OpenCode launchers start a fresh CLI session by default.",
                 "All adapters are companion-bound: closing the companion/panel also stops the bridge.",
                 "Unknown arguments are forwarded to the visible CLI client.",
                 "",
@@ -144,7 +155,14 @@ export function parseCliArgs(argv) {
         }
         cliArgs.push(arg);
     }
-    return { adapter, cwd, profile, timeoutMs, cliArgs };
+    return {
+        adapter,
+        cwd,
+        profile,
+        timeoutMs,
+        sessionStartMode: defaultSessionStartMode(adapter),
+        cliArgs,
+    };
 }
 function isPidAlive(pid) {
     if (!Number.isInteger(pid) || pid <= 0) {
@@ -247,6 +265,9 @@ export function buildBackgroundBridgeArgs(entryPath, options) {
         args.push("--experimental-strip-types");
     }
     args.push(entryPath, "--adapter", options.adapter, "--cwd", options.cwd, "--lifecycle", lifecycle);
+    if (options.sessionStartMode !== "restore") {
+        args.push("--session-start-mode", options.sessionStartMode);
+    }
     if (options.profile) {
         args.push("--profile", options.profile);
     }
@@ -304,6 +325,7 @@ async function ensureBridgeReady(options) {
         endpoint: endpointResult.endpoint,
         endpointIsReachable: Boolean(endpointResult.endpoint),
         companionIsAlive: isCompanionAlive(endpointResult.endpoint),
+        sessionStartMode: options.sessionStartMode,
     });
     log(options.adapter, decision.message);
     if (decision.kind === "already_active") {
@@ -355,6 +377,8 @@ export async function tryDelegateToDaemon(options, deps = {}) {
         profile: options.profile,
         cliArgs: options.cliArgs,
         openVisible: true,
+        sessionStartMode: options.sessionStartMode,
+        reuseExistingVisible: true,
     });
     if (!response.ok) {
         throw new Error(response.error);
@@ -374,6 +398,7 @@ export async function runVisibleClient(options, runners = {}) {
     return await (runners.localCompanion ?? runLocalCompanion)({
         adapter: options.adapter,
         cwd: options.cwd,
+        sessionStartMode: options.sessionStartMode,
         cliArgs: options.cliArgs,
     });
 }

package/dist/companion/local-companion.js

@@ -13,6 +13,7 @@ function log(adapter, message) {
 function parseCliArgs(argv) {
     let adapter = null;
     let cwd = process.cwd();
+    let sessionStartMode = "restore";
     const cliArgs = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -46,12 +47,20 @@ function parseCliArgs(argv) {
             i += 1;
             continue;
         }
+        if (arg === "--session-start-mode") {
+            if (!next || !["restore", "new"].includes(next)) {
+                throw new Error(`Invalid session start mode: ${next ?? "(missing)"}`);
+            }
+            sessionStartMode = next;
+            i += 1;
+            continue;
+        }
         cliArgs.push(arg);
     }
     if (!adapter) {
         throw new Error("Missing required --adapter <codex|claude|opencode>");
     }
-    return { adapter, cwd, cliArgs };
+    return { adapter, cwd, sessionStartMode, cliArgs };
 }
 function delay(ms) {
     if (ms <= 0) {
@@ -79,14 +88,22 @@ export async function runLocalCompanion(options) {
             extraCliArgs: options.cliArgs,
         });
     }
+    const shouldRestoreInitialSession = options.sessionStartMode !== "new";
     const adapter = createBridgeAdapter({
         kind: initialEndpoint.kind,
         command: initialEndpoint.command,
         cwd: initialEndpoint.cwd,
         profile: initialEndpoint.profile,
-        initialSharedSessionId: initialEndpoint.sharedSessionId ?? initialEndpoint.sharedThreadId,
-        initialResumeConversationId: initialEndpoint.resumeConversationId,
-        initialTranscriptPath: initialEndpoint.transcriptPath,
+        initialSharedSessionId: shouldRestoreInitialSession
+            ? initialEndpoint.sharedSessionId ?? initialEndpoint.sharedThreadId
+            : undefined,
+        initialResumeConversationId: shouldRestoreInitialSession
+            ? initialEndpoint.resumeConversationId
+            : undefined,
+        initialTranscriptPath: shouldRestoreInitialSession
+            ? initialEndpoint.transcriptPath
+            : undefined,
+        sessionStartMode: options.sessionStartMode,
         renderMode: initialEndpoint.kind === "codex" ? "panel" : "companion",
         extraCliArgs: options.cliArgs,
     });