@unlinearity/cli-wechat-bridge 1.0.4 → 1.0.6

package/dist/bridge/bridge-adapters.codex.js

@@ -7,7 +7,7 @@ import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
 import * as shared from "./bridge-adapters.shared.js";
 import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { CODEX_REMOTE_AUTH_TOKEN_ENV, LOCAL_CLIENT_PROTOCOL_VERSION, } from "../runtime/runtime-types.js";
-const { CODEX_APP_SERVER_HOST, CODEX_APP_SERVER_LOG_LIMIT, CODEX_APP_SERVER_READY_TIMEOUT_MS, CODEX_FINAL_REPLY_SETTLE_DELAY_MS, CODEX_RECENT_SESSION_KEY_LIMIT, CODEX_RPC_CONNECT_RETRY_MS, CODEX_RPC_RECONNECT_TIMEOUT_MS, CODEX_SESSION_FALLBACK_SCAN_INTERVAL_MS, CODEX_SESSION_LOCAL_MIRROR_FALLBACK_WINDOW_MS, CODEX_SESSION_POLL_INTERVAL_MS, CODEX_STARTUP_WARMUP_MS, CODEX_THREAD_SIGNAL_TTL_MS, INTERRUPT_SETTLE_DELAY_MS, appendBoundedLog, buildCliEnvironment, buildCodexApprovalRequest, buildCodexCliArgs, buildCodexUserInputRequest, coerceWebSocketMessageData, delay, describeUnknownError, extractCodexFinalTextFromItem, extractCodexThreadFollowIdFromStatusChanged, extractCodexThreadStartedThreadId, extractCodexUserMessageText, findCodexSessionFile, findRecentCodexSessionFileForCwd, getCodexRpcRequestId, getNotificationThreadId, getNotificationTurnId, isRecord, isRecentIsoTimestamp, listCodexResumeSessions, normalizeComparablePath, normalizeCodexRpcError, reserveLocalPort, resolveSpawnTarget, shouldAutoCompleteCodexWechatTurnAfterFinalReply, shouldIgnoreCodexSessionReplayEntry, shouldRecoverCodexStaleBusyState, waitForTcpPort, } = shared;
+const { CODEX_APP_SERVER_HOST, CODEX_APP_SERVER_LOG_LIMIT, CODEX_APP_SERVER_READY_TIMEOUT_MS, CODEX_FINAL_REPLY_SETTLE_DELAY_MS, CODEX_RECENT_SESSION_KEY_LIMIT, CODEX_RPC_CONNECT_RETRY_MS, CODEX_RPC_RECONNECT_TIMEOUT_MS, CODEX_SESSION_FALLBACK_SCAN_INTERVAL_MS, CODEX_SESSION_LOCAL_MIRROR_FALLBACK_WINDOW_MS, CODEX_SESSION_POLL_INTERVAL_MS, CODEX_STARTUP_WARMUP_MS, CODEX_THREAD_SIGNAL_TTL_MS, INTERRUPT_SETTLE_DELAY_MS, appendBoundedLog, buildCliEnvironment, buildCodexApprovalRequest, buildCodexCliArgs, buildCodexDynamicToolCallFailureResponse, buildCodexMcpServerElicitationDeclineResponse, buildCodexPermissionsRequestApprovalResponse, buildCodexUserInputRequest, coerceWebSocketMessageData, delay, describeUnknownError, extractCodexFinalTextFromItem, extractCodexThreadFollowIdFromStatusChanged, extractCodexThreadStartedThreadId, extractCodexUserMessageText, findCodexSessionFile, findRecentCodexSessionFileForCwd, getCodexRpcRequestId, getCodexApprovalAutoResponse, getCodexWechatOutboundAttachmentDenyMessage, getNotificationThreadId, getNotificationTurnId, isRecord, isRecentIsoTimestamp, listCodexResumeSessions, normalizeComparablePath, normalizeCodexRpcError, reserveLocalPort, resolveSpawnTarget, shouldAutoCompleteCodexWechatTurnAfterFinalReply, shouldIgnoreCodexSessionReplayEntry, shouldRecoverCodexStaleBusyState, waitForTcpPort, } = shared;
 const CODEX_LOCAL_THREAD_ANNOUNCE_SETTLE_MS = 150;
 export class CodexPtyAdapter extends AbstractPtyAdapter {
     runtimeKind = "codex_runtime_host";
@@ -24,6 +24,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     cleanPanelExitInProgress = false;
     rpcRequestCounter = 0;
     pendingRpcRequests = new Map();
+    subscribedThreadIds = new Set();
     sharedThreadId = null;
     announcedThreadId = null;
     pendingThreadAnnouncement = null;
@@ -194,6 +195,27 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         return await super.resolveApproval(action);
     }
+    async submitUserInput(answers) {
+        if (!this.pendingUserInputRequest) {
+            return false;
+        }
+        const request = this.pendingUserInputRequest;
+        const responseAnswers = {};
+        for (const [questionId, values] of Object.entries(answers)) {
+            responseAnswers[questionId] = {
+                answers: values,
+            };
+        }
+        this.sendRpcMessage({
+            id: request.requestId,
+            result: {
+                answers: responseAnswers,
+            },
+        });
+        this.clearPendingUserInputState();
+        this.setStatus("busy", "Codex user input submitted.");
+        return true;
+    }
     async dispose() {
         this.resetTurnTracking({ preserveThread: false });
         if (this.isEmbeddedCliMode()) {
@@ -752,6 +774,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (this.pendingApproval) {
             throw new Error("A Codex approval request is pending. Reply with /confirm <code> or /deny.");
         }
+        if (this.pendingUserInputRequest || this.state.pendingUserInput) {
+            throw new Error("Codex is waiting for user input. Reply with /answer and your response, or use /stop.");
+        }
         if (this.pendingTurnStart || this.activeTurn || this.state.status === "busy") {
             const origin = this.state.activeTurnOrigin;
             if (origin === "local") {
@@ -766,6 +791,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.rememberInjectedInput(text);
         this.clearPendingApprovalState();
         const threadId = await this.ensureThreadStarted();
+        const subscribedBeforeTurnStart = await this.tryEnsureSharedThreadSubscribed(threadId);
         this.pendingTurnStart = true;
         this.pendingTurnThreadId = threadId;
         this.interruptPendingTurnStart = false;
@@ -793,6 +819,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 turnId,
                 origin: "wechat",
             });
+            if (!subscribedBeforeTurnStart) {
+                await this.tryEnsureSharedThreadSubscribed(threadId);
+            }
             if (this.interruptPendingTurnStart) {
                 await this.requestActiveTurnInterrupt();
                 this.armInterruptFallback();
@@ -813,11 +842,15 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (this.isNativePanelMode() && !this.nativeProcess) {
             return false;
         }
-        const turnPending = this.pendingTurnStart || this.state.status === "busy" || this.state.status === "awaiting_approval";
+        const turnPending = this.pendingTurnStart ||
+            this.state.status === "busy" ||
+            this.state.status === "awaiting_approval" ||
+            this.state.status === "awaiting_input";
         if (!turnPending) {
             return false;
         }
         this.clearPendingApprovalState();
+        this.clearPendingUserInputState();
         if (this.pendingTurnStart && !this.activeTurn) {
             this.interruptPendingTurnStart = true;
             this.armInterruptFallback();
@@ -980,6 +1013,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     attachRpcSocket(socket) {
         this.rpcSocket = socket;
         this.rpcShuttingDown = false;
+        this.subscribedThreadIds.clear();
         socket.addEventListener("message", (event) => {
             this.handleRpcMessageData(event.data);
         });
@@ -991,6 +1025,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         const socket = this.rpcSocket;
         this.rpcSocket = null;
         this.rpcShuttingDown = true;
+        this.subscribedThreadIds.clear();
         this.rejectPendingRpcRequests("Codex websocket connection closed.");
         if (!socket) {
             this.rpcShuttingDown = false;
@@ -1028,6 +1063,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             cleanPanelExitInProgress: this.cleanPanelExitInProgress,
         });
         this.rpcSocket = null;
+        this.subscribedThreadIds.clear();
         this.rejectPendingRpcRequests("Codex websocket connection closed.");
         this.rpcShuttingDown = false;
         if (expectedShutdown) {
@@ -1156,9 +1192,44 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             throw new Error("Codex did not return a thread id for the bridge session.");
         }
         this.rememberBridgeOwnedThreadSignal(threadId);
+        this.subscribedThreadIds.add(threadId);
         this.updateSharedThread(threadId);
         return threadId;
     }
+    async tryEnsureSharedThreadSubscribed(threadId) {
+        if (this.subscribedThreadIds.has(threadId)) {
+            return true;
+        }
+        try {
+            await this.ensureSharedThreadSubscribed(threadId);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async ensureSharedThreadSubscribed(threadId) {
+        if (this.subscribedThreadIds.has(threadId)) {
+            return;
+        }
+        const response = await this.sendRpcRequest("thread/resume", {
+            threadId,
+            cwd: this.options.cwd,
+            approvalPolicy: "on-request",
+            approvalsReviewer: "user",
+            sandbox: "workspace-write",
+            excludeTurns: true,
+        });
+        const resumedThreadId = this.extractThreadIdFromResponse(response);
+        if (!resumedThreadId) {
+            throw new Error("Codex did not return a thread id while subscribing the bridge client.");
+        }
+        this.rememberBridgeOwnedThreadSignal(resumedThreadId);
+        this.subscribedThreadIds.add(resumedThreadId);
+        if (resumedThreadId !== this.sharedThreadId) {
+            this.updateSharedThread(resumedThreadId);
+        }
+    }
     async resumeSharedThread(threadId, options = {}) {
         const trimmedThreadId = threadId.trim();
         if (!trimmedThreadId) {
@@ -1180,12 +1251,14 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             approvalPolicy: "on-request",
             approvalsReviewer: "user",
             sandbox: "workspace-write",
+            excludeTurns: true,
         });
         const resumedThreadId = this.extractThreadIdFromResponse(response);
         if (!resumedThreadId) {
             throw new Error("Codex did not return a thread id while resuming the saved thread.");
         }
         this.rememberBridgeOwnedThreadSignal(resumedThreadId);
+        this.subscribedThreadIds.add(resumedThreadId);
         this.sessionFilePath = null;
         this.sessionReadOffset = 0;
         this.sessionPartialLine = "";
@@ -1238,7 +1311,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.clearInterruptTimer();
         this.interruptTimer = setTimeout(() => {
             this.interruptTimer = null;
-            if (this.state.status !== "busy" && this.state.status !== "awaiting_approval") {
+            if (this.state.status !== "busy" &&
+                this.state.status !== "awaiting_approval" &&
+                this.state.status !== "awaiting_input") {
                 return;
             }
             this.resetTurnTracking({ preserveThread: true });
@@ -1263,6 +1338,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             pendingTurnStart: this.pendingTurnStart,
             hasActiveTurn: Boolean(this.activeTurn),
             hasPendingApproval: Boolean(this.pendingApproval || this.pendingApprovalRequest),
+            hasPendingUserInput: Boolean(this.pendingUserInputRequest || this.state.pendingUserInput),
             activeTurnId: this.state.activeTurnId,
         })) {
             return;
@@ -1301,6 +1377,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.interruptPendingTurnStart = false;
         this.pendingThreadFollowId = null;
         this.clearPendingApprovalState();
+        this.clearPendingUserInputState();
         this.queuedTurnNotifications = [];
         this.queuedTurnServerRequests = [];
         this.turnFinalMessages.clear();
@@ -1503,6 +1580,11 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.state.pendingApproval = null;
         this.state.pendingApprovalOrigin = undefined;
     }
+    clearPendingUserInputState() {
+        this.pendingUserInputRequest = null;
+        this.state.pendingUserInput = null;
+        this.state.pendingUserInputOrigin = undefined;
+    }
     cleanupTurnArtifacts(turnId) {
         this.clearFinalReplyCompletionTimerForTurn(turnId);
         this.turnFinalMessages.delete(turnId);
@@ -1570,6 +1652,13 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         socket.send(JSON.stringify(payload));
     }
     async respondToApprovalRequest(request, action) {
+        if (request.method === "item/permissions/requestApproval") {
+            this.sendRpcMessage({
+                id: request.requestId,
+                result: buildCodexPermissionsRequestApprovalResponse(request.params, action),
+            });
+            return;
+        }
         const decision = action === "confirm" ? "accept" : "decline";
         this.sendRpcMessage({
             id: request.requestId,
@@ -1754,6 +1843,15 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                         this.setStatus("busy", "Codex approval resolved.");
                     }
                 }
+                if (requestId !== null &&
+                    this.pendingUserInputRequest &&
+                    requestId === this.pendingUserInputRequest.requestId &&
+                    trackedTurn.turnId === this.pendingUserInputRequest.turnId) {
+                    this.clearPendingUserInputState();
+                    if (this.state.status === "awaiting_input") {
+                        this.setStatus("busy", "Codex user input resolved.");
+                    }
+                }
                 return;
             }
             case "turn/completed": {
@@ -1764,8 +1862,24 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
     }
     handleRpcServerRequest(requestId, method, params) {
+        if (method === "mcpServer/elicitation/request") {
+            this.sendRpcMessage({
+                id: requestId,
+                result: buildCodexMcpServerElicitationDeclineResponse(),
+            });
+            return;
+        }
+        if (method === "item/tool/call") {
+            this.sendRpcMessage({
+                id: requestId,
+                result: buildCodexDynamicToolCallFailureResponse(),
+            });
+            return;
+        }
         if (method !== "item/commandExecution/requestApproval" &&
-            method !== "item/fileChange/requestApproval") {
+            method !== "item/fileChange/requestApproval" &&
+            method !== "item/permissions/requestApproval" &&
+            method !== "item/tool/requestUserInput") {
             this.sendRpcMessage({
                 id: requestId,
                 error: {
@@ -1793,16 +1907,57 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             });
             return;
         }
-        const trackedTurn = this.identifyTrackedTurn("server/request", params);
+        const trackedTurn = this.identifyTrackedTurn("server/request", params) ??
+            this.fallbackTrackedTurnForServerRequest(params);
         if (!trackedTurn) {
+            this.sendRpcMessage({
+                id: requestId,
+                error: {
+                    code: -32602,
+                    message: "Invalid Codex server request payload: missing threadId or turnId.",
+                },
+            });
             return;
         }
         this.handleTrackedTurnStarted(trackedTurn);
         this.handleTrackedTurnServerRequest(requestId, method, params, trackedTurn);
     }
     handleTrackedTurnServerRequest(requestId, method, params, trackedTurn) {
+        if (method === "item/tool/requestUserInput") {
+            this.handleTrackedTurnUserInputRequest(requestId, params, trackedTurn);
+            return;
+        }
+        const denyMessage = getCodexWechatOutboundAttachmentDenyMessage(method, params);
+        if (denyMessage) {
+            this.sendRpcMessage({
+                id: requestId,
+                result: method === "item/permissions/requestApproval"
+                    ? buildCodexPermissionsRequestApprovalResponse(params, "deny")
+                    : { decision: "decline" },
+            });
+            this.state.lastOutputAt = nowIso();
+            this.setStatus("busy", `Codex approval auto-denied: ${truncatePreview(denyMessage, 180)}`);
+            return;
+        }
+        const autoResponse = getCodexApprovalAutoResponse(method, params);
+        if (autoResponse) {
+            this.sendRpcMessage({
+                id: requestId,
+                result: autoResponse.result,
+            });
+            this.state.lastOutputAt = nowIso();
+            this.setStatus("busy", `Codex approval auto-approved: ${truncatePreview(autoResponse.reason, 180)}`);
+            return;
+        }
         const request = buildCodexApprovalRequest(method, params);
         if (!request) {
+            this.sendRpcMessage({
+                id: requestId,
+                error: {
+                    code: -32602,
+                    message: "Invalid Codex approval request payload.",
+                },
+            });
             return;
         }
         this.pendingApprovalRequest = {
@@ -1811,18 +1966,63 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             threadId: trackedTurn.threadId,
             turnId: trackedTurn.turnId,
             origin: trackedTurn.origin,
+            params,
         };
         this.pendingApproval = request;
         this.state.pendingApproval = request;
         this.state.pendingApprovalOrigin = trackedTurn.origin;
         this.state.lastOutputAt = nowIso();
-        this.setStatus("awaiting_approval", "Codex approval is required.");
+        this.setStatus("awaiting_approval", `Codex approval is required: ${truncatePreview(request.commandPreview, 180)}`);
         this.emit({
             type: "approval_required",
             request,
             timestamp: nowIso(),
         });
     }
+    fallbackTrackedTurnForServerRequest(params) {
+        if (this.activeTurn) {
+            return null;
+        }
+        const threadId = getNotificationThreadId(params);
+        const turnId = getNotificationTurnId(params);
+        if (!threadId || !turnId) {
+            return null;
+        }
+        return {
+            threadId,
+            turnId,
+            origin: this.bridgeOwnedTurnIds.has(turnId) ? "wechat" : "local",
+        };
+    }
+    handleTrackedTurnUserInputRequest(requestId, params, trackedTurn) {
+        const request = buildCodexUserInputRequest(params);
+        if (!request) {
+            this.sendRpcMessage({
+                id: requestId,
+                error: {
+                    code: -32602,
+                    message: "Invalid Codex user input request payload.",
+                },
+            });
+            return;
+        }
+        this.pendingUserInputRequest = {
+            requestId,
+            method: "item/tool/requestUserInput",
+            threadId: trackedTurn.threadId,
+            turnId: trackedTurn.turnId,
+            origin: trackedTurn.origin,
+        };
+        this.state.pendingUserInput = request;
+        this.state.pendingUserInputOrigin = trackedTurn.origin;
+        this.state.lastOutputAt = nowIso();
+        this.setStatus("awaiting_input", "Codex is waiting for user input.");
+        this.emit({
+            type: "user_input_required",
+            request,
+            timestamp: nowIso(),
+        });
+    }
     handleThreadStatusChanged(params) {
         const threadId = extractCodexThreadFollowIdFromStatusChanged(params);
         if (!threadId) {
@@ -1935,6 +2135,10 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             this.pendingApprovalRequest.turnId === trackedTurn.turnId) {
             this.clearPendingApprovalState();
         }
+        if (this.pendingUserInputRequest &&
+            this.pendingUserInputRequest.turnId === trackedTurn.turnId) {
+            this.clearPendingUserInputState();
+        }
         if (this.activeTurn?.turnId === trackedTurn.turnId) {
             this.setActiveTurn(null);
         }
@@ -2023,6 +2227,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             this.pendingTurnStart ||
             this.pendingApproval ||
             this.pendingApprovalRequest ||
+            this.pendingUserInputRequest ||
+            this.state.pendingUserInput ||
             !this.collectTurnOutput(turnId)) {
             return;
         }
@@ -2039,6 +2245,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         const finalText = this.collectTurnOutput(turnId);
         const lastActivityAtMs = this.turnLastActivityAtMs.get(turnId) ?? null;
         const pendingApproval = Boolean(this.pendingApproval || this.pendingApprovalRequest);
+        const pendingUserInput = Boolean(this.pendingUserInputRequest || this.state.pendingUserInput);
         const nowMs = Date.now();
         if (!shouldAutoCompleteCodexWechatTurnAfterFinalReply({
             candidateTurnId: turnId,
@@ -2046,6 +2253,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             activeTurnOrigin: activeTurn?.origin,
             pendingTurnStart: this.pendingTurnStart,
             hasPendingApproval: pendingApproval,
+            hasPendingUserInput: pendingUserInput,
             hasFinalOutput: Boolean(finalText),
             hasCompletedTurn: this.hasCompletedTurn(turnId),
             lastActivityAtMs,
@@ -2056,6 +2264,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 activeTurn.origin === "wechat" &&
                 !this.pendingTurnStart &&
                 !pendingApproval &&
+                !pendingUserInput &&
                 finalText &&
                 typeof lastActivityAtMs === "number") {
                 const remainingMs = CODEX_FINAL_REPLY_SETTLE_DELAY_MS - (nowMs - lastActivityAtMs);
@@ -2073,6 +2282,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             return;
         }
         this.clearPendingApprovalState();
+        this.clearPendingUserInputState();
         this.setActiveTurn(null);
         this.cleanupTurnArtifacts(turnId);
         this.state.lastOutputAt = nowIso();

package/dist/bridge/bridge-adapters.core.js

@@ -47,7 +47,10 @@ export class LocalCompanionProxyAdapter {
         this.shuttingDown = false;
         this.expectedCloseReason = null;
         this.clearReconnectShutdownTimer();
-        this.setStatus("starting", `Waiting for manual ${this.options.kind} companion connection. Run "${getLocalCompanionCommandName(this.options.kind)}" in a second terminal for this directory.`);
+        this.setStatus("starting", formatLocalCompanionStartupMessage({
+            kind: this.options.kind,
+            launchMode: this.options.companionLaunchMode,
+        }));
         await new Promise((resolve, reject) => {
             const server = net.createServer((socket) => {
                 this.handlePanelSocket(socket);
@@ -133,7 +136,9 @@ export class LocalCompanionProxyAdapter {
         this.expectedCloseReason = null;
         this.clearReconnectShutdownTimer();
         this.rejectPendingRequests(`${this.options.kind} companion proxy is shutting down.`);
-        clearLocalCompanionEndpoint(this.options.cwd, this.endpoint?.instanceId);
+        clearLocalCompanionEndpoint(this.options.cwd, this.endpoint?.instanceId, {
+            adapter: this.options.kind,
+        });
         if (this.socket) {
             try {
                 sendLocalCompanionMessage(this.socket, {
@@ -185,10 +190,15 @@ export class LocalCompanionProxyAdapter {
                 this.expectedCloseReason = null;
                 this.socket = socket;
                 this.detachMessageListener = detachListener;
+                const companionConnectedAt = nowIso();
+                if (this.endpoint) {
+                    this.endpoint.companionPid = message.companionPid;
+                    this.endpoint.companionConnectedAt = companionConnectedAt;
+                }
                 updateLocalCompanionOccupancy(this.options.cwd, {
                     companionPid: message.companionPid,
-                    companionConnectedAt: nowIso(),
-                }, this.endpoint?.instanceId);
+                    companionConnectedAt,
+                }, this.endpoint?.instanceId, { adapter: this.options.kind });
                 sendLocalCompanionMessage(socket, { type: "hello_ack" });
                 return;
             }
@@ -198,7 +208,9 @@ export class LocalCompanionProxyAdapter {
             if (this.socket === socket) {
                 const expectedCloseReason = this.expectedCloseReason;
                 this.expectedCloseReason = null;
-                clearLocalCompanionOccupancy(this.options.cwd, this.endpoint?.instanceId);
+                clearLocalCompanionOccupancy(this.options.cwd, this.endpoint?.instanceId, {
+                    adapter: this.options.kind,
+                });
                 this.detachPanelSocket();
                 if (!this.shuttingDown) {
                     this.handleCompanionDisconnect(expectedCloseReason);
@@ -296,6 +308,7 @@ export class LocalCompanionProxyAdapter {
             lifecycle: this.options.lifecycle,
             expectedClose: isExpectedLocalCompanionClose(expectedCloseReason),
             reconnectGraceMs: LOCAL_COMPANION_RECONNECT_GRACE_MS,
+            launchMode: this.options.companionLaunchMode,
         });
         if (disposition.action === "shutdown") {
             this.clearReconnectShutdownTimer();
@@ -362,7 +375,10 @@ export class LocalCompanionProxyAdapter {
     async sendRequest(payload) {
         const socket = this.socket;
         if (!socket) {
-            throw new Error(`${this.options.kind} companion is not connected. Run "${getLocalCompanionCommandName(this.options.kind)}" in a second terminal for this directory.`);
+            throw new Error(formatCompanionNotConnectedMessage({
+                kind: this.options.kind,
+                launchMode: this.options.companionLaunchMode,
+            }));
         }
         if (!this.state.pid && payload.command !== "dispose") {
             throw new Error(`${this.options.kind} companion is connected but not ready yet. Wait for it to finish starting.`);
@@ -389,6 +405,18 @@ export function buildCompanionHealthPatch(state, timestamp) {
         companionWorkerPid: state.pid,
     };
 }
+export function formatLocalCompanionStartupMessage(params) {
+    if (params.launchMode === "daemon_auto") {
+        return `Waiting for daemon-managed ${params.kind} companion connection. The daemon will open or reuse the visible CLI automatically.`;
+    }
+    return `Waiting for manual ${params.kind} companion connection. Run "${getLocalCompanionCommandName(params.kind)}" in a second terminal for this directory.`;
+}
+export function formatCompanionNotConnectedMessage(params) {
+    if (params.launchMode === "daemon_auto") {
+        return `${params.kind} companion is not connected yet. Send /${params.kind} in WeChat to open or reconnect the visible CLI automatically.`;
+    }
+    return `${params.kind} companion is not connected. Run "${getLocalCompanionCommandName(params.kind)}" in a second terminal for this directory.`;
+}
 export function isExpectedLocalCompanionClose(reason) {
     return typeof reason === "string" && reason.length > 0;
 }
@@ -411,11 +439,23 @@ export function getCompanionDisconnectDisposition(params) {
         };
     }
     if (params.expectedClose) {
+        if (params.launchMode === "daemon_auto") {
+            return {
+                action: "await_manual_reconnect",
+                message: `${params.kind} companion closed. Send /${params.kind} in WeChat to reopen the visible CLI automatically.`,
+            };
+        }
         return {
             action: "await_manual_reconnect",
             message: `${params.kind} companion closed. Run "${commandName}" again in a second terminal for this directory.`,
         };
     }
+    if (params.launchMode === "daemon_auto") {
+        return {
+            action: "await_manual_reconnect",
+            message: `${params.kind} companion disconnected unexpectedly. Send /${params.kind} in WeChat to reopen the visible CLI automatically.`,
+        };
+    }
     return {
         action: "await_manual_reconnect",
         message: `${params.kind} companion disconnected unexpectedly. Run "${commandName}" again in a second terminal for this directory to reconnect.`,