cli-wechat-bridge 1.1.7 → 1.1.8

package/dist/bridge/wechat-bridge.js

@@ -12,6 +12,8 @@ import { getProcessRecordByPid, reapOrphanedOpencodeProcesses, reapPeerBridgePro
 import { createRuntimeHost } from "../runtime/create-runtime-host.js";
 import { toChannelInboundMessage } from "../channels/wechat/channel-message.js";
 import { routeBridgeMessage } from "../core/bridge-message-router.js";
+import { clearTurn, resolveConversationTarget, rollbackTurn, tryBeginTurn, } from "../core/conversation-routing.js";
+import { handleAdapterControl } from "./adapter-control.js";
 import { forwardBridgeEvent } from "../core/bridge-event-forwarder.js";
 import { isDirectModuleRun } from "../core/direct-run.js";
 import { WechatChannelPort } from "../channels/wechat/wechat-channel-port.js";
@@ -361,16 +363,17 @@ async function main() {
     let textSendChain = Promise.resolve();
     let attachmentSendChain = Promise.resolve();
     const pendingWechatForwardTasks = new Set();
-    let activeTask = null;
-    let currentWecomConversation = null;
-    let activeWecomConversation = null;
-    let lastWecomConversation = {
+    const defaultWecomConversation = {
         channelId: "wecom",
         accountId: wecomAccount?.botId,
         conversationId: credentials.userId,
         recipientId: credentials.userId,
         metadata: { chatType: "direct" },
     };
+    const turnState = {
+        activeTask: null,
+        lastConversation: defaultWecomConversation,
+    };
     const deferredInboundMessages = [];
     let drainingDeferredInboundMessages = false;
     let consecutivePollFailures = 0;
@@ -389,9 +392,11 @@ async function main() {
         if (options.channelId === "wecom") {
             const target = targetOverride ??
                 (senderId === credentials.userId
-                    ? currentWecomConversation ??
-                        activeWecomConversation ??
-                        lastWecomConversation
+                    ? resolveConversationTarget({
+                        active: turnState.activeConversation,
+                        last: turnState.lastConversation,
+                        fallback: defaultWecomConversation,
+                    })
                     : {
                         channelId: "wecom",
                         accountId: wecomAccount?.botId,
@@ -469,8 +474,15 @@ async function main() {
         return { status: "failed" };
     };
     const queueWechatMessage = (senderId, text, context = "message", targetOverride) => {
+        const queuedTarget = options.channelId === "wecom" && senderId === credentials.userId
+            ? targetOverride ?? resolveConversationTarget({
+                active: turnState.activeConversation,
+                last: turnState.lastConversation,
+                fallback: defaultWecomConversation,
+            })
+            : targetOverride;
         return queueWechatTextAction(async () => {
-            const result = await sendWechatMessageNow(senderId, text, context, targetOverride);
+            const result = await sendWechatMessageNow(senderId, text, context, queuedTarget);
             if (result.status === "context_unavailable") {
                 const pending = pendingWechatMessages.enqueue(senderId, text, context, result.target);
                 if (pending) {
@@ -514,7 +526,13 @@ async function main() {
         }
     };
     const outputBatcher = new OutputBatcher(async (text) => {
-        await queueWechatMessage(stateStore.getState().authorizedUserId, text);
+        await queueWechatMessage(stateStore.getState().authorizedUserId, text, "message", options.channelId === "wecom"
+            ? resolveConversationTarget({
+                active: turnState.activeConversation,
+                last: turnState.lastConversation,
+                fallback: defaultWecomConversation,
+            })
+            : undefined);
     });
     const maybeDrainDeferredInboundMessages = async () => {
         if (drainingDeferredInboundMessages || !ensureRuntimeOwnership()) {
@@ -529,7 +547,7 @@ async function main() {
             hasPendingConfirmation: Boolean(stateStore.getState().pendingConfirmation),
             hasPendingUserInput: Boolean(stateStore.getState().pendingUserInput),
             hasPendingApproval: Boolean(adapterState.pendingApproval),
-            hasActiveTask: Boolean(activeTask),
+            hasActiveTask: Boolean(turnState.activeTask),
         })) {
             return;
         }
@@ -540,17 +558,25 @@ async function main() {
         drainingDeferredInboundMessages = true;
         try {
             stateStore.appendLog(`draining_deferred_inbound_input: remaining=${deferredInboundMessages.length} text=${truncatePreview(nextDeferred.message.text)}`);
-            if (nextDeferred.channelMessage) {
-                activeWecomConversation = nextDeferred.channelMessage.conversation;
-                lastWecomConversation = nextDeferred.channelMessage.conversation;
+            const nextTask = createActiveTask(nextDeferred.message);
+            const lease = tryBeginTurn(turnState, nextTask, nextDeferred.channelMessage?.conversation);
+            if (!lease) {
+                deferredInboundMessages.unshift(nextDeferred);
+                return;
+            }
+            try {
+                await dispatchInboundWechatText({
+                    message: nextDeferred.message,
+                    options,
+                    stateStore,
+                    adapter,
+                    activeTask: nextTask,
+                });
+            }
+            catch (error) {
+                rollbackTurn(turnState, lease);
+                throw error;
             }
-            const nextTask = await dispatchInboundWechatText({
-                message: nextDeferred.message,
-                options,
-                stateStore,
-                adapter,
-            });
-            activeTask = nextTask;
         }
         catch (err) {
             const errorText = err instanceof Error ? err.message : String(err);
@@ -565,7 +591,7 @@ async function main() {
                 adapter: options.adapter,
                 cwd: options.cwd,
                 errorText,
-            }), "inbound_error");
+            }), "inbound_error", nextDeferred.channelMessage?.conversation);
         }
         finally {
             drainingDeferredInboundMessages = false;
@@ -715,9 +741,11 @@ async function main() {
             queueWechatMessage,
             trackWechatForwardTask,
             maybeDrainDeferredInboundMessages,
-            clearActiveTask: () => {
-                activeTask = null;
-                activeWecomConversation = null;
+            getActiveTask: () => turnState.activeTask,
+            clearActiveTask: (expectedTask) => {
+                if (expectedTask) {
+                    clearTurn(turnState, expectedTask);
+                }
             },
             syncSharedSessionState: () => {
                 syncSharedSessionState(stateStore, adapter);
@@ -727,7 +755,11 @@ async function main() {
             },
             requestShutdown,
             wecomTransport,
-            getWecomTarget: () => activeWecomConversation ?? lastWecomConversation,
+            getWecomTarget: () => resolveConversationTarget({
+                active: turnState.activeConversation,
+                last: turnState.lastConversation,
+                fallback: defaultWecomConversation,
+            }),
         });
         await adapter.start();
         if (!ensureRuntimeOwnership()) {
@@ -742,59 +774,73 @@ async function main() {
                     if (shutdownPromise || !ensureRuntimeOwnership()) {
                         return;
                     }
-                    currentWecomConversation = channelMessage.conversation;
-                    lastWecomConversation = channelMessage.conversation;
+                    turnState.lastConversation = channelMessage.conversation;
+                    const queueInboundReply = (senderId, text, context) => queueWechatMessage(senderId, text, context, channelMessage.conversation);
+                    if (pendingWechatMessages.list().length > 0) {
+                        await flushPendingWechatMessages();
+                    }
+                    const message = toLegacyInboundWechatMessage(channelMessage);
+                    const taskAtMessageStart = turnState.activeTask;
+                    stateStore.touchActivity(message.createdAt);
                     try {
-                        if (pendingWechatMessages.list().length > 0) {
-                            await flushPendingWechatMessages();
-                        }
-                        const message = toLegacyInboundWechatMessage(channelMessage);
-                        stateStore.touchActivity(message.createdAt);
-                        let nextTask = null;
-                        try {
-                            nextTask = await handleInboundMessage({
-                                message,
-                                channelMessage,
-                                options,
-                                stateStore,
-                                adapter,
-                                resumeCoordinator,
-                                queueWechatMessage,
-                                outputBatcher,
-                                clearActiveTask: () => {
-                                    activeTask = null;
-                                    activeWecomConversation = null;
-                                },
-                                deferInboundMessage: async (nextMessage) => {
-                                    deferredInboundMessages.push({
-                                        message: nextMessage,
-                                        channelMessage,
+                        await handleInboundMessage({
+                            message,
+                            channelMessage,
+                            options,
+                            stateStore,
+                            adapter,
+                            resumeCoordinator,
+                            queueWechatMessage: queueInboundReply,
+                            outputBatcher,
+                            clearActiveTask: () => {
+                                if (taskAtMessageStart) {
+                                    clearTurn(turnState, taskAtMessageStart);
+                                }
+                            },
+                            dispatchInboundText: async () => {
+                                const nextActiveTask = createActiveTask(message);
+                                const lease = tryBeginTurn(turnState, nextActiveTask, channelMessage.conversation);
+                                if (!lease) {
+                                    await queueInboundReply(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);
+                                    return null;
+                                }
+                                try {
+                                    await dispatchInboundWechatText({
+                                        message,
+                                        options,
+                                        stateStore,
+                                        adapter,
+                                        activeTask: nextActiveTask,
                                     });
-                                    stateStore.appendLog(`deferred_inbound_input: position=${deferredInboundMessages.length} text=${truncatePreview(nextMessage.text)}`);
-                                    await queueWechatMessage(nextMessage.senderId, formatDeferredCodexInboundQueueMessage(deferredInboundMessages.length));
-                                },
-                            });
-                        }
-                        catch (error) {
-                            const errorText = error instanceof Error ? error.message : String(error);
-                            logError(errorText);
-                            stateStore.appendLog(`inbound_error: ${errorText}`);
-                            await queueWechatMessage(message.senderId, formatUserFacingInboundError({
-                                adapter: options.adapter,
-                                cwd: options.cwd,
-                                errorText,
-                            }), "inbound_error");
-                        }
-                        if (nextTask) {
-                            activeTask = nextTask;
-                            activeWecomConversation = channelMessage.conversation;
-                        }
-                        syncSharedSessionState(stateStore, adapter);
-                        await maybeDrainDeferredInboundMessages();
+                                    return nextActiveTask;
+                                }
+                                catch (error) {
+                                    rollbackTurn(turnState, lease);
+                                    throw error;
+                                }
+                            },
+                            deferInboundMessage: async (nextMessage) => {
+                                deferredInboundMessages.push({
+                                    message: nextMessage,
+                                    channelMessage,
+                                });
+                                stateStore.appendLog(`deferred_inbound_input: position=${deferredInboundMessages.length} text=${truncatePreview(nextMessage.text)}`);
+                                await queueInboundReply(nextMessage.senderId, formatDeferredCodexInboundQueueMessage(deferredInboundMessages.length));
+                            },
+                        });
                     }
-                    finally {
-                        currentWecomConversation = null;
+                    catch (error) {
+                        const errorText = error instanceof Error ? error.message : String(error);
+                        logError(errorText);
+                        stateStore.appendLog(`inbound_error: ${errorText}`);
+                        await queueInboundReply(message.senderId, formatUserFacingInboundError({
+                            adapter: options.adapter,
+                            cwd: options.cwd,
+                            errorText,
+                        }), "inbound_error");
                     }
+                    syncSharedSessionState(stateStore, adapter);
+                    await maybeDrainDeferredInboundMessages();
                 },
                 onUnauthorized: async (senderId, chatType) => {
                     stateStore.appendLog(`wecom_unauthorized: sender=${senderId} chat_type=${chatType}`);
@@ -910,10 +956,10 @@ async function main() {
                 if (!ensureRuntimeOwnership()) {
                     break;
                 }
+                const taskAtMessageStart = turnState.activeTask;
                 stateStore.touchActivity(message.createdAt);
-                let nextTask = null;
                 try {
-                    nextTask = await handleInboundMessage({
+                    await handleInboundMessage({
                         message,
                         options,
                         stateStore,
@@ -922,7 +968,31 @@ async function main() {
                         queueWechatMessage,
                         outputBatcher,
                         clearActiveTask: () => {
-                            activeTask = null;
+                            if (taskAtMessageStart) {
+                                clearTurn(turnState, taskAtMessageStart);
+                            }
+                        },
+                        dispatchInboundText: async () => {
+                            const nextActiveTask = createActiveTask(message);
+                            const lease = tryBeginTurn(turnState, nextActiveTask);
+                            if (!lease) {
+                                await queueWechatMessage(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);
+                                return null;
+                            }
+                            try {
+                                await dispatchInboundWechatText({
+                                    message,
+                                    options,
+                                    stateStore,
+                                    adapter,
+                                    activeTask: nextActiveTask,
+                                });
+                                return nextActiveTask;
+                            }
+                            catch (error) {
+                                rollbackTurn(turnState, lease);
+                                throw error;
+                            }
                         },
                         deferInboundMessage: async (nextMessage) => {
                             deferredInboundMessages.push({
@@ -943,9 +1013,6 @@ async function main() {
                         errorText,
                     }), "inbound_error");
                 }
-                if (nextTask) {
-                    activeTask = nextTask;
-                }
                 syncSharedSessionState(stateStore, adapter);
                 await maybeDrainDeferredInboundMessages();
             }
@@ -980,7 +1047,7 @@ function syncSharedSessionState(stateStore, adapter) {
     }
 }
 function wireAdapterEvents(params) {
-    const { adapter, resumeCoordinator, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, clearActiveTask, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, wecomTransport, getWecomTarget, } = params;
+    const { adapter, resumeCoordinator, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, getActiveTask, clearActiveTask, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, wecomTransport, getWecomTarget, } = params;
     const channelPort = options.channelId === "wecom"
         ? new WecomChannelPort({
             transport: wecomTransport,
@@ -1016,6 +1083,14 @@ function wireAdapterEvents(params) {
             stateStore.clearPendingUserInput();
         }
         const authorizedUserId = stateStore.getState().authorizedUserId;
+        const eventTarget = options.channelId === "wecom"
+            ? getWecomTarget()
+            : {
+                channelId: "wechat",
+                conversationId: authorizedUserId,
+                recipientId: authorizedUserId,
+            };
+        const eventTask = getActiveTask();
         eventForwardChain = eventForwardChain
             .then(() => forwardBridgeEvent(event, {
             stdout: (next) => {
@@ -1033,13 +1108,7 @@ function wireAdapterEvents(params) {
                 stateStore.appendLog(`final_reply: ${truncatePreview(next.text)}`);
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     await channelPort.send({
-                        target: options.channelId === "wecom"
-                            ? getWecomTarget()
-                            : {
-                                channelId: "wechat",
-                                conversationId: authorizedUserId,
-                                recipientId: authorizedUserId,
-                            },
+                        target: eventTarget,
                         kind: "final_reply",
                         text: next.text,
                         adapter: options.adapter,
@@ -1057,7 +1126,7 @@ function wireAdapterEvents(params) {
                 stateStore.appendLog(`${next.level}_notice: ${truncatePreview(next.text)}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, next.type, { text: next.text })) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                        await queueWechatMessage(authorizedUserId, next.text, "notice");
+                        await queueWechatMessage(authorizedUserId, next.text, "notice", eventTarget);
                     }));
                 }
             },
@@ -1069,7 +1138,7 @@ function wireAdapterEvents(params) {
                         trackWechatForwardTask((async () => {
                             await queueWechatMessage(authorizedUserId, options.channelId === "wecom"
                                 ? `Processing: ${thinkingPreview}`
-                                : `思考: ${thinkingPreview}`, "thinking");
+                                : `思考: ${thinkingPreview}`, "thinking", eventTarget);
                         })());
                     }
                 }
@@ -1079,7 +1148,7 @@ function wireAdapterEvents(params) {
                     const pending = toPendingApproval(next.request);
                     stateStore.setPendingConfirmation(pending);
                     stateStore.appendLog(`Approval requested (${pending.source}): ${pending.commandPreview}`);
-                    await queueWechatMessage(authorizedUserId, formatApprovalMessage(pending, adapterState), "approval_required");
+                    await queueWechatMessage(authorizedUserId, formatApprovalMessage(pending, adapterState), "approval_required", eventTarget);
                 }));
             },
             userInputRequired: (next) => {
@@ -1087,14 +1156,14 @@ function wireAdapterEvents(params) {
                     const pending = toPendingUserInput(next.request);
                     stateStore.setPendingUserInput(pending);
                     stateStore.appendLog(`User input requested: questions=${pending.questions.length}`);
-                    await queueWechatMessage(authorizedUserId, formatUserInputRequestMessage(pending, adapterState), "user_input_required");
+                    await queueWechatMessage(authorizedUserId, formatUserInputRequestMessage(pending, adapterState), "user_input_required", eventTarget);
                 }));
             },
             mirroredUserInput: (next) => {
                 stateStore.appendLog(`mirrored_local_input: ${truncatePreview(next.text)}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, next.type, { text: next.text })) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                        await queueWechatMessage(authorizedUserId, formatMirroredUserInputMessage(options.adapter, next.text), "mirrored_user_input");
+                        await queueWechatMessage(authorizedUserId, formatMirroredUserInputMessage(options.adapter, next.text), "mirrored_user_input", eventTarget);
                     }));
                 }
             },
@@ -1104,7 +1173,7 @@ function wireAdapterEvents(params) {
                 stateStore.appendLog(`session_switched: ${next.sessionId} source=${next.source} reason=${next.reason}`);
                 if (shouldForwardSessionSwitchEvent(next.reason) && shouldForwardBridgeEventToWechat(options.adapter, next.type)) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                        await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({ adapter: options.adapter, sessionId: next.sessionId, source: next.source, reason: next.reason }), "session_switched");
+                        await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({ adapter: options.adapter, sessionId: next.sessionId, source: next.source, reason: next.reason }), "session_switched", eventTarget);
                     }));
                 }
             },
@@ -1122,7 +1191,7 @@ function wireAdapterEvents(params) {
                 }
                 if (shouldForwardSessionSwitchEvent(next.reason) && shouldForwardBridgeEventToWechat(options.adapter, next.type)) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                        await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({ adapter: options.adapter, sessionId: next.threadId, source: next.source, reason: next.reason }), "thread_switched");
+                        await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({ adapter: options.adapter, sessionId: next.threadId, source: next.source, reason: next.reason }), "thread_switched", eventTarget);
                     }));
                 }
                 void maybeDrainDeferredInboundMessages();
@@ -1131,7 +1200,7 @@ function wireAdapterEvents(params) {
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
                     stateStore.clearPendingUserInput();
-                    clearActiveTask();
+                    clearActiveTask(eventTask);
                     await maybeDrainDeferredInboundMessages();
                 }));
             },
@@ -1139,8 +1208,8 @@ function wireAdapterEvents(params) {
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
                     stateStore.clearPendingUserInput();
-                    clearActiveTask();
-                    await queueWechatMessage(authorizedUserId, formatTaskFailedMessage(options.adapter, next.message), "task_failed");
+                    clearActiveTask(eventTask);
+                    await queueWechatMessage(authorizedUserId, formatTaskFailedMessage(options.adapter, next.message), "task_failed", eventTarget);
                     await maybeDrainDeferredInboundMessages();
                 }));
             },
@@ -1149,9 +1218,9 @@ function wireAdapterEvents(params) {
                 stateStore.appendLog(`fatal_error: ${next.message}`);
                 stateStore.clearPendingConfirmation();
                 stateStore.clearPendingUserInput();
-                clearActiveTask();
+                clearActiveTask(eventTask);
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                    await queueWechatMessage(authorizedUserId, formatUserFacingBridgeFatalError(next.message), "fatal_error");
+                    await queueWechatMessage(authorizedUserId, formatUserFacingBridgeFatalError(next.message), "fatal_error", eventTarget);
                     await maybeDrainDeferredInboundMessages();
                 }));
             },
@@ -1180,7 +1249,7 @@ function formatInboundMessagePreview(message) {
 }
 async function handleInboundMessage(params) {
     const { message, channelMessage, } = params;
-    const { options, stateStore, adapter, resumeCoordinator, queueWechatMessage, outputBatcher, clearActiveTask, deferInboundMessage, } = params;
+    const { options, stateStore, adapter, resumeCoordinator, queueWechatMessage, outputBatcher, clearActiveTask, dispatchInboundText, deferInboundMessage, } = params;
     const state = stateStore.getState();
     if (message.senderId !== state.authorizedUserId) {
         await queueWechatMessage(message.senderId, options.channelId === "wecom"
@@ -1194,6 +1263,10 @@ async function handleInboundMessage(params) {
         hasPendingUserInput: Boolean(state.pendingUserInput),
     });
     switch (systemCommand?.type) {
+        case "model":
+        case "plan":
+            await queueWechatMessage(message.senderId, await handleAdapterControl(adapter, message.senderId, systemCommand));
+            return null;
         case "status":
             await queueWechatMessage(message.senderId, formatStatusReport(stateStore.getState(), adapter.getState()));
             return null;
@@ -1348,24 +1421,20 @@ async function handleInboundMessage(params) {
         defer: async () => {
             await deferInboundMessage(message);
         },
-        dispatch: async () => {
-            return await dispatchInboundWechatText({
-                message,
-                options,
-                stateStore,
-                adapter,
-            });
-        },
+        dispatch: dispatchInboundText,
     });
     return routeResult.kind === "dispatched" ? routeResult.result : null;
 }
+function createActiveTask(message) {
+    return {
+        startedAt: Date.now(),
+        inputPreview: truncatePreview(formatInboundMessagePreview(message), 180),
+    };
+}
 async function dispatchInboundWechatText(params) {
     const { message, options, stateStore, adapter } = params;
     const preview = formatInboundMessagePreview(message);
-    const activeTask = {
-        startedAt: Date.now(),
-        inputPreview: truncatePreview(preview, 180),
-    };
+    const activeTask = params.activeTask ?? createActiveTask(message);
     stateStore.appendLog(`Forwarded input to ${options.adapter}: ${truncatePreview(preview)}`);
     await adapter.sendInput(options.channelId === "wecom"
         ? buildWecomInboundPrompt(message.text, message.attachments)

package/dist/companion/codex-remote-client.js

@@ -5,7 +5,7 @@ import net from "node:net";
 import path from "node:path";
 import { assertNoReservedExtraCliArgs, buildCliEnvironment, buildCodexCliArgs, resolveSpawnTarget, } from "../bridge/bridge-adapters.shared.js";
 import { killProcessTreeSync } from "../bridge/bridge-process-reaper.js";
-import { CODEX_VISIBLE_CONTROL_HOST, parseCodexVisibleSwitchRequest, sendCodexVisibleSwitchResponse, } from "./codex-visible-client-link.js";
+import { CODEX_VISIBLE_CONTROL_HOST, parseCodexVisibleControlRequest, sendCodexVisibleShutdownResponse, sendCodexVisibleSwitchResponse, } from "./codex-visible-client-link.js";
 import { clearLocalCompanionOccupancy, readLocalCompanionEndpoint, updateCodexVisibleControl, updateLocalCompanionOccupancy, } from "./local-companion-link.js";
 import { migrateLegacyChannelFiles } from "../wechat/channel-config.js";
 import { CODEX_REMOTE_AUTH_TOKEN_ENV } from "../runtime/runtime-types.js";
@@ -302,11 +302,20 @@ export class CodexVisibleClientSupervisor {
                     socket.destroy();
                     return;
                 }
-                const request = parseCodexVisibleSwitchRequest(parsed);
+                const request = parseCodexVisibleControlRequest(parsed);
                 if (!request || request.token !== this.controlToken) {
                     socket.destroy();
                     return;
                 }
+                if (request.type === "shutdown") {
+                    sendCodexVisibleShutdownResponse(socket, {
+                        type: "shutdown_result",
+                        id: request.id,
+                        ok: true,
+                    });
+                    void this.shutdownFromControl();
+                    return;
+                }
                 void this.switchThread(request.threadId).then(() => {
                     sendCodexVisibleSwitchResponse(socket, {
                         type: "switch_thread_result",
@@ -340,6 +349,17 @@ export class CodexVisibleClientSupervisor {
         this.controlServer = server;
         this.controlPort = address.port;
     }
+    async shutdownFromControl() {
+        await this.switchChain.catch(() => undefined);
+        if (this.runSettled) {
+            return;
+        }
+        const child = this.child;
+        if (child) {
+            await this.stopChild(child);
+        }
+        this.finishRun(undefined, 0);
+    }
     async closeControlServer() {
         const server = this.controlServer;
         this.controlServer = null;