@unlinearity/cli-wechat-bridge 1.2.1 → 1.2.3

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

@@ -5,9 +5,13 @@
 // 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 net from "node:net";
+import os from "node:os";
 import path from "node:path";
 import crypto from "node:crypto";
 import { spawn as spawnChild, spawnSync } from "node:child_process";
+import { WebSocket as WsPackageWebSocket } from "ws";
 import { detectCliApproval, } from "./bridge-utils.js";
 import { normalizeOutput, nowIso, summarizeOutput, truncatePreview, } from "../core/text-utils.js";
 import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
@@ -29,7 +33,87 @@ export function isCodexVersionInCompatibilityRange(version) {
     }
     const major = parts[0] ?? -1;
     const minor = parts[1] ?? -1;
-    return major === 0 && minor >= 149 && minor <= 157;
+    return major === 0 && minor >= 149 && minor <= 161;
+}
+/** Resolve the shared Codex app-server daemon control socket path. */
+export function resolveCodexDaemonControlSocketPath(codexHomeEnv = process.env.CODEX_HOME) {
+    const codexHome = codexHomeEnv && codexHomeEnv.trim()
+        ? codexHomeEnv
+        : path.join(os.homedir(), ".codex");
+    return path.join(codexHome, "app-server-control", "app-server-control.sock");
+}
+/**
+ * Pick attachable threads from a `thread/list` response: only threads that are
+ * live in the shared daemon (`status.type !== "notLoaded"`), belong to the
+ * requested cwd, are root threads, accept direct input, and were not started
+ * by a bridge (`originator === "wechat-bridge"`). Newest activity wins.
+ */
+export function selectCodexDaemonAttachCandidates(response, cwd) {
+    if (!isRecord(response) || !Array.isArray(response.data)) {
+        return [];
+    }
+    const candidates = [];
+    for (const entry of response.data) {
+        if (!isRecord(entry))
+            continue;
+        const id = typeof entry.id === "string" ? entry.id : null;
+        if (!id)
+            continue;
+        const threadCwd = typeof entry.cwd === "string" ? entry.cwd : null;
+        if (!threadCwd || normalizeComparablePath(threadCwd) !== normalizeComparablePath(cwd)) {
+            continue;
+        }
+        if (entry.parentThreadId !== null && entry.parentThreadId !== undefined)
+            continue;
+        if (entry.canAcceptDirectInput === false)
+            continue;
+        const status = isRecord(entry.status) ? entry.status.type : undefined;
+        if (typeof status !== "string" || status === "notLoaded")
+            continue;
+        const originator = typeof entry.originator === "string" ? entry.originator : null;
+        if (originator === "wechat-bridge")
+            continue;
+        const updatedAt = typeof entry.updatedAt === "number"
+            ? entry.updatedAt
+            : typeof entry.lastUpdatedAt === "number"
+                ? entry.lastUpdatedAt
+                : 0;
+        candidates.push({ id, updatedAt, originator });
+    }
+    return candidates.sort((left, right) => right.updatedAt - left.updatedAt);
+}
+/**
+ * Resume params for the bridge's app-server client. In daemon-attach mode the
+ * thread already has an owner with its own settings; sending cwd/approval/
+ * sandbox overrides would rewrite the shared thread's settings
+ * (`thread/settings/updated`), so attach mode resumes without overrides.
+ */
+export function buildCodexThreadResumeParams(params) {
+    if (params.attachDaemon) {
+        return { threadId: params.threadId, excludeTurns: true };
+    }
+    return {
+        threadId: params.threadId,
+        cwd: params.cwd,
+        approvalPolicy: "on-request",
+        approvalsReviewer: "user",
+        sandbox: "workspace-write",
+        excludeTurns: true,
+    };
+}
+/** Turn params; daemon-attach mode inherits the thread's existing settings. */
+export function buildCodexTurnStartParams(params) {
+    const input = [{ type: "text", text: params.text }];
+    if (params.attachDaemon) {
+        return { threadId: params.threadId, input };
+    }
+    return {
+        threadId: params.threadId,
+        cwd: params.cwd,
+        approvalPolicy: "on-request",
+        approvalsReviewer: "user",
+        input,
+    };
 }
 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;
@@ -95,6 +179,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     rpcRequestCounter = 0;
     pendingRpcRequests = new Map();
     subscribedThreadIds = new Set();
+    backgroundThreadIds = new Set();
     pendingThreadSubscriptions = new Map();
     sharedThreadId = null;
     previousCollaborationMode = null;
@@ -114,6 +199,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;
@@ -145,9 +235,16 @@ 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;
+        if (options.codexAttachDaemon) {
+            // Daemon attach binds an explicit (or discovered) live thread; stale
+            // persisted session ids must not leak into the attach target.
+            this.resumeThreadId = options.codexAttachThreadId?.trim() || null;
+        }
         if (this.resumeThreadId && options.renderMode !== "panel") {
             this.state.sharedSessionId = this.resumeThreadId;
             this.state.sharedThreadId = this.resumeThreadId;
@@ -167,6 +264,10 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 : `outside-supported-range=${this.codexCliVersion}`
             : "unknown-version";
         this.setStatus("starting", `Codex protocol compatibility: ${compatibility}.`);
+        if (this.options.codexAttachDaemon) {
+            await this.startDaemonAttach();
+            return;
+        }
         await this.startAppServer();
         await this.connectRpcClient();
         try {
@@ -236,23 +337,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;
@@ -275,11 +376,59 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!this.isHeadlessRuntimeMode()) {
             throw new Error('WeChat /resume requires the managed "wechat-codex" visible client.');
         }
+        if (this.options.codexAttachDaemon) {
+            await this.resumeDaemonAttachedThread(threadId);
+            return;
+        }
         await this.resumeVisibleSharedThread(threadId);
     }
+    /**
+     * WeChat /resume in daemon-attach mode: rejoin another thread on the shared
+     * daemon. Live threads rejoin in place; cold threads are loaded by the
+     * daemon (the bridge never becomes the rollout writer for an embedded
+     * desktop session — that resume fails with an active-writer error).
+     */
+    async resumeDaemonAttachedThread(threadId) {
+        const trimmedThreadId = threadId.trim();
+        if (!trimmedThreadId) {
+            throw new Error("A thread id is required to resume a Codex thread.");
+        }
+        if (this.pendingApproval) {
+            throw new Error(t("adapter.codex.approvalPending"));
+        }
+        if (this.pendingTurnStart ||
+            this.activeTurn ||
+            this.state.status === "busy" ||
+            this.state.status === "awaiting_approval") {
+            throw new Error(t("adapter.codex.busy"));
+        }
+        const response = await this.sendRpcRequest("thread/resume", buildCodexThreadResumeParams({
+            threadId: trimmedThreadId,
+            cwd: this.options.cwd,
+            attachDaemon: true,
+        }));
+        this.validateCodexResumeThread(response, trimmedThreadId);
+        if (isRecord(response) && isRecord(response.thread) && typeof response.thread.path === "string") {
+            this.sessionFilePath = response.thread.path;
+        }
+        const previousThreadId = this.sharedThreadId;
+        this.subscribedThreadIds.add(trimmedThreadId);
+        this.sessionReadOffset = 0;
+        this.sessionPartialLine = "";
+        this.sessionFinalText = null;
+        this.pendingThreadFollowId = null;
+        this.updateSharedThread(trimmedThreadId, {
+            source: "wechat",
+            reason: "wechat_resume",
+            notify: true,
+        });
+        if (previousThreadId && previousThreadId !== trimmedThreadId) {
+            await this.unsubscribeCodexThreadBestEffort(previousThreadId);
+        }
+    }
     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 : [];
@@ -303,14 +452,14 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         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) {
@@ -318,7 +467,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;
@@ -344,7 +493,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() {
@@ -362,35 +511,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) {
@@ -410,7 +562,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() {
@@ -499,11 +651,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({
@@ -550,6 +704,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     }
     isCodexClientRunning() {
         if (this.isHeadlessRuntimeMode()) {
+            if (this.options.codexAttachDaemon) {
+                return Boolean(this.rpcSocket);
+            }
             return Boolean(this.appServer);
         }
         return this.isNativePanelMode() ? Boolean(this.nativeProcess) : Boolean(this.pty);
@@ -1037,22 +1194,22 @@ 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;
@@ -1068,18 +1225,12 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.state.activeTurnOrigin = "wechat";
         this.setStatus("busy");
         try {
-            const response = await this.sendRpcRequest("turn/start", {
+            const response = await this.sendRpcRequest("turn/start", buildCodexTurnStartParams({
                 threadId,
+                text,
                 cwd: this.options.cwd,
-                approvalPolicy: "on-request",
-                approvalsReviewer: "user",
-                input: [
-                    {
-                        type: "text",
-                        text,
-                    },
-                ],
-            });
+                attachDaemon: Boolean(this.options.codexAttachDaemon),
+            }));
             const turnId = this.extractTurnIdFromResponse(response);
             if (!turnId) {
                 throw new Error("Codex did not return a turn id for the requested turn.");
@@ -1133,6 +1284,178 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.armInterruptFallback();
         return true;
     }
+    /**
+     * Daemon-attach mode: instead of spawning an owned app-server, join the
+     * shared Codex app-server daemon (codex >= 0.162) as an additional client
+     * and rebind the bridge to a live thread in this workspace. The daemon and
+     * the owning TUI keep their lifecycle; the bridge is a guest connection.
+     */
+    async startDaemonAttach() {
+        this.setStatus("starting", "Attaching to the shared Codex app-server daemon...");
+        await this.connectDaemonRpcClient();
+        try {
+            await this.attachDaemonThread();
+        }
+        catch (error) {
+            await this.disconnectRpcClient();
+            throw error;
+        }
+        this.shuttingDown = false;
+        this.cleanPanelExitInProgress = false;
+        this.hasAcceptedInput = true;
+        this.state.startedAt = nowIso();
+        this.state.pendingApproval = null;
+        this.afterStart();
+        this.setStatus("idle", "Attached to the live Codex daemon session.");
+    }
+    async connectDaemonRpcClient() {
+        if (this.rpcSocket) {
+            return;
+        }
+        const socket = await this.openDaemonRpcSocket();
+        this.attachRpcSocket(socket);
+        await this.initializeRpcClient();
+    }
+    async openDaemonRpcSocket() {
+        const socketPath = resolveCodexDaemonControlSocketPath();
+        if (!fs.existsSync(socketPath)) {
+            throw new Error(`No shared Codex app-server daemon socket at ${socketPath}. Attach mode requires Codex >= 0.162 with its shared background server (the default). Sessions started with --no-daemon, --oss, or a --profile, and desktop-app embedded sessions, cannot be attached.`);
+        }
+        return await new Promise((resolve, reject) => {
+            // ws 8.22 ignores the `agent` option and installs its own TCP
+            // createConnection; passing createConnection at the top level is
+            // forwarded to http.request and takes precedence, which is how the
+            // Unix control socket is dialed.
+            const socket = new WsPackageWebSocket("ws://localhost/", {
+                createConnection: () => net.connect(socketPath),
+            });
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                try {
+                    socket.close();
+                }
+                catch {
+                    // Best effort cleanup after timeout.
+                }
+                reject(new Error(`Timed out connecting to the Codex daemon socket ${socketPath}.`));
+            }, CODEX_APP_SERVER_READY_TIMEOUT_MS);
+            const cleanup = () => {
+                clearTimeout(timer);
+            };
+            socket.once("open", () => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanup();
+                resolve(socket);
+            });
+            socket.once("error", (error) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanup();
+                reject(new Error(`Failed to connect to the Codex daemon socket ${socketPath}: ${String(error)}`));
+            });
+        });
+    }
+    /**
+     * Bind the bridge to a live daemon thread. An explicit thread id wins;
+     * otherwise the newest live interactive thread in the workspace cwd is
+     * selected. `thread/resume` on a running thread rejoins it (history plus a
+     * live subscription) without taking the rollout writer lock, which stays
+     * with the owning client.
+     */
+    async attachDaemonThread() {
+        const targetThreadId = this.resumeThreadId ?? await this.discoverDaemonAttachThreadId();
+        this.setStatus("starting", `Attaching Codex daemon thread ${targetThreadId.slice(0, 12)}...`);
+        const response = await this.sendRpcRequest("thread/resume", buildCodexThreadResumeParams({
+            threadId: targetThreadId,
+            cwd: this.options.cwd,
+            attachDaemon: true,
+        }));
+        const resumedThreadId = this.extractThreadIdFromResponse(response);
+        if (!resumedThreadId) {
+            throw new Error("Codex daemon did not confirm the attached thread id.");
+        }
+        if (resumedThreadId !== targetThreadId) {
+            throw new Error(`Codex daemon opened ${resumedThreadId}, expected ${targetThreadId}.`);
+        }
+        this.validateCodexThreadWorkspaceIfPresent(response, resumedThreadId);
+        if (isRecord(response) && isRecord(response.thread) && typeof response.thread.path === "string") {
+            this.sessionFilePath = response.thread.path;
+        }
+        this.subscribedThreadIds.add(resumedThreadId);
+        this.resumeThreadId = null;
+        this.updateSharedThread(resumedThreadId, {
+            source: "restore",
+            reason: "startup_restore",
+            notify: true,
+        });
+    }
+    async discoverDaemonAttachThreadId() {
+        const response = await this.sendRpcRequest("thread/list", {
+            limit: 50,
+            sortKey: "updated_at",
+            sortDirection: "desc",
+            sourceKinds: ["cli", "vscode"],
+            archived: false,
+            cwd: this.options.cwd,
+        });
+        const candidates = selectCodexDaemonAttachCandidates(response, this.options.cwd);
+        if (candidates.length === 0) {
+            throw new Error(`No live Codex daemon session found for ${this.options.cwd}. Open codex (>= 0.162, default shared-server mode) in this directory, then retry. Embedded sessions (desktop app, --no-daemon, --oss, --profile) cannot be attached.`);
+        }
+        if (candidates.length > 1) {
+            const listed = candidates
+                .slice(0, 5)
+                .map((candidate) => candidate.id.slice(0, 8))
+                .join(", ");
+            this.setStatus("starting", `Multiple live Codex daemon sessions for ${this.options.cwd}; attaching the newest (${listed}).`);
+        }
+        return candidates[0].id;
+    }
+    /** Reconnect after the daemon socket dropped unexpectedly. */
+    async reconnectDaemonRpcClient() {
+        const reconnectDeadline = Date.now() + CODEX_RPC_RECONNECT_TIMEOUT_MS;
+        let lastError = "Codex daemon connection closed.";
+        while (!this.shuttingDown &&
+            !this.cleanPanelExitInProgress &&
+            Date.now() < reconnectDeadline) {
+            try {
+                await this.connectDaemonRpcClient();
+                // The daemon may have restarted; rejoin the bound thread. Cold threads
+                // are reloaded from disk, so this also recovers after daemon restarts.
+                if (this.state.sharedThreadId) {
+                    await this.ensureSharedThreadSubscribed(this.state.sharedThreadId);
+                }
+                return true;
+            }
+            catch (error) {
+                lastError = describeUnknownError(error);
+                await delay(CODEX_RPC_CONNECT_RETRY_MS);
+            }
+        }
+        if (shouldSuppressCodexTransportFatalError({
+            transportShuttingDown: this.rpcShuttingDown,
+            shuttingDown: this.shuttingDown,
+            cleanPanelExitInProgress: this.cleanPanelExitInProgress,
+        })) {
+            return false;
+        }
+        this.emit({
+            type: "fatal_error",
+            message: `Lost the connection to the shared Codex app-server daemon (${this.lastRpcCloseDetail || lastError}). The attached session may have closed; restart the attach bridge.`,
+            timestamp: nowIso(),
+        });
+        this.terminateCodexClient();
+        return false;
+    }
     async startAppServer() {
         if (this.appServer) {
             return;
@@ -1362,6 +1685,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.");
@@ -1383,6 +1707,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             })) {
                 return false;
             }
+            if (this.options.codexAttachDaemon) {
+                return await this.reconnectDaemonRpcClient();
+            }
             if (!this.appServer || !this.appServerPort) {
                 if (shouldSuppressCodexTransportFatalError({
                     transportShuttingDown: this.appServerShuttingDown,
@@ -1524,14 +1851,11 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (this.subscribedThreadIds.has(threadId)) {
             return;
         }
-        const response = await this.sendRpcRequest("thread/resume", {
+        const response = await this.sendRpcRequest("thread/resume", buildCodexThreadResumeParams({
             threadId,
             cwd: this.options.cwd,
-            approvalPolicy: "on-request",
-            approvalsReviewer: "user",
-            sandbox: "workspace-write",
-            excludeTurns: true,
-        });
+            attachDaemon: Boolean(this.options.codexAttachDaemon),
+        }));
         const resumedThreadId = this.extractThreadIdFromResponse(response);
         if (!resumedThreadId) {
             throw new Error("Codex did not return a thread id while subscribing the bridge client.");
@@ -1624,20 +1948,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}.`);
@@ -1722,14 +2046,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,
@@ -1820,7 +2144,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);
@@ -2079,6 +2403,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
     }
     trackLocalSharedThread(threadId, options) {
+        if (this.backgroundThreadIds.has(threadId)) {
+            return;
+        }
         const weakSignal = options.signal === "status_changed" ||
             options.signal === "thread_started" ||
             options.signal === "session_fallback";
@@ -2200,10 +2527,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) {
@@ -2344,6 +2694,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;
@@ -2386,6 +2748,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!threadId || !turnId) {
             return null;
         }
+        if (this.backgroundThreadIds.has(threadId)) {
+            return null;
+        }
         if (this.hasCompletedTurn(turnId)) {
             return null;
         }
@@ -2470,16 +2835,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 &&
@@ -2553,9 +2908,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: {
@@ -2582,7 +2942,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);
@@ -2592,7 +2952,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);
@@ -2606,24 +2966,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) {
@@ -2631,7 +2987,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 {
@@ -2663,7 +3019,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,
@@ -2690,11 +3046,83 @@ 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.rememberBackgroundThread(params.thread) || this.backgroundThreadIds.has(threadId)) {
+            return;
+        }
         if (this.pendingVisibleResume || this.visibleThreadProxy) {
             return;
         }
@@ -2742,6 +3170,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) &&
@@ -2774,6 +3205,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!threadId) {
             return;
         }
+        if (this.rememberBackgroundThread(params.thread) || this.backgroundThreadIds.has(threadId)) {
+            return;
+        }
         if (this.visibleThreadProxy || this.isBridgeResumeReplay(threadId)) {
             return;
         }
@@ -2781,13 +3215,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             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 ||
@@ -2876,7 +3306,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 &&
@@ -3055,6 +3485,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         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;