@unlinearity/cli-wechat-bridge 1.2.0 → 1.2.2

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

@@ -5,6 +5,7 @@
 // must be released under AGPL-3.0-or-later with full source code; see
 // LICENSE.txt. Network services built on it must offer source to users.
 import fs from "node:fs";
+import { t } from "../i18n/index.js";
 import path from "node:path";
 import crypto from "node:crypto";
 import { spawn as spawnChild, spawnSync } from "node:child_process";
@@ -12,10 +13,11 @@ import { detectCliApproval, } from "./bridge-utils.js";
 import { normalizeOutput, nowIso, summarizeOutput, truncatePreview, } from "../core/text-utils.js";
 import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
 import { killProcessTreeSync } from "./bridge-process-reaper.js";
+import { CodexVisibleThreadProxy } from "./codex-visible-thread-proxy.js";
 import * as shared from "./bridge-adapters.shared.js";
 import { requestCodexVisibleClientShutdown, requestCodexVisibleThreadSwitch, } from "../companion/codex-visible-client-link.js";
 import { readLocalCompanionEndpoint } from "../companion/local-companion-link.js";
-import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
+import { appendBoundedLog as appendBridgeLog, BRIDGE_LOG_FILE, ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { CODEX_REMOTE_AUTH_TOKEN_ENV, LOCAL_CLIENT_PROTOCOL_VERSION, } from "../runtime/runtime-types.js";
 export function parseCodexCliVersion(output) {
     const match = output.match(/\b(\d+\.\d+\.\d+)\b/);
@@ -28,7 +30,7 @@ export function isCodexVersionInCompatibilityRange(version) {
     }
     const major = parts[0] ?? -1;
     const minor = parts[1] ?? -1;
-    return major === 0 && minor >= 149 && minor <= 155;
+    return major === 0 && minor >= 149 && minor <= 161;
 }
 const { CODEX_APP_SERVER_HOST, 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, 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;
@@ -80,6 +82,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     appServer = null;
     nativeProcess = null;
     appServerPort = null;
+    visibleThreadProxy = null;
+    visibleOutOfWorkspaceThreadId = null;
     appServerShuttingDown = false;
     appServerLog = "";
     appServerAuthToken = null;
@@ -92,6 +96,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     rpcRequestCounter = 0;
     pendingRpcRequests = new Map();
     subscribedThreadIds = new Set();
+    backgroundThreadIds = new Set();
     pendingThreadSubscriptions = new Map();
     sharedThreadId = null;
     previousCollaborationMode = null;
@@ -111,6 +116,11 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     bridgeResumeReplayThreadId = null;
     bridgeResumeReplayUntilMs = 0;
     pendingApprovalRequests = [];
+    settledApprovalIds = new Set();
+    discoveringApprovalIds = new Set();
+    approvalGeneration = 0;
+    resolvingApprovalIds = new Set();
+    backgroundThreadParents = new Map();
     pendingUserInputRequest = null;
     pendingUserInputTimer = null;
     userInputAutoResolutionDelayMs = CODEX_NON_BLOCKING_USER_INPUT_TIMEOUT_MS;
@@ -142,6 +152,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     localClientInstanceId = `${process.pid}-${Date.now().toString(36)}`;
     constructor(options) {
         super(options);
+        this.state.supportsApprovalRequestIds = true;
+        this.state.pendingApprovals = [];
         this.resumeThreadId = options.sessionStartMode === "new"
             ? null
             : options.initialSharedSessionId ?? options.initialSharedThreadId ?? null;
@@ -166,8 +178,18 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.setStatus("starting", `Codex protocol compatibility: ${compatibility}.`);
         await this.startAppServer();
         await this.connectRpcClient();
-        await this.restoreInitialSharedThreadIfNeeded();
         try {
+            if (this.isHeadlessRuntimeMode() && this.appServerPort && this.appServerAuthToken) {
+                const trace = (message) => appendBridgeLog(BRIDGE_LOG_FILE, `[${nowIso()}] codex_visible_proxy: ${message}\n`);
+                this.visibleThreadProxy = await CodexVisibleThreadProxy.start({
+                    upstreamUrl: `ws://${CODEX_APP_SERVER_HOST}:${this.appServerPort}`,
+                    token: this.appServerAuthToken,
+                    onTrace: trace,
+                    onThreadOpened: (threadId, cwd) => this.handleVisibleCodexThreadOpened(threadId, cwd, trace),
+                    onVisibleTurn: (threadId) => this.handleVisibleCodexTurn(threadId, trace),
+                });
+            }
+            await this.restoreInitialSharedThreadIfNeeded();
             if (this.isNativePanelMode()) {
                 await this.startNativeClient();
             }
@@ -223,23 +245,23 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             return;
         }
         if (!this.pty) {
-            throw new Error("codex adapter is not running.");
+            throw new Error(t("adapter.codex.notRunning"));
         }
         if (this.state.status === "busy") {
-            throw new Error("codex is still working. Wait for the current reply or use /stop.");
+            throw new Error(t("adapter.codex.busy"));
         }
         if (this.pendingApproval) {
-            throw new Error("A Codex approval request is pending. Reply with /confirm or /deny.");
+            throw new Error(t("adapter.codex.approvalPending"));
         }
         if (this.startupBlocker) {
-            throw new Error("Codex is waiting for local terminal input before the session can continue.");
+            throw new Error(t("adapter.codex.localInputPending"));
         }
         await delay(this.warmupUntilMs - Date.now());
         if (!this.pty) {
-            throw new Error("codex adapter is not running.");
+            throw new Error(t("adapter.codex.notRunning"));
         }
         if (this.startupBlocker) {
-            throw new Error("Codex is waiting for local terminal input before the session can continue.");
+            throw new Error(t("adapter.codex.localInputPending"));
         }
         this.clearInterruptTimer();
         this.hasAcceptedInput = true;
@@ -266,7 +288,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     }
     async listModels() {
         if (!this.usesRpcTurnTransport() || !this.sharedThreadId) {
-            throw new Error("Codex model selection requires an active app-server thread.");
+            throw new Error(t("adapter.codex.modelThreadRequired"));
         }
         const response = await this.sendRpcRequest("model/list", { includeHidden: false });
         const data = isRecord(response) && Array.isArray(response.data) ? response.data : [];
@@ -286,16 +308,18 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         return models;
     }
     async selectModel(modelId) {
+        this.assertVisibleCodexWorkspace();
         const models = await this.listModels();
         const selected = models.find((model) => model.id === modelId);
         if (!selected)
-            throw new Error(`Codex model ${modelId} is not available.`);
+            throw new Error(t("adapter.codex.modelUnavailable", { model: modelId }));
         await this.sendRpcRequest("thread/settings/update", { threadId: this.sharedThreadId, model: selected.id });
         return selected;
     }
     async setPlanMode(enabled) {
+        this.assertVisibleCodexWorkspace();
         if (!this.usesRpcTurnTransport() || !this.sharedThreadId) {
-            throw new Error("Codex plan mode requires an active app-server thread.");
+            throw new Error(t("adapter.codex.planThreadRequired"));
         }
         const settings = await this.readCodexThreadSettings();
         if (enabled) {
@@ -303,7 +327,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             const modes = isRecord(response) && Array.isArray(response.data) ? response.data : [];
             const plan = modes.find((item) => isRecord(item) && (item.mode === "plan" || item.name?.toString().toLowerCase() === "plan"));
             if (!isRecord(plan))
-                throw new Error("Codex plan mode is not available in this app-server.");
+                throw new Error(t("adapter.codex.planUnavailable"));
             this.previousCollaborationMode = isRecord(settings.collaborationMode) ? settings.collaborationMode : null;
             const mode = typeof plan.mode === "string" ? plan.mode : "plan";
             const model = typeof plan.model === "string" ? plan.model : settings.model;
@@ -329,7 +353,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         const response = await this.sendRpcRequest("thread/read", { threadId: this.sharedThreadId, includeTurns: false });
         const thread = isRecord(response) && isRecord(response.thread) ? response.thread : null;
         if (!thread || typeof thread.model !== "string")
-            throw new Error("Codex did not return the current thread model.");
+            throw new Error(t("adapter.codex.modelMissing"));
         return { model: thread.model, effort: thread.reasoningEffort, collaborationMode: thread.collaborationMode };
     }
     async interrupt() {
@@ -347,35 +371,38 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.armInterruptFallback();
         return true;
     }
-    async resolveApproval(action) {
-        if (!this.pendingApproval && this.pendingApprovalRequests.length === 0) {
-            return false;
+    async resolveApproval(action, requestId) {
+        const pending = requestId === undefined
+            ? this.pendingApprovalRequests[0]
+            : this.pendingApprovalRequests.find((request) => this.rpcRequestKey(request.requestId) === requestId);
+        if (!pending) {
+            return this.pendingApprovalRequests.length ? false : await super.resolveApproval(action, requestId);
         }
-        if (this.pendingApprovalRequests.length > 0 && this.rpcSocket) {
-            for (const request of this.pendingApprovalRequests) {
-                await this.respondToApprovalRequest(request, action);
-            }
-            this.clearPendingApprovalState();
-            this.setStatus("busy");
+        const id = this.rpcRequestKey(pending.requestId);
+        if (this.resolvingApprovalIds.has(id))
+            return false;
+        this.resolvingApprovalIds.add(id);
+        try {
+            await this.respondToApprovalRequest(pending, action);
+            this.rememberSettledApproval(pending.requestId);
+            this.pendingApprovalRequests = this.pendingApprovalRequests.filter((request) => request !== pending);
+            this.syncPendingApprovals();
             return true;
         }
-        return await super.resolveApproval(action);
+        finally {
+            this.resolvingApprovalIds.delete(id);
+        }
     }
     async resolveAllApprovals(action) {
-        if (this.pendingApprovalRequests.length === 0 && !this.pendingApproval) {
-            return 0;
+        if (!this.pendingApprovalRequests.length)
+            return await super.resolveAllApprovals(action);
+        let count = 0;
+        const ids = this.pendingApprovalRequests.map((request) => this.rpcRequestKey(request.requestId));
+        for (const id of ids) {
+            if (await this.resolveApproval(action, id))
+                count++;
         }
-        if (this.pendingApprovalRequests.length > 0 && this.rpcSocket) {
-            const count = this.pendingApprovalRequests.length;
-            for (const request of this.pendingApprovalRequests) {
-                await this.respondToApprovalRequest(request, action);
-            }
-            this.clearPendingApprovalState();
-            this.setStatus("busy");
-            return count;
-        }
-        const ok = await super.resolveApproval(action);
-        return ok ? 1 : 0;
+        return count;
     }
     async submitUserInput(answers) {
         if (!this.pendingUserInputRequest) {
@@ -395,7 +422,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             },
         });
         this.clearPendingUserInputState();
-        this.setStatus("busy", "Codex user input submitted.");
+        this.setStatus(this.pendingApprovalRequests.length ? "awaiting_approval" : "busy", "Codex user input submitted.");
         return true;
     }
     async dispose() {
@@ -464,7 +491,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             renderMode: "headless",
             bridgeOwnerPid: process.pid,
             serverPort: this.appServerPort,
-            serverUrl: `ws://${CODEX_APP_SERVER_HOST}:${this.appServerPort}`,
+            serverUrl: this.visibleThreadProxy?.url ?? `ws://${CODEX_APP_SERVER_HOST}:${this.appServerPort}`,
             remoteAuthTokenEnv: CODEX_REMOTE_AUTH_TOKEN_ENV,
             cwd: this.options.cwd,
             command: this.options.command,
@@ -484,11 +511,13 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             return;
         }
         this.state.lastOutputAt = nowIso();
-        const approval = detectCliApproval(text);
+        const detectedApproval = detectCliApproval(text);
+        const approval = detectedApproval ? { ...detectedApproval, requestId: crypto.randomUUID() } : null;
         if (this.hasAcceptedInput) {
             if (approval && !this.pendingApproval) {
                 this.pendingApproval = approval;
                 this.state.pendingApproval = approval;
+                this.state.pendingApprovals = [approval];
                 this.state.pendingApprovalOrigin = this.state.activeTurnOrigin;
                 this.setStatus("awaiting_approval", "Codex approval is required.");
                 this.emit({
@@ -1020,23 +1049,24 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
     }
     async sendPanelTurn(text) {
+        this.assertVisibleCodexWorkspace();
         if (this.isNativePanelMode() && !this.nativeProcess) {
-            throw new Error("codex panel is not running.");
+            throw new Error(t("adapter.codex.panelNotRunning"));
         }
         this.recoverStaleBusyStateIfNeeded();
         this.recoverStaleActiveTurnStateIfNeeded();
         if (this.pendingApproval) {
-            throw new Error("A Codex approval request is pending. Reply with /confirm or /deny.");
+            throw new Error(t("adapter.codex.approvalPending"));
         }
         if (this.pendingUserInputRequest || this.state.pendingUserInput) {
-            throw new Error("Codex is waiting for user input. Reply with /answer and your response, or use /stop.");
+            throw new Error(t("adapter.codex.inputPending"));
         }
         if (this.pendingTurnStart || this.activeTurn || this.state.status === "busy") {
             const origin = this.state.activeTurnOrigin;
             if (origin === "local") {
-                throw new Error("The local Codex panel is still working. Wait for the current reply or use /stop.");
+                throw new Error(t("adapter.codex.localBusy"));
             }
-            throw new Error("codex is still working. Wait for the current reply or use /stop.");
+            throw new Error(t("adapter.codex.busy"));
         }
         this.clearInterruptTimer();
         this.hasAcceptedInput = true;
@@ -1168,6 +1198,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             });
             this.appServer = null;
             this.appServerPort = null;
+            void this.visibleThreadProxy?.close();
+            this.visibleThreadProxy = null;
             this.appServerShuttingDown = false;
             this.deleteAppServerAuthTokenFile();
             this.appServerAuthToken = null;
@@ -1190,6 +1222,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             });
             this.appServer = null;
             this.appServerPort = null;
+            void this.visibleThreadProxy?.close();
+            this.visibleThreadProxy = null;
             this.appServerShuttingDown = false;
             this.deleteAppServerAuthTokenFile();
             this.appServerAuthToken = null;
@@ -1342,6 +1376,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             cleanPanelExitInProgress: this.cleanPanelExitInProgress,
         });
         this.rpcSocket = null;
+        this.clearPendingApprovalState();
         this.lastRpcCloseDetail = `close_code=${code ?? "unknown"}${reason ? ` reason=${truncatePreview(reason, 240)}` : ""}`;
         this.subscribedThreadIds.clear();
         this.rejectPendingRpcRequests("Codex websocket connection closed.");
@@ -1604,20 +1639,20 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             throw new Error("A thread id is required to resume a Codex thread.");
         }
         if (this.pendingVisibleResume) {
-            throw new Error("Codex is already switching visible threads.");
+            throw new Error(t("adapter.codex.switching"));
         }
         if (this.pendingApproval || this.pendingApprovalRequests.length > 0) {
-            throw new Error("A Codex approval request is pending. Reply with /confirm or /deny.");
+            throw new Error(t("adapter.codex.approvalPending"));
         }
         if (this.pendingUserInputRequest || this.state.pendingUserInput) {
-            throw new Error("Codex is waiting for user input. Reply with /answer or use /stop.");
+            throw new Error(t("adapter.codex.inputPendingShort"));
         }
         if (this.pendingTurnStart ||
             this.activeTurn ||
             this.state.status === "busy" ||
             this.state.status === "awaiting_approval" ||
             this.state.status === "awaiting_input") {
-            throw new Error("codex is still working. Wait for the current reply or use /stop.");
+            throw new Error(t("adapter.codex.busy"));
         }
         if (this.state.status !== "idle") {
             throw new Error(`Codex cannot switch threads while its status is ${this.state.status}.`);
@@ -1660,6 +1695,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 reason: "wechat_resume",
                 notify: true,
             });
+            this.clearVisibleCodexWorkspaceBlock();
             this.bridgeResumeReplayThreadId = targetThreadId;
             this.bridgeResumeReplayUntilMs = Date.now() + CODEX_RESUME_REPLAY_SETTLE_MS;
             this.setStatus("starting", `Codex resume committed thread ${targetThreadId.slice(0, 12)}.`);
@@ -1701,14 +1737,14 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             throw new Error("A thread id is required to resume a Codex thread.");
         }
         if (this.pendingApproval) {
-            throw new Error("A Codex approval request is pending. Reply with /confirm or /deny.");
+            throw new Error(t("adapter.codex.approvalPending"));
         }
         if (!options.startup &&
             (this.pendingTurnStart ||
                 this.activeTurn ||
                 this.state.status === "busy" ||
                 this.state.status === "awaiting_approval")) {
-            throw new Error("codex is still working. Wait for the current reply or use /stop.");
+            throw new Error(t("adapter.codex.busy"));
         }
         const response = await this.sendRpcRequest("thread/resume", {
             threadId: trimmedThreadId,
@@ -1799,7 +1835,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             this.setStatus("idle", "Codex task interrupted.");
             this.emit({
                 type: "task_complete",
-                summary: "Interrupted",
+                summary: t("task.interrupted"),
                 timestamp: nowIso(),
             });
         }, INTERRUPT_SETTLE_DELAY_MS);
@@ -1881,6 +1917,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!options.preserveThread) {
             this.clearPendingThreadAnnouncement();
             this.announcedThreadId = null;
+            this.visibleOutOfWorkspaceThreadId = null;
         }
         if (!options.preserveThread) {
             this.updateSharedThread(null);
@@ -2000,14 +2037,73 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }, CODEX_LOCAL_THREAD_ANNOUNCE_SETTLE_MS);
         pending.timer.unref?.();
     }
+    handleVisibleCodexThreadOpened(threadId, cwd, trace) {
+        if (this.pendingVisibleResume || this.shuttingDown) {
+            trace?.(`ignored thread=${threadId.slice(0, 12)} reason=bridge_switch`);
+            return;
+        }
+        if (cwd && normalizeComparablePath(cwd) !== normalizeComparablePath(this.options.cwd)) {
+            trace?.(`paused thread=${threadId.slice(0, 12)} reason=workspace`);
+            this.interruptWechatTurnForLocalThreadSwitch(threadId);
+            this.clearPendingThreadAnnouncement();
+            this.pendingThreadFollowId = null;
+            if (this.visibleOutOfWorkspaceThreadId !== threadId) {
+                this.visibleOutOfWorkspaceThreadId = threadId;
+                this.emit({
+                    type: "notice",
+                    level: "warning",
+                    text: `The visible Codex terminal switched to ${cwd}, outside the bridge workspace ${this.options.cwd}. WeChat input is paused instead of being sent to the previous session. Resume a session from the bridge workspace, or restart the bridge in ${cwd}.`,
+                    timestamp: nowIso(),
+                });
+            }
+            return;
+        }
+        this.clearVisibleCodexWorkspaceBlock();
+        trace?.(`follow thread=${threadId.slice(0, 12)} source=visible_open`);
+        this.trackLocalSharedThread(threadId, { reason: "local_follow", signal: "visible_request" });
+    }
+    handleVisibleCodexTurn(threadId, trace) {
+        if (this.pendingVisibleResume || this.shuttingDown)
+            return;
+        if (threadId === this.sharedThreadId) {
+            this.clearVisibleCodexWorkspaceBlock();
+            return;
+        }
+        if (!findCodexSessionFile(this.options.cwd, Date.now(), { threadId })) {
+            trace?.(`ignored thread=${threadId.slice(0, 12)} reason=workspace_or_unpersisted`);
+            return;
+        }
+        this.clearVisibleCodexWorkspaceBlock();
+        trace?.(`follow thread=${threadId.slice(0, 12)} source=visible_turn`);
+        this.trackLocalSharedThread(threadId, { reason: "local_follow", signal: "visible_request" });
+    }
+    clearVisibleCodexWorkspaceBlock() {
+        if (!this.visibleOutOfWorkspaceThreadId)
+            return;
+        this.visibleOutOfWorkspaceThreadId = null;
+        this.emit({
+            type: "notice",
+            level: "info",
+            text: `The visible Codex terminal is back in the bridge workspace ${this.options.cwd}. WeChat input has resumed.`,
+            timestamp: nowIso(),
+        });
+    }
+    assertVisibleCodexWorkspace() {
+        if (this.visibleOutOfWorkspaceThreadId) {
+            throw new Error(`The visible Codex terminal is outside the bridge workspace ${this.options.cwd}. WeChat input is paused; resume a session from this workspace or restart the bridge in the terminal's workspace.`);
+        }
+    }
     trackLocalSharedThread(threadId, options) {
+        if (this.backgroundThreadIds.has(threadId)) {
+            return;
+        }
         const weakSignal = options.signal === "status_changed" ||
             options.signal === "thread_started" ||
             options.signal === "session_fallback";
         if (weakSignal && Date.now() < this.localThreadFollowBlockedUntilMs) {
             return;
         }
-        if (options.signal === "user_message" || options.signal === "turn_started") {
+        if (options.signal === "user_message" || options.signal === "turn_started" || options.signal === "visible_request") {
             this.localThreadFollowBlockedUntilMs = 0;
         }
         if (this.pendingVisibleResume) {
@@ -2122,10 +2218,33 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.bridgeResumeReplayUntilMs = 0;
     }
     clearPendingApprovalState() {
+        this.approvalGeneration++;
+        const hadPending = this.pendingApprovalRequests.length > 0;
+        for (const pending of this.pendingApprovalRequests)
+            this.rememberSettledApproval(pending.requestId);
         this.pendingApprovalRequests = [];
+        this.state.pendingApprovals = [];
         this.pendingApproval = null;
         this.state.pendingApproval = null;
         this.state.pendingApprovalOrigin = undefined;
+        if (hadPending)
+            this.emit({ type: "approval_state_changed", requests: [], timestamp: nowIso() });
+    }
+    syncPendingApprovals() {
+        const previousId = this.pendingApproval?.requestId;
+        const requests = this.pendingApprovalRequests.flatMap((pending) => {
+            const request = buildCodexApprovalRequest(pending.method, pending.params);
+            return request ? [{ ...request, requestId: this.rpcRequestKey(pending.requestId) }] : [];
+        });
+        this.pendingApproval = requests[0] ?? null;
+        this.state.pendingApproval = this.pendingApproval;
+        this.state.pendingApprovals = requests;
+        this.state.pendingApprovalOrigin = this.pendingApprovalRequests[0]?.origin;
+        this.setStatus(requests.length ? "awaiting_approval" : this.state.pendingUserInput ? "awaiting_input" : "busy");
+        this.emit({ type: "approval_state_changed", requests, timestamp: nowIso() });
+        if (requests[0] && requests[0].requestId !== previousId) {
+            this.emit({ type: "approval_required", request: requests[0], timestamp: nowIso() });
+        }
     }
     clearPendingUserInputState() {
         if (this.pendingUserInputTimer) {
@@ -2266,6 +2385,18 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!isRecord(params)) {
             return;
         }
+        if (method === "serverRequest/resolved") {
+            const requestId = getCodexRpcRequestId(params.requestId);
+            if (requestId !== null)
+                this.rememberSettledApproval(requestId);
+            const pending = this.pendingApprovalRequests.find((request) => request.requestId === requestId
+                && (!getNotificationThreadId(params) || request.threadId === getNotificationThreadId(params))
+                && (!getNotificationTurnId(params) || request.turnId === getNotificationTurnId(params)));
+            if (pending) {
+                this.pendingApprovalRequests = this.pendingApprovalRequests.filter((request) => request !== pending);
+                this.syncPendingApprovals();
+            }
+        }
         if (method === "thread/started") {
             this.handleThreadStarted(params);
             return;
@@ -2308,6 +2439,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!threadId || !turnId) {
             return null;
         }
+        if (this.backgroundThreadIds.has(threadId)) {
+            return null;
+        }
         if (this.hasCompletedTurn(turnId)) {
             return null;
         }
@@ -2343,7 +2477,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 origin: "local",
             };
         }
-        if (method === "turn/started" && !this.activeTurn) {
+        if (method === "turn/started" && !this.activeTurn && !this.visibleThreadProxy) {
             return {
                 threadId,
                 turnId,
@@ -2392,16 +2526,6 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             }
             case "serverRequest/resolved": {
                 const requestId = getCodexRpcRequestId(params.requestId);
-                if (requestId !== null &&
-                    this.pendingApprovalRequests.some((r) => r.requestId === requestId && r.turnId === trackedTurn.turnId)) {
-                    this.pendingApprovalRequests = this.pendingApprovalRequests.filter((r) => r.requestId !== requestId);
-                    if (this.pendingApprovalRequests.length === 0) {
-                        this.clearPendingApprovalState();
-                    }
-                    if (this.state.status === "awaiting_approval") {
-                        this.setStatus("busy", "Codex approval resolved.");
-                    }
-                }
                 if (requestId !== null &&
                     this.pendingUserInputRequest &&
                     requestId === this.pendingUserInputRequest.requestId &&
@@ -2475,9 +2599,14 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             });
             return;
         }
-        const trackedTurn = this.identifyTrackedTurn("server/request", params) ??
+        const trackedTurn = (method !== "item/tool/requestUserInput" ? this.approvalOwnerForBackgroundThread(params) : null) ??
+            this.identifyTrackedTurn("server/request", params) ??
             this.fallbackTrackedTurnForServerRequest(params);
         if (!trackedTurn) {
+            if (method !== "item/tool/requestUserInput" && this.activeTurn && this.rpcSocket) {
+                this.discoverBackgroundApprovalOwner(requestId, method, params);
+                return;
+            }
             this.sendRpcMessage({
                 id: requestId,
                 error: {
@@ -2504,7 +2633,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                     : { decision: "decline" },
             });
             this.state.lastOutputAt = nowIso();
-            this.setStatus("busy", `Codex approval auto-denied: ${truncatePreview(denyMessage, 180)}`);
+            this.setStatus(this.pendingApprovalRequests.length ? "awaiting_approval" : "busy", `Codex approval auto-denied: ${truncatePreview(denyMessage, 180)}`);
             return;
         }
         const autoResponse = getCodexApprovalAutoResponse(method, params);
@@ -2514,7 +2643,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 result: autoResponse.result,
             });
             this.state.lastOutputAt = nowIso();
-            this.setStatus("busy", `Codex approval auto-approved: ${truncatePreview(autoResponse.reason, 180)}`);
+            this.setStatus(this.pendingApprovalRequests.length ? "awaiting_approval" : "busy", `Codex approval auto-approved: ${truncatePreview(autoResponse.reason, 180)}`);
             return;
         }
         const request = buildCodexApprovalRequest(method, params);
@@ -2528,24 +2657,20 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             });
             return;
         }
+        if (this.pendingApprovalRequests.some((pending) => pending.requestId === requestId)
+            || this.settledApprovalIds.has(this.rpcRequestKey(requestId)))
+            return;
         this.pendingApprovalRequests.push({
+            ownerTurnId: trackedTurn.turnId,
             requestId,
             method,
-            threadId: trackedTurn.threadId,
-            turnId: trackedTurn.turnId,
+            threadId: getNotificationThreadId(params) ?? trackedTurn.threadId,
+            turnId: getNotificationTurnId(params) ?? 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: ${truncatePreview(request.commandPreview, 180)}`);
-        this.emit({
-            type: "approval_required",
-            request,
-            timestamp: nowIso(),
-        });
+        this.syncPendingApprovals();
     }
     fallbackTrackedTurnForServerRequest(params) {
         if (this.activeTurn) {
@@ -2553,7 +2678,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         const threadId = getNotificationThreadId(params);
         const turnId = getNotificationTurnId(params);
-        if (!threadId || !turnId) {
+        if (!threadId || !turnId || this.backgroundThreadIds.has(threadId)) {
             return null;
         }
         return {
@@ -2585,7 +2710,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.state.pendingUserInput = request;
         this.state.pendingUserInputOrigin = trackedTurn.origin;
         this.state.lastOutputAt = nowIso();
-        this.setStatus("awaiting_input", "Codex is waiting for user input.");
+        this.setStatus(this.pendingApprovalRequests.length ? "awaiting_approval" : "awaiting_input", "Codex is waiting for user input.");
         this.emit({
             type: "user_input_required",
             request,
@@ -2612,12 +2737,84 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }, this.userInputAutoResolutionDelayMs);
         this.pendingUserInputTimer.unref?.();
     }
+    rememberSettledApproval(requestId) {
+        this.settledApprovalIds.add(this.rpcRequestKey(requestId));
+        if (this.settledApprovalIds.size > 512)
+            this.settledApprovalIds.delete(this.settledApprovalIds.values().next().value);
+    }
+    discoverBackgroundApprovalOwner(requestId, method, params) {
+        const id = this.rpcRequestKey(requestId);
+        if (this.discoveringApprovalIds.has(id) || this.settledApprovalIds.has(id))
+            return;
+        this.discoveringApprovalIds.add(id);
+        const owner = this.activeTurn;
+        const generation = this.approvalGeneration;
+        void (async () => {
+            let threadId = getNotificationThreadId(params);
+            const seen = new Set();
+            while (threadId && owner && !seen.has(threadId) && seen.size < 32) {
+                if (this.approvalOwnerForBackgroundThread(params))
+                    break;
+                seen.add(threadId);
+                const response = await this.sendRpcRequest("thread/read", { threadId, includeTurns: false });
+                if (!isRecord(response) || !isRecord(response.thread))
+                    break;
+                const thread = response.thread;
+                if (thread.id !== threadId || typeof thread.cwd !== "string"
+                    || normalizeComparablePath(thread.cwd) !== normalizeComparablePath(this.options.cwd)
+                    || typeof thread.parentThreadId !== "string")
+                    break;
+                this.rememberBackgroundThread(thread);
+                threadId = thread.parentThreadId;
+            }
+            if (generation !== this.approvalGeneration || this.activeTurn !== owner || this.settledApprovalIds.has(id))
+                return;
+            const trackedTurn = this.approvalOwnerForBackgroundThread(params);
+            if (!trackedTurn)
+                throw new Error("Codex approval does not belong to the active parent turn.");
+            this.handleTrackedTurnServerRequest(requestId, method, params, trackedTurn);
+        })().catch((error) => {
+            if (generation === this.approvalGeneration && !this.settledApprovalIds.has(id) && this.rpcSocket) {
+                this.sendRpcMessage({ id: requestId, error: { code: -32602, message: describeUnknownError(error) } });
+            }
+        }).finally(() => this.discoveringApprovalIds.delete(id));
+    }
+    approvalOwnerForBackgroundThread(params) {
+        if (!this.activeTurn)
+            return null;
+        let threadId = getNotificationThreadId(params);
+        const seen = new Set();
+        while (threadId && !seen.has(threadId)) {
+            seen.add(threadId);
+            threadId = this.backgroundThreadParents.get(threadId) ?? null;
+            if (threadId === this.activeTurn.threadId)
+                return this.activeTurn;
+        }
+        return null;
+    }
+    rememberBackgroundThread(thread) {
+        if (!isRecord(thread) || typeof thread.id !== "string" ||
+            (typeof thread.parentThreadId !== "string" && thread.ephemeral !== true)) {
+            return false;
+        }
+        // Later notifications may carry only an id. Keep subagent/ephemeral
+        // threads out of local follow and turn ownership for the server lifetime.
+        this.backgroundThreadIds.add(thread.id);
+        if (typeof thread.parentThreadId === "string"
+            && (typeof thread.cwd !== "string" || normalizeComparablePath(thread.cwd) === normalizeComparablePath(this.options.cwd))) {
+            this.backgroundThreadParents.set(thread.id, thread.parentThreadId);
+        }
+        return true;
+    }
     handleThreadStatusChanged(params) {
         const threadId = extractCodexThreadFollowIdFromStatusChanged(params);
         if (!threadId) {
             return;
         }
-        if (this.pendingVisibleResume) {
+        if (this.rememberBackgroundThread(params.thread) || this.backgroundThreadIds.has(threadId)) {
+            return;
+        }
+        if (this.pendingVisibleResume || this.visibleThreadProxy) {
             return;
         }
         if (this.isBridgeResumeReplay(threadId)) {
@@ -2664,6 +2861,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 return;
             }
             const thread = response.thread;
+            if (this.rememberBackgroundThread(thread) || this.backgroundThreadIds.has(threadId)) {
+                return;
+            }
             if (thread.id === threadId &&
                 typeof thread.cwd === "string" &&
                 normalizeComparablePath(thread.cwd) === normalizeComparablePath(this.options.cwd) &&
@@ -2696,20 +2896,19 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!threadId) {
             return;
         }
-        if (this.isBridgeResumeReplay(threadId)) {
+        if (this.rememberBackgroundThread(params.thread) || this.backgroundThreadIds.has(threadId)) {
+            return;
+        }
+        if (this.visibleThreadProxy || this.isBridgeResumeReplay(threadId)) {
             return;
         }
         if (this.isRecentlyBridgeOwnedThread(threadId)) {
             return;
         }
         const thread = isRecord(params.thread) ? params.thread : null;
-        if (thread) {
-            if ((typeof thread.cwd === "string" &&
-                normalizeComparablePath(thread.cwd) !== normalizeComparablePath(this.options.cwd)) ||
-                typeof thread.parentThreadId === "string" ||
-                thread.ephemeral === true) {
-                return;
-            }
+        if (typeof thread?.cwd === "string" &&
+            normalizeComparablePath(thread.cwd) !== normalizeComparablePath(this.options.cwd)) {
+            return;
         }
         if (!this.activeTurn ||
             this.activeTurn.threadId === threadId ||
@@ -2798,7 +2997,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 ? "Local terminal turn completed."
                 : this.currentPreview;
         if (this.pendingApprovalRequests.length > 0 &&
-            this.pendingApprovalRequests.some((r) => r.turnId === trackedTurn.turnId)) {
+            this.pendingApprovalRequests.some((r) => (r.ownerTurnId ?? r.turnId) === trackedTurn.turnId)) {
             this.clearPendingApprovalState();
         }
         if (this.pendingUserInputRequest &&
@@ -2974,6 +3173,12 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.rememberCompletedTurn(turnId);
     }
     async stopAppServer() {
+        const visibleThreadProxy = this.visibleThreadProxy;
+        this.visibleThreadProxy = null;
+        await visibleThreadProxy?.close();
+        this.backgroundThreadIds.clear();
+        this.backgroundThreadParents.clear();
+        this.settledApprovalIds.clear();
         if (!this.appServer) {
             this.appServerPort = null;
             this.appServerShuttingDown = false;