@linkshell/host 0.4.68 → 0.4.70

package/dist/host/src/drivers/codex/driver.d.ts

@@ -1,7 +1,8 @@
 import { type GoalChange, type SessionGoal, type ContentBlock, type QuestionAnswer } from "@linkshell/wire";
 import type { AgentAuth } from "@linkshell/wire";
-import type { AgentDriver, DiscoveredSession, DriverHost, DriverStatus, ForkOptions, HistoryItem, LaunchSpec } from "../types.js";
+import type { AgentDriver, DiscoveredSession, DriverHost, DriverStatus, ForkOptions, HistoryItem, LaunchSpec, SideOutput, SideRequest } from "../types.js";
 import { type DriverBehavior } from "../behavior.js";
+import { CodexMcpApps } from "./mcp-apps.js";
 export interface CodexDriverOptions {
     socketPath: string;
     command?: string;
@@ -56,6 +57,7 @@ export declare class CodexDriver implements AgentDriver {
         images: boolean;
         models: boolean;
         modes: boolean;
+        side: boolean;
     };
     private host?;
     private server?;
@@ -71,7 +73,13 @@ export declare class CodexDriver implements AgentDriver {
     /** Recent tool titles by item, so a file-change approval can name its files. */
     private readonly toolTitles;
     private readonly settings;
+    /** What a device chose for each thread; kept in the host's state so a restart before the next turn doesn't lose it. */
     private readonly overrides;
+    /** Side conversations (`sideAsk`), by `<parent>\n<sideId>`, and their threads. */
+    private readonly sides;
+    private readonly sideThreads;
+    /** Turns that run under the full access a device chose, started with it or chosen while they ran. */
+    private readonly fullAccessTurns;
     /** Sub-agent thread → the parent thread and the spawnAgent call its work nests under. */
     private readonly children;
     /** Threads Codex reported as sub-agents (parentThreadId set); never shown as sessions. */
@@ -114,6 +122,7 @@ export declare class CodexDriver implements AgentDriver {
     private readonly confirmStartMs;
     private readonly sharedSocketPath?;
     private readonly desktopBusPath?;
+    readonly mcpApps: CodexMcpApps;
     constructor(options: CodexDriverOptions);
     status(): DriverStatus;
     start(host: DriverHost): Promise<DriverStatus>;
@@ -225,8 +234,40 @@ export declare class CodexDriver implements AgentDriver {
     private send;
     goal(nativeId: string, change: GoalChange): Promise<SessionGoal | null>;
     private announceGoal;
-    /** Model, reasoning effort and permissions apply from the next turn on. */
+    /** Model, reasoning effort and permissions apply from the next turn on (full access at once, see autoApproval). */
     setConfig(nativeId: string, optionId: string, value: string): Promise<void>;
+    private overridesOf;
+    private setOverrides;
+    /**
+     * With full access chosen, what Codex still asks in the thread (the turn
+     * under way started with the old approvals) is approved here, as it would
+     * not have been asked from the next turn on. Questions still go to the user.
+     */
+    private autoApproval;
+    /**
+     * Codex's `/side`: an ephemeral fork of the thread (never written to disk),
+     * read-only, told where the inherited history ends. Each question is a turn
+     * in it; what it writes goes to `out`, not into the session.
+     */
+    sideAsk(nativeId: string, request: SideRequest, out: SideOutput, signal: AbortSignal): Promise<void>;
+    sideClose(nativeId: string, sideId: string): Promise<void>;
+    private openSide;
+    /** Their server went away, and an ephemeral thread with it: the next question opens a new one. */
+    private loseSides;
+    private sideUpdate;
+    private markFullAccess;
+    private approvePending;
+    /** From the app-server the driver keeps running: its model list (cached) and the configuration a thread started in `cwd` reads. */
+    listModels(cwd?: string): Promise<{
+        models: {
+            value: string;
+            name: string;
+            description?: string;
+        }[];
+        current?: string;
+    }>;
+    /** The model config.toml (with the project's own layers, for `cwd`) gives a new thread; undefined: Codex's default. */
+    private configuredModel;
     private loadModels;
     private announceConfig;
     private isNews;
@@ -256,6 +297,8 @@ export declare class CodexDriver implements AgentDriver {
     /** Remembers which spawnAgent call each new sub-agent thread belongs to. */
     private noteSpawns;
     private onServerRequest;
+    /** A tool call's page, found only once its tool had been looked up: to the card, wherever the call's thread shows. */
+    private lateDetail;
     private rememberTitle;
     private rpc;
     /** A request about a thread, to the server it is loaded in. */

package/dist/host/src/drivers/codex/driver.js

@@ -10,9 +10,10 @@ import { behaviorCapabilities } from "../behavior.js";
 import { CodexAppServer, CodexSharedServer, findCodex, sharedServerSocket } from "./app-server.js";
 import { APPROVAL_METHODS, QUESTION_METHODS, mapApprovalRequest, mapQuestionRequest, mapNotification, threadStateOf, threadToDiscovered, spawnedThreads, subagentHistory, threadToHistory, toCodexInput, toolStart, turnUnderWay, } from "./mapper.js";
 import { nestHistory, nestUnder } from "../nesting.js";
-import { configOptions, effective, settingsFrom, settingsFromTurnContext, turnOverrides } from "./settings.js";
+import { configOptions, effective, newThreadModels, settingsFrom, settingsFromTurnContext, turnOverrides } from "./settings.js";
 import { COMMANDS, INIT_PROMPT, commandOf } from "./commands.js";
 import { DesktopUnconfirmed, desktopBusSocket, interruptThroughDesktop, startThroughDesktop, steerThroughDesktop, updateSettingsThroughDesktop } from "./desktop-ipc.js";
+import { CodexMcpApps } from "./mcp-apps.js";
 /** Codex's refusal to load a thread that another process has loaded. */
 function heldElsewhere(error) {
     return error instanceof Error && /already has an active writer/i.test(error.message);
@@ -88,6 +89,17 @@ const HELD_SEND = "会话开在电脑的另一个 Codex 里，这条消息没能
 const HELD_STOP = "这一轮跑在电脑的 Codex 桌面 App（或 IDE 插件）里，这次没能从手机停下它。请在电脑上停止；一直这样的话，重启一下 Codex 桌面 App。";
 const HELD_NOW = "这一轮跑在电脑的 Codex 桌面 App（或 IDE 插件）里，这次没能从手机插进去。它结束后这条消息会自动发送；想现在就插入，在电脑上对这条排队消息点 Steer。一直这样的话，重启一下 Codex 桌面 App。";
 const HELD_COMMAND = "会话开在电脑的另一个 Codex 里，要在那边关掉它之后才能从手机做。";
+/**
+ * What a side conversation's thread is told, as Codex's own `/side` tells it:
+ * the history it was forked with is for reference, and it changes nothing.
+ */
+const SIDE_INSTRUCTIONS = [
+    "You are in a side conversation forked from the user's main thread, not in the main thread itself.",
+    "The history before the side-conversation boundary is reference only: do not continue, carry out or complete any task, plan, tool call, approval or edit from it. Only messages after the boundary are instructions for you.",
+    "Answer questions and explore without changing anything: you may read and search files and run commands that change nothing, but do not modify files, git state, configuration or the workspace, do not ask for broader permissions, and do not start or talk to sub-agents.",
+    "Keep answers short; the user is reading them on a phone.",
+].join("\n\n");
+const SIDE_BOUNDARY = "Side conversation boundary. Everything before this point is the main thread's history, for reference only. What the user asks from here on is the side conversation.";
 /**
  * Codex, tier multi_client: LinkShell and the desktop TUI (`codex --remote`)
  * are both clients of one app-server, so every thread is live on both sides.
@@ -118,6 +130,7 @@ export class CodexDriver {
         images: true,
         models: true,
         modes: true,
+        side: true,
         ...behaviorCapabilities(this.behavior),
     };
     host;
@@ -134,7 +147,13 @@ export class CodexDriver {
     /** Recent tool titles by item, so a file-change approval can name its files. */
     toolTitles = new Map();
     settings = new Map();
+    /** What a device chose for each thread; kept in the host's state so a restart before the next turn doesn't lose it. */
     overrides = new Map();
+    /** Side conversations (`sideAsk`), by `<parent>\n<sideId>`, and their threads. */
+    sides = new Map();
+    sideThreads = new Map();
+    /** Turns that run under the full access a device chose, started with it or chosen while they ran. */
+    fullAccessTurns = new Set();
     /** Sub-agent thread → the parent thread and the spawnAgent call its work nests under. */
     children = new Map();
     /** Threads Codex reported as sub-agents (parentThreadId set); never shown as sessions. */
@@ -177,6 +196,12 @@ export class CodexDriver {
     confirmStartMs;
     sharedSocketPath;
     desktopBusPath;
+    mcpApps = new CodexMcpApps({
+        request: (method, params, threadId) => (threadId ? this.rpcFor(threadId, method, params) : this.rpc(method, params)),
+        reach: (threadId) => (this.observed.has(threadId) ? "held" : this.attached.has(threadId) ? "joined" : "unloaded"),
+        lateDetail: (threadId, toolCallId, detail) => this.lateDetail(threadId, toolCallId, detail),
+        log: (message) => this.host?.log(message),
+    });
     constructor(options) {
         this.options = options;
         this.restartDelay = options.restartDelayMs ?? 1000;
@@ -217,6 +242,7 @@ export class CodexDriver {
         return parseCodexLoginStatus(await runStatusCommand(this.command, ["login", "status"], this.options.env));
     }
     async stop() {
+        this.mcpApps.stop();
         if (this.attentionTimer)
             clearInterval(this.attentionTimer);
         this.attentionTimer = undefined;
@@ -374,7 +400,7 @@ export class CodexDriver {
                 // Archives remain readable; opening history must not unarchive or resume the agent.
                 const { thread } = await this.rpc("thread/read", { threadId: nativeId, includeTurns: true });
                 this.host?.sessionSeen(this.id, { ...threadToDiscovered(thread), archived: true, state: "idle", asyncQuestions: [] });
-                const history = await this.withSubAgents(nativeId, thread, threadToHistory(thread));
+                const history = await this.withSubAgents(nativeId, thread, threadToHistory(thread, this.mcpApps.lookup(nativeId)));
                 this.host?.update(this.id, nativeId, { sessionUpdate: "ls_status", state: "idle" });
                 return history;
             }
@@ -389,7 +415,7 @@ export class CodexDriver {
             return this.observe(nativeId);
         }
         this.stopObserving(nativeId);
-        const history = await this.withSubAgents(nativeId, joined.thread, threadToHistory(joined.thread));
+        const history = await this.withSubAgents(nativeId, joined.thread, threadToHistory(joined.thread, this.mcpApps.lookup(nativeId)));
         this.goLive(nativeId, joined);
         this.reportHeld(nativeId, false);
         void this.announceConfig(nativeId);
@@ -476,7 +502,7 @@ export class CodexDriver {
         const read = new Set((thread.turns ?? []).flatMap((turn) => turn.items.map((item) => item.id)));
         for (const item of underWay) {
             // A command still running: its card. (Its output so far was missed, so the whole of it comes when it finishes.)
-            const start = read.has(item.id) ? undefined : toolStart(item);
+            const start = read.has(item.id) ? undefined : toolStart(item, this.mcpApps.lookup(threadId));
             if (start)
                 this.host?.update(this.id, threadId, start);
         }
@@ -499,7 +525,7 @@ export class CodexDriver {
     /** Reads the thread from disk, and keeps reading while a device has it open. */
     async observe(threadId) {
         const { thread } = await this.rpc("thread/read", { threadId, includeTurns: true });
-        const history = await this.withSubAgents(threadId, thread, threadToHistory(thread));
+        const history = await this.withSubAgents(threadId, thread, threadToHistory(thread, this.mcpApps.lookup(threadId)));
         this.stopObserving(threadId);
         const timer = setInterval(() => void this.refresh(threadId), this.observeIntervalMs);
         timer.unref?.();
@@ -548,7 +574,7 @@ export class CodexDriver {
         watch.reading = true;
         try {
             const { thread } = await this.rpc("thread/read", { threadId, includeTurns: true });
-            const history = await this.withSubAgents(threadId, thread, threadToHistory(thread));
+            const history = await this.withSubAgents(threadId, thread, threadToHistory(thread, this.mcpApps.lookup(threadId)));
             // Joined, or let go, while it was being read.
             if (this.observed.get(threadId) !== watch)
                 return;
@@ -642,7 +668,7 @@ export class CodexDriver {
                     throw error;
                 }
                 this.stopObserving(threadId);
-                for (const item of await this.withSubAgents(threadId, joined.thread, threadToHistory(joined.thread))) {
+                for (const item of await this.withSubAgents(threadId, joined.thread, threadToHistory(joined.thread, this.mcpApps.lookup(threadId)))) {
                     if (!watch.seen.has(item.itemId))
                         this.report(threadId, item);
                 }
@@ -786,7 +812,7 @@ export class CodexDriver {
     }
     desktopMessage(threadId, input, clientMessageId) {
         const current = this.settings.get(threadId) ?? {};
-        const overrides = this.overrides.get(threadId) ?? {};
+        const overrides = this.overridesOf(threadId);
         return {
             input,
             text: textOf(input),
@@ -1019,7 +1045,7 @@ export class CodexDriver {
                     const result = await this.rpcFor(threadId, "thread/read", { threadId: child, includeTurns: true });
                     known.path = result.thread.path ?? undefined;
                     known.stamp = stamp;
-                    return nestHistory(subagentHistory(result.thread), callId);
+                    return nestHistory(subagentHistory(result.thread, this.mcpApps.lookup(child)), callId);
                 }
                 catch {
                     // A just-started child may not have written its rollout yet.
@@ -1088,7 +1114,7 @@ export class CodexDriver {
             const lines = [];
             if (command.name === "status") {
                 const { thread } = await this.rpcFor(nativeId, "thread/read", { threadId: nativeId, includeTurns: false });
-                const current = effective(this.settings.get(nativeId) ?? {}, this.overrides.get(nativeId) ?? {}, await this.loadModels());
+                const current = effective(this.settings.get(nativeId) ?? {}, this.overridesOf(nativeId), await this.loadModels());
                 const running = this.observed.get(nativeId)?.running ?? Boolean(this.stateOf(nativeId).activeTurnId);
                 lines.push(`目录：${thread.cwd}`, `模型：${current.model ?? "默认"}`, `推理强度：${current.effort ?? "默认"}`, `状态：${running ? "运行中" : "空闲"}`);
             }
@@ -1184,13 +1210,15 @@ export class CodexDriver {
                 this.host?.log(`[codex] steer failed, starting a new turn: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        const overrides = this.overrides.get(nativeId) ?? {};
-        await this.rpcFor(nativeId, "turn/start", {
+        const overrides = this.overridesOf(nativeId);
+        const started = await this.rpcFor(nativeId, "turn/start", {
             threadId: nativeId,
             clientUserMessageId: clientMessageId,
             input,
             ...turnOverrides(overrides, overrides.plan === undefined ? {} : effective(this.settings.get(nativeId) ?? {}, overrides, await this.loadModels())),
         });
+        if (overrides.permissions === "full-access" && typeof started?.turn?.id === "string")
+            this.markFullAccess(started.turn.id);
         return "started";
     }
     async goal(nativeId, change) {
@@ -1228,12 +1256,12 @@ export class CodexDriver {
             this.host?.log(`[codex] goal unavailable: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    /** Model, reasoning effort and permissions apply from the next turn on. */
+    /** Model, reasoning effort and permissions apply from the next turn on (full access at once, see autoApproval). */
     async setConfig(nativeId, optionId, value) {
         const models = await this.loadModels();
         const base = this.settings.get(nativeId) ?? {};
-        const current = effective(base, this.overrides.get(nativeId) ?? {}, models);
-        const next = { ...this.overrides.get(nativeId) };
+        const current = effective(base, this.overridesOf(nativeId), models);
+        const next = { ...this.overridesOf(nativeId) };
         if (optionId === "model") {
             if (!models.some((m) => m.model === value) && value !== current.model) {
                 throw RpcError.app("invalid_params", `unknown model ${value}`);
@@ -1263,16 +1291,217 @@ export class CodexDriver {
         else {
             throw RpcError.app("not_supported", `Codex has no setting ${optionId}`);
         }
-        this.overrides.set(nativeId, next);
+        this.setOverrides(nativeId, next);
+        // Codex fixes approvals when a turn starts, so the turn under way would go on asking.
+        const running = this.stateOf(nativeId).activeTurnId ?? this.observed.get(nativeId)?.turnId;
+        if (optionId === "permissions" && running) {
+            if (value === "full-access") {
+                this.markFullAccess(running);
+                this.approvePending(nativeId);
+            }
+            else
+                this.fullAccessTurns.delete(running);
+        }
         if (this.observed.has(nativeId) && this.desktopBusPath) {
             const updated = effective(base, next, models);
             const threadSettings = turnOverrides(next, { model: updated.model, effort: updated.effort });
             await updateSettingsThroughDesktop(this.desktopBusPath, nativeId, threadSettings, optionId === "permissions" ? (this.observed.get(nativeId)?.turnId ?? null) : null).catch((error) => {
                 this.host?.log(`[codex] desktop settings sync for ${nativeId}: ${error instanceof Error ? error.message : String(error)}`);
+                // The window keeps its own settings until then; saying nothing would look like the choice took.
+                this.host?.update(this.id, nativeId, {
+                    sessionUpdate: "ls_notice",
+                    level: "warning",
+                    title: "Codex 桌面 App 没有接受这项设置",
+                    detail: "电脑上那个窗口仍按原来的设置运行；从这里发下一条消息时会按新设置开始。",
+                });
             });
         }
         await this.announceConfig(nativeId);
     }
+    overridesOf(threadId) {
+        let overrides = this.overrides.get(threadId);
+        if (!overrides) {
+            try {
+                overrides = JSON.parse(this.host?.state(this.id, threadId).get("overrides") ?? "{}");
+            }
+            catch {
+                overrides = {};
+            }
+            this.overrides.set(threadId, overrides);
+        }
+        return overrides;
+    }
+    setOverrides(threadId, next) {
+        this.overrides.set(threadId, next);
+        this.host?.state(this.id, threadId).set("overrides", JSON.stringify(next));
+    }
+    /**
+     * With full access chosen, what Codex still asks in the thread (the turn
+     * under way started with the old approvals) is approved here, as it would
+     * not have been asked from the next turn on. Questions still go to the user.
+     */
+    autoApproval(method, request, turnId) {
+        // Only such turns: a turn someone else started keeps the approvals it was started with.
+        if (!APPROVAL_METHODS.has(method) || !turnId || !this.fullAccessTurns.has(turnId))
+            return undefined;
+        if (this.overridesOf(request.threadId).permissions !== "full-access")
+            return undefined;
+        const options = request.update.options;
+        return (options.find((option) => option.kind === "allow_always") ?? options.find((option) => option.kind === "allow_once"))?.optionId;
+    }
+    // ── side conversations (/side) ────────────────────────────────────
+    /**
+     * Codex's `/side`: an ephemeral fork of the thread (never written to disk),
+     * read-only, told where the inherited history ends. Each question is a turn
+     * in it; what it writes goes to `out`, not into the session.
+     */
+    async sideAsk(nativeId, request, out, signal) {
+        if (signal.aborted)
+            return;
+        const key = `${nativeId}\n${request.sideId}`;
+        const side = this.sides.get(key) ?? (await this.openSide(key, nativeId));
+        if (signal.aborted)
+            return;
+        const done = new Promise((resolve, reject) => {
+            side.out = out;
+            side.finish = (error) => (error ? reject(error) : resolve());
+        });
+        const stop = () => {
+            side.finish?.();
+            if (side.turnId)
+                void this.rpcFor(side.threadId, "turn/interrupt", { threadId: side.threadId, turnId: side.turnId }).catch(() => { });
+        };
+        signal.addEventListener("abort", stop, { once: true });
+        try {
+            const started = await this.rpcFor(side.threadId, "turn/start", {
+                threadId: side.threadId,
+                input: toCodexInput([{ type: "text", text: request.question }]),
+            });
+            if (typeof started?.turn?.id === "string")
+                side.turnId = started.turn.id;
+            if (signal.aborted)
+                stop();
+            await done;
+        }
+        catch (error) {
+            // The fork may be gone (Codex restarted it away): the next question opens a new one.
+            if (!side.turnId) {
+                this.sides.delete(side.key);
+                this.sideThreads.delete(side.threadId);
+            }
+            throw error;
+        }
+        finally {
+            signal.removeEventListener("abort", stop);
+            side.out = undefined;
+            side.finish = undefined;
+            side.turnId = undefined;
+            side.messageId = undefined;
+        }
+    }
+    async sideClose(nativeId, sideId) {
+        const side = this.sides.get(`${nativeId}\n${sideId}`);
+        if (!side)
+            return;
+        this.sides.delete(side.key);
+        this.sideThreads.delete(side.threadId);
+        side.finish?.();
+        // Nobody subscribed, an ephemeral thread is unloaded: nothing of it is left.
+        await this.rpcFor(side.threadId, "thread/unsubscribe", { threadId: side.threadId }).catch(() => { });
+        this.inShared.delete(side.threadId);
+        this.threads.delete(side.threadId);
+    }
+    async openSide(key, parent) {
+        let forked;
+        try {
+            forked = await this.rpcFor(parent, "thread/fork", {
+                threadId: parent,
+                ephemeral: true,
+                excludeTurns: true,
+                approvalPolicy: "never",
+                sandbox: "read-only",
+                developerInstructions: SIDE_INSTRUCTIONS,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error && /at least one turn|no rollout/i.test(error.message))
+                throw RpcError.app("not_ready", "这个 Codex 会话还没有任何消息：先发一条再问");
+            throw error;
+        }
+        const threadId = typeof forked.thread?.id === "string" ? forked.thread.id : undefined;
+        if (!threadId)
+            throw RpcError.app("agent_error", "Codex 没有开出旁支对话");
+        const side = { key, threadId };
+        this.sides.set(key, side);
+        this.sideThreads.set(threadId, side);
+        // The fork lives where its parent is loaded.
+        if (this.inShared.has(parent))
+            this.inShared.add(threadId);
+        await this.rpcFor(threadId, "thread/inject_items", {
+            threadId,
+            items: [{ type: "message", role: "developer", content: [{ type: "input_text", text: SIDE_BOUNDARY }] }],
+        }).catch((error) => this.host?.log(`[codex] side boundary not injected: ${error instanceof Error ? error.message : String(error)}`));
+        return side;
+    }
+    /** Their server went away, and an ephemeral thread with it: the next question opens a new one. */
+    loseSides(from) {
+        for (const side of [...this.sides.values()]) {
+            if (this.inShared.has(side.threadId) !== (from === "shared"))
+                continue;
+            this.sides.delete(side.key);
+            this.sideThreads.delete(side.threadId);
+            this.inShared.delete(side.threadId);
+            side.finish?.(new Error("Codex 重启了，这个回答没有完成：再问一次即可，之前的旁支内容 Codex 已不记得"));
+        }
+    }
+    sideUpdate(side, update) {
+        if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
+            if (side.messageId && side.messageId !== update.messageId)
+                side.out?.text("\n\n");
+            side.messageId = update.messageId;
+            side.out?.text(update.content.text);
+        }
+        else if (update.sessionUpdate === "tool_call")
+            side.out?.activity(update.title);
+        else if (update.sessionUpdate === "ls_error")
+            side.finish?.(new Error(update.message));
+        else if (update.sessionUpdate === "ls_turn" && update.state === "ended" && (!side.turnId || !update.turnId || update.turnId === side.turnId))
+            side.finish?.();
+    }
+    markFullAccess(turnId) {
+        this.fullAccessTurns.add(turnId);
+        if (this.fullAccessTurns.size > 200)
+            this.fullAccessTurns.delete(this.fullAccessTurns.values().next().value);
+    }
+    approvePending(threadId) {
+        for (const [requestId, pending] of this.approvals) {
+            if (pending.threadId !== threadId)
+                continue;
+            const optionId = this.autoApproval(pending.method, pending.request, pending.turnId);
+            if (!optionId)
+                continue;
+            this.approvals.delete(requestId);
+            pending.answer(pending.request.respond(optionId));
+            this.host?.update(this.id, threadId, { sessionUpdate: "ls_permission_resolved", requestId, optionId });
+        }
+    }
+    /** From the app-server the driver keeps running: its model list (cached) and the configuration a thread started in `cwd` reads. */
+    async listModels(cwd) {
+        const [models, configured] = await Promise.all([this.loadModels(), this.configuredModel(cwd)]);
+        return newThreadModels(models, configured);
+    }
+    /** The model config.toml (with the project's own layers, for `cwd`) gives a new thread; undefined: Codex's default. */
+    async configuredModel(cwd) {
+        try {
+            const result = await this.rpc("config/read", { includeLayers: false, ...(cwd ? { cwd } : {}) });
+            return result.config?.model ?? undefined;
+        }
+        catch (error) {
+            // Older app-servers have no config/read: the list's default is the best guess.
+            this.host?.log(`[codex] config/read failed: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    }
     loadModels() {
         this.models ??= this.rpc("model/list", { includeHidden: false })
             .then((result) => result.data)
@@ -1285,7 +1514,7 @@ export class CodexDriver {
     }
     async announceConfig(nativeId) {
         const models = await this.loadModels();
-        const options = configOptions(this.settings.get(nativeId) ?? {}, this.overrides.get(nativeId) ?? {}, models);
+        const options = configOptions(this.settings.get(nativeId) ?? {}, this.overridesOf(nativeId), models);
         if (options.length > 0 && this.isNews(`config:${nativeId}`, options))
             this.host?.update(this.id, nativeId, { sessionUpdate: "ls_config", options });
     }
@@ -1485,6 +1714,7 @@ export class CodexDriver {
             return;
         this.host?.log(`[codex] ${reason}`);
         this.abandonApprovals("own");
+        this.loseSides("own");
         for (const threadId of [...this.attached]) {
             // (What is joined in Codex's background server is still there.)
             if (this.inShared.has(threadId))
@@ -1560,6 +1790,9 @@ export class CodexDriver {
             const thread = params?.thread;
             if (!thread?.id)
                 return;
+            // A side conversation (ours, or one a TUI opened with /side): gone when it closes, never a session.
+            if (thread.ephemeral)
+                return;
             if (thread.parentThreadId) {
                 // A sub-agent: its work shows inside the parent session, not as a session of its own.
                 this.subThreads.add(thread.id);
@@ -1583,6 +1816,12 @@ export class CodexDriver {
             return;
         }
         const threadId = params?.threadId;
+        const side = typeof threadId === "string" ? this.sideThreads.get(threadId) : undefined;
+        if (side) {
+            for (const mapped of mapNotification(method, params, (id) => this.stateOf(id)))
+                this.sideUpdate(side, mapped.update);
+            return;
+        }
         const held = typeof threadId === "string" ? this.joining.get(threadId) : undefined;
         if (held) {
             held.push({ method, params, from });
@@ -1603,7 +1842,7 @@ export class CodexDriver {
             if (frame)
                 this.host?.preview?.(this.id, threadId, frame);
         }
-        for (const mapped of mapNotification(method, params, (id) => this.stateOf(id))) {
+        for (const mapped of mapNotification(method, params, (id) => this.stateOf(id), (id) => this.mcpApps.lookup(id))) {
             const update = from === "shared" && mapped.update.sessionUpdate === "ls_permission_resolved"
                 ? { ...mapped.update, requestId: sharedRequestId(mapped.update.requestId) }
                 : mapped.update;
@@ -1660,6 +1899,14 @@ export class CodexDriver {
             return ABANDON;
         const requestId = from === "shared" ? sharedRequestId(String(id)) : String(id);
         const mapped = QUESTION_METHODS.has(method) ? mapQuestionRequest(method, params, requestId) : mapApprovalRequest(method, params, requestId);
+        const side = mapped && this.sideThreads.get(mapped.threadId);
+        if (side && mapped) {
+            // A side conversation changes nothing (it runs read-only and is told so): what it would need asking for is declined.
+            const options = mapped.update.options;
+            const decline = (options.find((option) => option.kind === "reject_once") ?? options[0]).optionId;
+            side.out?.activity(`已拒绝：${mapped.update.title}（旁支对话只读）`);
+            return mapped.answer ? mapped.answer([]) : mapped.respond(decline);
+        }
         // A sub-agent asking for permission asks in its parent session.
         const request = mapped && this.children.has(mapped.threadId) ? { ...mapped, threadId: this.children.get(mapped.threadId).threadId } : mapped;
         if (!request || !this.attached.has(request.threadId))
@@ -1668,9 +1915,18 @@ export class CodexDriver {
         const toolTitle = method === "item/fileChange/requestApproval" && request.update.toolCallId && this.toolTitles.get(request.update.toolCallId);
         if (toolTitle)
             request.update = { ...request.update, title: toolTitle };
+        const asking = params?.turnId;
+        const turnId = mapped && mapped.threadId !== request.threadId ? this.stateOf(request.threadId).activeTurnId : typeof asking === "string" ? asking : undefined;
+        const approved = this.autoApproval(method, request, turnId);
+        if (approved) {
+            this.host?.log(`[codex] ${method} in ${request.threadId} approved under the full access a device chose`);
+            return request.respond(approved);
+        }
         return new Promise((resolve) => {
             this.approvals.set(requestId, {
                 threadId: request.threadId,
+                method,
+                turnId,
                 request,
                 answer: resolve,
                 abandon: () => resolve(ABANDON),
@@ -1678,6 +1934,19 @@ export class CodexDriver {
             this.host?.update(this.id, request.threadId, request.update);
         });
     }
+    /** A tool call's page, found only once its tool had been looked up: to the card, wherever the call's thread shows. */
+    lateDetail(threadId, toolCallId, detail) {
+        const update = { sessionUpdate: "tool_call_update", toolCallId, detail };
+        const parent = this.children.get(threadId);
+        if (parent) {
+            const nested = nestUnder(update, parent.toolCallId);
+            if (nested && this.attached.has(parent.threadId))
+                this.host?.update(this.id, parent.threadId, nested);
+        }
+        else if (this.attached.has(threadId)) {
+            this.host?.update(this.id, threadId, update);
+        }
+    }
     rememberTitle(toolCallId, title) {
         this.toolTitles.delete(toolCallId);
         this.toolTitles.set(toolCallId, title);
@@ -1712,6 +1981,7 @@ export class CodexDriver {
             return;
         this.host?.log("[codex] lost Codex's background server");
         this.abandonApprovals("shared");
+        this.loseSides("shared");
         const joined = [...this.inShared].filter((threadId) => this.attached.delete(threadId));
         this.inShared.clear();
         for (const threadId of joined) {