@getpaseo/server 0.1.74 → 0.1.76

package/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -1,3 +1,4 @@
+import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
 import { homedir } from "node:os";
 import { randomUUID } from "node:crypto";
 import * as fsSync from "node:fs";
@@ -13,8 +14,9 @@ import { findExecutable, isCommandAvailable } from "../../../utils/executable.js
 import { spawnProcess } from "../../../utils/spawn.js";
 import { extractCodexTerminalSessionId, nonEmptyString } from "./tool-call-mapper-utils.js";
 import { buildCodexFeatures, codexModelSupportsFastMode } from "./codex-feature-definitions.js";
-import { CodexAppServerClient } from "./codex/app-server-transport.js";
+import { CodexAppServerClient, } from "./codex/app-server-transport.js";
 import { renderProviderImageOutputAsAssistantMarkdown, } from "./provider-image-output.js";
+import { normalizeProviderReplayTimestamp } from "../provider-history-timestamps.js";
 import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
 function assertChildWithPipes(child) {
@@ -37,11 +39,13 @@ const CODEX_TOOL_THREAD_ITEM_TYPES = new Set([
     "webSearch",
     "collabAgentToolCall",
 ]);
+const CODEX_CONTEXT_COMPACTION_TYPE = "contextCompaction";
 const CODEX_PLAN_IMPLEMENTATION_PROMPT_PREFIX = "The user approved the plan. Implement it now. Do not restate or revise the plan unless blocked.";
 // Codex's experimental `goals` feature ships in 0.128.0+. Older binaries reject
 // `--enable goals` at launch, so we gate by version and silently skip the flag
 // (and the /goal slash command) when the binary is too old.
 const CODEX_GOALS_MIN_VERSION = [0, 128, 0];
+const CODEX_AUTO_REVIEW_MIN_VERSION = [0, 115, 0];
 function parseCodexVersion(versionOutput) {
     const match = versionOutput.match(/(\d+)\.(\d+)\.(\d+)/);
     if (!match)
@@ -90,6 +94,11 @@ const CODEX_MODES = [
         label: "Default Permissions",
         description: "Edit files and run commands with Codex's default approval flow.",
     },
+    {
+        id: "auto-review",
+        label: "Auto-review",
+        description: "Same workspace-write permissions as Default, but eligible `on-request` approvals are routed through the auto-reviewer subagent.",
+    },
     {
         id: "full-access",
         label: "Full Access",
@@ -106,12 +115,30 @@ const MODE_PRESETS = {
         approvalPolicy: "on-request",
         sandbox: "workspace-write",
     },
+    "auto-review": {
+        approvalPolicy: "on-request",
+        sandbox: "workspace-write",
+        approvalsReviewer: "auto_review",
+    },
     "full-access": {
         approvalPolicy: "never",
         sandbox: "danger-full-access",
         networkAccess: true,
     },
 };
+function isAutoReviewReviewer(value) {
+    return value === "auto_review" || value === "guardian_subagent";
+}
+function applyApprovalsReviewerParam(params, preset) {
+    if (preset.approvalsReviewer) {
+        params.approvalsReviewer = preset.approvalsReviewer;
+    }
+}
+function shouldPromoteThreadResponseToAutoReview(params) {
+    return (isAutoReviewReviewer(params.approvalsReviewer) &&
+        params.approvalPolicy === "on-request" &&
+        params.sandbox === "workspace-write");
+}
 function validateCodexMode(modeId) {
     if (!(modeId in MODE_PRESETS)) {
         const validModes = Object.keys(MODE_PRESETS).join(", ");
@@ -1069,6 +1096,29 @@ function firstStringField(record, fields) {
     }
     return null;
 }
+function readCodexHistoryTimestamp(item) {
+    const record = toObjectRecord(item);
+    if (!record) {
+        return null;
+    }
+    return (normalizeProviderReplayTimestamp(record.timestamp) ??
+        normalizeProviderReplayTimestamp(record.createdAt) ??
+        normalizeProviderReplayTimestamp(record.created_at));
+}
+function readCodexTurnHistoryTimestamp(turn, timelineItem) {
+    const record = toObjectRecord(turn);
+    if (!record) {
+        return null;
+    }
+    const startedAt = normalizeProviderReplayTimestamp(record.startedAt) ??
+        normalizeProviderReplayTimestamp(record.started_at);
+    const completedAt = normalizeProviderReplayTimestamp(record.completedAt) ??
+        normalizeProviderReplayTimestamp(record.completed_at);
+    if (timelineItem.type === "user_message") {
+        return startedAt ?? completedAt;
+    }
+    return completedAt ?? startedAt;
+}
 function codexImageOutputFromResult(result) {
     if (typeof result === "string") {
         const trimmed = result.trim();
@@ -1138,15 +1188,23 @@ function threadItemToTimeline(item, options) {
     switch (normalizedType) {
         case "userMessage":
             return mapCodexThreadUserMessageItem(normalizedItem, includeUserMessage);
-        case "agentMessage":
+        case "agentMessage": {
+            const messageId = nonEmptyString(normalizedItem.id);
             return {
                 type: "assistant_message",
                 text: typeof normalizedItem.text === "string" ? normalizedItem.text : "",
+                ...(messageId ? { messageId } : {}),
             };
+        }
         case "plan":
             return mapCodexThreadPlanItem(normalizedItem);
         case "reasoning":
             return mapCodexThreadReasoningItem(normalizedItem);
+        case CODEX_CONTEXT_COMPACTION_TYPE:
+            return {
+                type: "compaction",
+                status: "completed",
+            };
         default:
             return null;
     }
@@ -1178,7 +1236,11 @@ async function loadCodexThreadHistoryTimeline(params) {
         for (const item of turn.items) {
             const timelineItem = threadItemToTimeline(item, { cwd: params.cwd });
             if (timelineItem) {
-                timeline.push(timelineItem);
+                const timestamp = readCodexHistoryTimestamp(item) ?? readCodexTurnHistoryTimestamp(turn, timelineItem);
+                timeline.push({
+                    item: timelineItem,
+                    timestamp: timestamp ?? undefined,
+                });
             }
         }
     }
@@ -1295,6 +1357,12 @@ const ItemLifecycleNotificationSchema = z
         .passthrough(),
 })
     .passthrough();
+const ContextCompactedNotificationSchema = z
+    .object({
+    threadId: z.string(),
+    turnId: z.string().optional(),
+})
+    .passthrough();
 const CodexEventTurnAbortedNotificationSchema = z
     .object({
     msg: z
@@ -1510,6 +1578,18 @@ const CodexNotificationSchema = z.union([
         method,
         params,
     })),
+    z
+        .object({ method: z.literal("thread/compacted"), params: ContextCompactedNotificationSchema })
+        .transform(({ params }) => ({
+        kind: "context_compacted",
+        threadId: params.threadId,
+        turnId: params.turnId ?? null,
+    })),
+    z.object({ method: z.literal("thread/compacted"), params: z.unknown() }).transform(({ method, params }) => ({
+        kind: "invalid_payload",
+        method,
+        params,
+    })),
     z
         .object({
         method: z.literal("item/agentMessage/delta"),
@@ -1911,13 +1991,54 @@ function buildCodexAppServerInitializeParams() {
         },
     };
 }
+function normalizeOpenAICompatibleBaseUrl(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const withoutTrailingSlashes = trimmed.replace(/\/+$/u, "");
+    if (withoutTrailingSlashes.endsWith("/v1")) {
+        return withoutTrailingSlashes;
+    }
+    return `${withoutTrailingSlashes}/v1`;
+}
+function buildCodexCustomProviderConfig(runtimeSettings, customProvider) {
+    if (customProvider?.extends !== CODEX_PROVIDER) {
+        return null;
+    }
+    const baseUrl = runtimeSettings?.env?.OPENAI_BASE_URL;
+    if (typeof baseUrl !== "string") {
+        return null;
+    }
+    const normalizedBaseUrl = normalizeOpenAICompatibleBaseUrl(baseUrl);
+    if (!normalizedBaseUrl) {
+        return null;
+    }
+    const providerConfig = {
+        name: customProvider.label,
+        base_url: normalizedBaseUrl,
+        wire_api: "responses",
+    };
+    if (runtimeSettings?.env?.OPENAI_API_KEY?.trim()) {
+        providerConfig.env_key = "OPENAI_API_KEY";
+        providerConfig.requires_openai_auth = false;
+    }
+    return {
+        model_provider: customProvider.id,
+        model_providers: {
+            [customProvider.id]: providerConfig,
+        },
+    };
+}
 class CodexAppServerAgentSession {
-    constructor(config, resumeHandle, logger, spawnAppServer, deps = {}, ephemeral = false, goalsEnabled = false) {
+    constructor(config, resumeHandle, logger, spawnAppServer, deps = {}, ephemeral = false, goalsEnabled = false, autoReviewEnabled = false, agentId) {
         this.resumeHandle = resumeHandle;
         this.spawnAppServer = spawnAppServer;
         this.deps = deps;
         this.ephemeral = ephemeral;
         this.goalsEnabled = goalsEnabled;
+        this.autoReviewEnabled = autoReviewEnabled;
+        this.agentId = agentId;
         this.provider = CODEX_PROVIDER;
         this.capabilities = CODEX_APP_SERVER_CAPABILITIES;
         this.currentThreadId = null;
@@ -1952,11 +2073,21 @@ class CodexAppServerAgentSession {
         this.warnedInvalidNotificationPayloads = new Set();
         this.warnedIncompleteEditToolCallIds = new Set();
         this.latestPlanResult = null;
+        this.pendingManualCompactionStarts = 0;
+        this.compactionTriggerByItemId = new Map();
+        // Codex can report one completed compaction through both channels:
+        // `thread/compacted` and a completed `contextCompaction` item.
+        this.unpairedCompactionNotificationCompletions = 0;
+        this.unpairedCompactionItemCompletions = 0;
         this.connected = false;
         this.collaborationModes = [];
         this.resolvedCollaborationMode = null;
         this.cachedSkills = [];
-        this.logger = logger.child({ module: "agent", provider: CODEX_PROVIDER });
+        this.logger = logger.child({
+            module: "agent",
+            provider: CODEX_PROVIDER,
+            agentId: this.agentId,
+        });
         if (config.modeId === undefined) {
             throw new Error("Codex agent requires modeId to be specified");
         }
@@ -1964,7 +2095,7 @@ class CodexAppServerAgentSession {
         this.currentMode = config.modeId;
         this.config = config;
         this.config.thinkingOptionId = normalizeCodexThinkingOptionId(this.config.thinkingOptionId);
-        if (this.config.featureValues?.fast_mode) {
+        if (this.config.featureValues?.fast_mode && codexModelSupportsFastMode(this.config.model)) {
             this.serviceTier = "fast";
         }
         if (this.config.featureValues?.plan_mode) {
@@ -1990,7 +2121,7 @@ class CodexAppServerAgentSession {
         if (this.connected)
             return;
         const child = await this.spawnAppServer();
-        this.client = new CodexAppServerClient(child, this.logger);
+        this.client = new CodexAppServerClient(child, this.logger, () => this.traceContext());
         this.client.setNotificationHandler((method, params) => this.handleNotification(method, params));
         this.registerRequestHandlers();
         await this.client.request("initialize", buildCodexAppServerInitializeParams());
@@ -2003,6 +2134,13 @@ class CodexAppServerAgentSession {
         }
         this.connected = true;
     }
+    traceContext() {
+        return {
+            agentId: this.agentId,
+            sessionId: this.currentThreadId ?? undefined,
+            turnId: this.activeForegroundTurnId ?? undefined,
+        };
+    }
     async loadCollaborationModes() {
         if (!this.client)
             return;
@@ -2023,7 +2161,13 @@ class CodexAppServerAgentSession {
             });
         }
         catch (error) {
-            this.logger.trace({ error }, "Failed to load collaboration modes");
+            this.logger.trace({
+                agentId: this.agentId,
+                provider: CODEX_PROVIDER,
+                sessionId: this.currentThreadId,
+                turnId: this.activeForegroundTurnId ?? undefined,
+                error,
+            }, "provider.codex.metadata.collaboration_modes_failed");
             this.collaborationModes = [];
         }
         this.refreshResolvedCollaborationMode();
@@ -2036,7 +2180,7 @@ class CodexAppServerAgentSession {
                 cwd: [this.config.cwd],
             }));
             const entries = Array.isArray(response?.data) ? response.data : [];
-            const skills = [];
+            const skillsByName = new Map();
             for (const entry of entries) {
                 const entryRecord = toObjectRecord(entry);
                 const list = Array.isArray(entryRecord?.skills) ? entryRecord.skills : [];
@@ -2044,17 +2188,25 @@ class CodexAppServerAgentSession {
                     const skillRecord = toObjectRecord(skill);
                     if (typeof skillRecord?.name !== "string" || typeof skillRecord?.path !== "string")
                         continue;
-                    skills.push({
-                        name: skillRecord.name,
-                        description: resolveSkillDescription(skillRecord),
-                        path: skillRecord.path,
-                    });
+                    if (!skillsByName.has(skillRecord.name)) {
+                        skillsByName.set(skillRecord.name, {
+                            name: skillRecord.name,
+                            description: resolveSkillDescription(skillRecord),
+                            path: skillRecord.path,
+                        });
+                    }
                 }
             }
-            this.cachedSkills = skills;
+            this.cachedSkills = Array.from(skillsByName.values());
         }
         catch (error) {
-            this.logger.trace({ error }, "Failed to load skills list");
+            this.logger.trace({
+                agentId: this.agentId,
+                provider: CODEX_PROVIDER,
+                sessionId: this.currentThreadId,
+                turnId: this.activeForegroundTurnId ?? undefined,
+                error,
+            }, "provider.codex.metadata.skills_failed");
             this.cachedSkills = [];
         }
     }
@@ -2212,9 +2364,10 @@ class CodexAppServerAgentSession {
             await this.client.request("thread/resume", params);
         }
         catch (error) {
-            this.logger.warn({ error }, "Failed to resume Codex thread, starting new thread");
-            this.currentThreadId = null;
-            await this.ensureThread();
+            const threadId = this.currentThreadId;
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ error, threadId }, "Failed to resume persisted Codex thread");
+            throw new Error(`Failed to resume Codex thread ${threadId}: ${message}`, { cause: error });
         }
     }
     parseSlashCommandInput(text) {
@@ -2265,56 +2418,18 @@ class CodexAppServerAgentSession {
         }
         const skill = this.cachedSkills.find((entry) => entry.name === commandName);
         if (skill) {
+            const trimmedArgs = args?.trim() ?? "";
+            const text = trimmedArgs ? `$${skill.name} ${trimmedArgs}` : `$${skill.name}`;
             const input = [
                 { type: "skill", name: skill.name, path: skill.path },
+                { type: "text", text },
             ];
-            if (args && args.trim().length > 0) {
-                input.push({ type: "text", text: args.trim() });
-            }
-            else {
-                input.push({ type: "text", text: `$${skill.name}` });
-            }
             return input;
         }
         return args ? `$${commandName} ${args}` : `$${commandName}`;
     }
-    async run(prompt, options) {
-        return runProviderTurn({
-            prompt,
-            runOptions: options,
-            startTurn: (p, o) => this.startTurn(p, o),
-            subscribe: (callback) => this.subscribe(callback),
-            getSessionId: async () => (await this.getRuntimeInfo()).sessionId ?? "",
-            reduceFinalText: ({ current, item }) => {
-                if (item.type === "assistant_message") {
-                    return item.text;
-                }
-                if (item.type === "tool_call" && item.detail.type === "plan") {
-                    return item.detail.text;
-                }
-                return current;
-            },
-        });
-    }
-    async startTurn(prompt, options) {
-        if (this.activeForegroundTurnId) {
-            throw new Error("A foreground turn is already active");
-        }
-        await this.connect();
-        if (!this.client) {
-            throw new Error("Codex client not initialized");
-        }
-        const slashCommand = await this.resolveSlashCommandInvocation(prompt);
-        const effectivePrompt = slashCommand
-            ? await this.buildCommandPromptInput(slashCommand.commandName, slashCommand.args)
-            : prompt;
-        if (this.currentThreadId) {
-            await this.ensureThreadLoaded();
-        }
-        else {
-            await this.ensureThread();
-        }
-        const input = await this.buildUserInput(effectivePrompt);
+    async buildTurnStartParams(prompt, options) {
+        const input = await this.buildUserInput(prompt);
         const preset = MODE_PRESETS[this.currentMode] ?? MODE_PRESETS[DEFAULT_CODEX_MODE_ID];
         const approvalPolicy = this.config.approvalPolicy ?? preset.approvalPolicy;
         const sandboxPolicyType = this.config.sandboxMode ?? preset.sandbox;
@@ -2326,6 +2441,7 @@ class CodexAppServerAgentSession {
                 ? this.config.networkAccess
                 : preset.networkAccess),
         };
+        applyApprovalsReviewerParam(params, preset);
         if (this.config.model) {
             params.model = this.config.model;
         }
@@ -2355,10 +2471,81 @@ class CodexAppServerAgentSession {
         if (codexConfig) {
             params.config = codexConfig;
         }
+        return {
+            params,
+            thinkingOptionId,
+            approvalPolicy,
+            sandboxPolicyType,
+            hasOutputSchema: Boolean(options?.outputSchema),
+            hasCodexConfig: Boolean(codexConfig),
+        };
+    }
+    logTurnStartSummary({ turnId, thinkingOptionId, approvalPolicy, sandboxPolicyType, hasOutputSchema, hasCodexConfig, }) {
+        this.logger.info({
+            turnId,
+            threadId: this.currentThreadId,
+            model: this.config.model ?? null,
+            modeId: this.currentMode ?? null,
+            effort: thinkingOptionId ?? null,
+            serviceTier: this.serviceTier,
+            cwd: this.config.cwd ?? null,
+            approvalPolicy,
+            sandboxPolicyType,
+            hasCollaborationMode: Boolean(this.resolvedCollaborationMode),
+            hasOutputSchema,
+            hasDeveloperInstructions: Boolean(this.config.systemPrompt?.trim()),
+            hasCodexConfig,
+        }, "Starting Codex app-server turn");
+    }
+    async run(prompt, options) {
+        return runProviderTurn({
+            prompt,
+            runOptions: options,
+            startTurn: (p, o) => this.startTurn(p, o),
+            subscribe: (callback) => this.subscribe(callback),
+            getSessionId: async () => (await this.getRuntimeInfo()).sessionId ?? "",
+            reduceFinalText: ({ current, item }) => {
+                if (item.type === "assistant_message") {
+                    return item.text;
+                }
+                if (item.type === "tool_call" && item.detail.type === "plan") {
+                    return item.detail.text;
+                }
+                return current;
+            },
+        });
+    }
+    async startTurn(prompt, options) {
+        if (this.activeForegroundTurnId) {
+            throw new Error("A foreground turn is already active");
+        }
+        await this.connect();
+        if (!this.client) {
+            throw new Error("Codex client not initialized");
+        }
+        const slashCommand = await this.resolveSlashCommandInvocation(prompt);
+        const effectivePrompt = slashCommand
+            ? await this.buildCommandPromptInput(slashCommand.commandName, slashCommand.args)
+            : prompt;
+        if (this.currentThreadId) {
+            await this.ensureThreadLoaded();
+        }
+        else {
+            await this.ensureThread();
+        }
+        const turnStart = await this.buildTurnStartParams(effectivePrompt, options);
         const turnId = this.createTurnId();
         this.activeForegroundTurnId = turnId;
         try {
-            await this.client.request("turn/start", params, TURN_START_TIMEOUT_MS);
+            this.logTurnStartSummary({
+                turnId,
+                thinkingOptionId: turnStart.thinkingOptionId,
+                approvalPolicy: turnStart.approvalPolicy,
+                sandboxPolicyType: turnStart.sandboxPolicyType,
+                hasOutputSchema: turnStart.hasOutputSchema,
+                hasCodexConfig: turnStart.hasCodexConfig,
+            });
+            await this.client.request("turn/start", turnStart.params, TURN_START_TIMEOUT_MS);
         }
         catch (error) {
             this.activeForegroundTurnId = null;
@@ -2379,8 +2566,13 @@ class CodexAppServerAgentSession {
         const history = this.persistedHistory;
         this.persistedHistory = [];
         this.historyPending = false;
-        for (const item of history) {
-            yield { type: "timeline", provider: CODEX_PROVIDER, item };
+        for (const entry of history) {
+            yield {
+                type: "timeline",
+                provider: CODEX_PROVIDER,
+                item: entry.item,
+                timestamp: entry.timestamp,
+            };
         }
     }
     async getRuntimeInfo() {
@@ -2406,7 +2598,10 @@ class CodexAppServerAgentSession {
         return { ...info };
     }
     async getAvailableModes() {
-        return CODEX_MODES;
+        if (this.autoReviewEnabled) {
+            return CODEX_MODES;
+        }
+        return CODEX_MODES.filter((mode) => mode.id !== "auto-review");
     }
     async getCurrentMode() {
         return this.currentMode ?? null;
@@ -2431,6 +2626,9 @@ class CodexAppServerAgentSession {
     }
     async setFeature(featureId, value) {
         if (featureId === "fast_mode") {
+            if (Boolean(value) && !codexModelSupportsFastMode(this.config.model)) {
+                throw new Error(`Codex fast mode is not available for model '${this.config.model ?? "default"}'`);
+            }
             this.applyFeatureValue("fast_mode", Boolean(value));
             return;
         }
@@ -2635,7 +2833,13 @@ class CodexAppServerAgentSession {
         const fallbackSkills = appServerSkills.length === 0
             ? await listCodexSkills(this.config.cwd, this.deps.workspaceGitService)
             : [];
-        const builtin = [];
+        const builtin = [
+            {
+                name: "compact",
+                description: "Summarize conversation to prevent hitting the context limit",
+                argumentHint: "",
+            },
+        ];
         if (this.goalsEnabled) {
             builtin.push({
                 name: "goal",
@@ -2646,12 +2850,26 @@ class CodexAppServerAgentSession {
         return [...builtin, ...appServerSkills, ...fallbackSkills, ...prompts].sort((a, b) => a.name.localeCompare(b.name));
     }
     tryHandleOutOfBand(prompt) {
-        if (!this.goalsEnabled)
-            return null;
         if (typeof prompt !== "string")
             return null;
         const parsed = this.parseSlashCommandInput(prompt);
-        if (!parsed || parsed.commandName !== "goal")
+        if (!parsed)
+            return null;
+        if (parsed.commandName === "compact") {
+            return {
+                run: async ({ emit }) => {
+                    const error = await this.executeCompactCommand();
+                    if (error) {
+                        emit({
+                            type: "timeline",
+                            provider: CODEX_PROVIDER,
+                            item: { type: "assistant_message", text: formatOutOfBandStatusMessage(error) },
+                        });
+                    }
+                },
+            };
+        }
+        if (!this.goalsEnabled || parsed.commandName !== "goal")
             return null;
         const subcommand = parseGoalSubcommand(parsed.args);
         return {
@@ -2665,6 +2883,35 @@ class CodexAppServerAgentSession {
             },
         };
     }
+    async executeCompactCommand() {
+        try {
+            await this.connect();
+            if (this.currentThreadId) {
+                await this.ensureThreadLoaded();
+            }
+            else {
+                await this.ensureThread();
+            }
+            if (!this.client || !this.currentThreadId) {
+                throw new Error("Codex thread is not available");
+            }
+            this.pendingManualCompactionStarts += 1;
+            try {
+                await this.client.request("thread/compact/start", {
+                    threadId: this.currentThreadId,
+                });
+            }
+            catch (error) {
+                this.pendingManualCompactionStarts = Math.max(0, this.pendingManualCompactionStarts - 1);
+                throw error;
+            }
+            return null;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "unknown error";
+            return `Failed to compact context: ${message}`;
+        }
+    }
     async executeGoalSubcommand(subcommand) {
         if (subcommand.kind === "usage") {
             return "Usage: /goal <objective>|pause|resume|clear";
@@ -2776,7 +3023,7 @@ class CodexAppServerAgentSession {
         const approvalPolicy = this.config.approvalPolicy ?? preset.approvalPolicy;
         const sandbox = this.config.sandboxMode ?? preset.sandbox;
         const innerConfig = this.buildCodexInnerConfig();
-        const rawResponse = await this.client.request("thread/start", {
+        const params = {
             model,
             cwd: this.config.cwd ?? null,
             approvalPolicy,
@@ -2786,13 +3033,24 @@ class CodexAppServerAgentSession {
                 : {}),
             ...(innerConfig ? { config: innerConfig } : {}),
             ...(this.ephemeral ? { ephemeral: true } : {}),
-        });
+        };
+        applyApprovalsReviewerParam(params, preset);
+        const rawResponse = await this.client.request("thread/start", params);
         const response = toObjectRecord(rawResponse);
         const threadRecord = toObjectRecord(response?.thread);
         const threadId = typeof threadRecord?.id === "string" ? threadRecord.id : undefined;
         if (!threadId) {
             throw new Error("Codex app-server did not return thread id");
         }
+        const responseApprovalsReviewer = typeof response?.approvalsReviewer === "string" ? response.approvalsReviewer : undefined;
+        if (shouldPromoteThreadResponseToAutoReview({
+            approvalsReviewer: responseApprovalsReviewer,
+            approvalPolicy,
+            sandbox,
+        })) {
+            this.currentMode = "auto-review";
+            this.cachedRuntimeInfo = null;
+        }
         this.currentThreadId = threadId;
     }
     buildCodexInnerConfig() {
@@ -2807,6 +3065,9 @@ class CodexAppServerAgentSession {
         if (this.config.extra?.codex) {
             Object.assign(innerConfig, this.config.extra.codex);
         }
+        if (this.deps.customCodexConfig) {
+            Object.assign(innerConfig, this.deps.customCodexConfig);
+        }
         return Object.keys(innerConfig).length > 0 ? innerConfig : null;
     }
     async buildUserInput(prompt) {
@@ -2821,6 +3082,13 @@ class CodexAppServerAgentSession {
     notifySubscribers(event) {
         const turnId = this.activeForegroundTurnId;
         const tagged = turnId ? { ...event, turnId } : event;
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: CODEX_PROVIDER,
+            sessionId: this.currentThreadId,
+            turnId: getAgentStreamEventTurnId(tagged),
+            event: tagged,
+        }, "provider.codex.event_emit");
         for (const callback of this.subscribers) {
             try {
                 callback(tagged);
@@ -2835,6 +3103,7 @@ class CodexAppServerAgentSession {
     }
     handleNotification(method, params) {
         const parsed = CodexNotificationSchema.parse({ method, params });
+        this.traceParsedNotification(method, params, parsed);
         switch (parsed.kind) {
             case "thread_started":
                 this.handleThreadStartedNotification(parsed);
@@ -2856,6 +3125,9 @@ class CodexAppServerAgentSession {
             case "token_usage_updated":
                 this.handleTokenUsageUpdatedNotification(parsed);
                 return;
+            case "context_compacted":
+                this.handleContextCompactedNotification(parsed);
+                return;
             case "agent_message_delta":
             case "reasoning_delta":
             case "exec_command_output_delta":
@@ -2890,6 +3162,17 @@ class CodexAppServerAgentSession {
                 this.warnUnknownNotificationMethod(parsed.method, parsed.params);
         }
     }
+    traceParsedNotification(method, params, parsed) {
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: CODEX_PROVIDER,
+            sessionId: this.currentThreadId,
+            turnId: this.activeForegroundTurnId ?? undefined,
+            method,
+            params,
+            parsed,
+        }, "provider.codex.parsed_event");
+    }
     getSubAgentCallIdForThread(threadId) {
         if (!threadId || threadId === this.currentThreadId) {
             return null;
@@ -2998,6 +3281,7 @@ class CodexAppServerAgentSession {
             if (subAgentCallId) {
                 this.upsertSubAgentChildItem(subAgentCallId, parsed.itemId, {
                     type: "assistant_message",
+                    messageId: parsed.itemId,
                     text,
                 });
                 this.emitSubAgentActivityUpdate(subAgentCallId, "running");
@@ -3009,6 +3293,7 @@ class CodexAppServerAgentSession {
                 provider: CODEX_PROVIDER,
                 item: {
                     type: "assistant_message",
+                    messageId: parsed.itemId,
                     text: isFirstDeltaForItem && this.pendingAssistantMessageBoundary
                         ? `${ASSISTANT_MESSAGE_BOUNDARY_MARKDOWN}${parsed.delta}`
                         : parsed.delta,
@@ -3113,6 +3398,8 @@ class CodexAppServerAgentSession {
         this.pendingFileChangeOutputDeltas.clear();
         this.pendingAssistantMessageBoundary = false;
         this.warnedIncompleteEditToolCallIds.clear();
+        this.unpairedCompactionNotificationCompletions = 0;
+        this.unpairedCompactionItemCompletions = 0;
     }
     handlePlanUpdatedNotification(parsed) {
         const timelineItem = mapCodexPlanToToolCall({
@@ -3143,6 +3430,55 @@ class CodexAppServerAgentSession {
             });
         }
     }
+    resolveContextCompactionTrigger(itemId) {
+        if (itemId) {
+            const known = this.compactionTriggerByItemId.get(itemId);
+            if (known) {
+                return known;
+            }
+        }
+        if (this.pendingManualCompactionStarts > 0) {
+            this.pendingManualCompactionStarts -= 1;
+            return "manual";
+        }
+        return undefined;
+    }
+    createContextCompactionTimelineItem(status, itemId) {
+        const trigger = this.resolveContextCompactionTrigger(itemId);
+        if (itemId && trigger) {
+            if (status === "loading") {
+                this.compactionTriggerByItemId.set(itemId, trigger);
+            }
+            else {
+                this.compactionTriggerByItemId.delete(itemId);
+            }
+        }
+        return {
+            type: "compaction",
+            status,
+            ...(trigger ? { trigger } : {}),
+        };
+    }
+    isContextCompactionItem(item) {
+        return (normalizeCodexThreadItemType(typeof item.type === "string" ? item.type : undefined) ===
+            CODEX_CONTEXT_COMPACTION_TYPE);
+    }
+    handleContextCompactedNotification(parsed) {
+        if (parsed.threadId !== this.currentThreadId) {
+            return;
+        }
+        if (this.unpairedCompactionItemCompletions > 0) {
+            this.unpairedCompactionItemCompletions -= 1;
+            return;
+        }
+        this.unpairedCompactionNotificationCompletions += 1;
+        this.emitEvent({
+            type: "timeline",
+            provider: CODEX_PROVIDER,
+            item: this.createContextCompactionTimelineItem("completed"),
+            ...(parsed.turnId ? { turnId: parsed.turnId } : {}),
+        });
+    }
     handleExecCommandStartedNotification(parsed) {
         if (parsed.callId) {
             this.emittedExecCommandStartedCallIds.add(parsed.callId);
@@ -3239,6 +3575,19 @@ class CodexAppServerAgentSession {
         if (parsed.source === "codex_event") {
             return;
         }
+        if (this.isContextCompactionItem(parsed.item)) {
+            if (this.unpairedCompactionNotificationCompletions > 0) {
+                this.unpairedCompactionNotificationCompletions -= 1;
+                return;
+            }
+            this.emitEvent({
+                type: "timeline",
+                provider: CODEX_PROVIDER,
+                item: this.createContextCompactionTimelineItem("completed", parsed.item.id),
+            });
+            this.unpairedCompactionItemCompletions += 1;
+            return;
+        }
         const timelineItem = threadItemToTimeline(parsed.item, {
             includeUserMessage: false,
             cwd: this.config.cwd ?? null,
@@ -3320,7 +3669,13 @@ class CodexAppServerAgentSession {
         this.emitEvent({
             type: "timeline",
             provider: CODEX_PROVIDER,
-            item: { type: timelineItem.type, text: suffix },
+            item: timelineItem.type === "assistant_message"
+                ? {
+                    type: timelineItem.type,
+                    text: suffix,
+                    ...(timelineItem.messageId ? { messageId: timelineItem.messageId } : {}),
+                }
+                : { type: timelineItem.type, text: suffix },
         });
     }
     applyBufferedDeltaTextToTimelineItem(timelineItem, itemId) {
@@ -3345,6 +3700,14 @@ class CodexAppServerAgentSession {
         if (parsed.source === "codex_event") {
             return;
         }
+        if (this.isContextCompactionItem(parsed.item)) {
+            this.emitEvent({
+                type: "timeline",
+                provider: CODEX_PROVIDER,
+                item: this.createContextCompactionTimelineItem("loading", parsed.item.id),
+            });
+            return;
+        }
         const timelineItem = threadItemToTimeline(parsed.item, {
             includeUserMessage: false,
             cwd: this.config.cwd ?? null,
@@ -3385,7 +3748,14 @@ class CodexAppServerAgentSession {
             return;
         }
         this.warnedUnknownNotificationMethods.add(method);
-        this.logger.trace({ method, params }, "Unhandled Codex app-server notification method");
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: CODEX_PROVIDER,
+            sessionId: this.currentThreadId,
+            turnId: this.activeForegroundTurnId ?? undefined,
+            method,
+            params,
+        }, "provider.codex.event_unhandled");
     }
     warnInvalidNotificationPayload(method, params) {
         const key = method;
@@ -3617,6 +3987,13 @@ export class CodexAppServerAgentClient {
         this.provider = CODEX_PROVIDER;
         this.capabilities = CODEX_APP_SERVER_CAPABILITIES;
         this.goalsEnabledPromise = null;
+        this.autoReviewEnabledPromise = null;
+    }
+    sessionDeps() {
+        return {
+            ...this.deps,
+            customCodexConfig: buildCodexCustomProviderConfig(this.runtimeSettings, this.deps.customProvider),
+        };
     }
     resolveGoalsEnabled() {
         if (!this.goalsEnabledPromise) {
@@ -3625,7 +4002,11 @@ export class CodexAppServerAgentClient {
                     const launchPrefix = await resolveCodexLaunchPrefix(this.runtimeSettings);
                     const versionOutput = await resolveBinaryVersion(launchPrefix.command);
                     const enabled = codexVersionAtLeast(versionOutput, CODEX_GOALS_MIN_VERSION);
-                    this.logger.trace({ versionOutput, enabled }, "Resolved codex goals feature gate");
+                    this.logger.trace({
+                        provider: CODEX_PROVIDER,
+                        versionOutput,
+                        enabled,
+                    }, "provider.codex.config.goals_resolved");
                     return enabled;
                 }
                 catch (error) {
@@ -3636,6 +4017,28 @@ export class CodexAppServerAgentClient {
         }
         return this.goalsEnabledPromise;
     }
+    resolveAutoReviewEnabled() {
+        if (!this.autoReviewEnabledPromise) {
+            this.autoReviewEnabledPromise = (async () => {
+                try {
+                    const launchPrefix = await resolveCodexLaunchPrefix(this.runtimeSettings);
+                    const versionOutput = await resolveBinaryVersion(launchPrefix.command);
+                    const enabled = codexVersionAtLeast(versionOutput, CODEX_AUTO_REVIEW_MIN_VERSION);
+                    this.logger.trace({
+                        provider: CODEX_PROVIDER,
+                        versionOutput,
+                        enabled,
+                    }, "provider.codex.config.auto_review_resolved");
+                    return enabled;
+                }
+                catch (error) {
+                    this.logger.warn({ err: error }, "Failed to probe codex version for auto-review gate");
+                    return false;
+                }
+            })();
+        }
+        return this.autoReviewEnabledPromise;
+    }
     async spawnAppServer(launchEnv, options) {
         const launchPrefix = await resolveCodexLaunchPrefix(this.runtimeSettings);
         const args = [...launchPrefix.args, "app-server"];
@@ -3643,9 +4046,11 @@ export class CodexAppServerAgentClient {
             args.push("--enable", "goals");
         }
         this.logger.trace({
+            agentId: options?.agentId,
+            provider: CODEX_PROVIDER,
             launchPrefix,
             goalsEnabled: options?.goalsEnabled === true,
-        }, "Spawning Codex app server");
+        }, "provider.codex.spawn");
         const child = spawnProcess(launchPrefix.command, args, {
             detached: process.platform !== "win32",
             stdio: ["pipe", "pipe", "pipe"],
@@ -3665,7 +4070,8 @@ export class CodexAppServerAgentClient {
         }
         const sessionConfig = { ...config, provider: CODEX_PROVIDER };
         const goalsEnabled = await this.resolveGoalsEnabled();
-        const session = new CodexAppServerAgentSession(sessionConfig, null, this.logger, () => this.spawnAppServer(launchContext?.env, { goalsEnabled }), this.deps, options?.persistSession === false, goalsEnabled);
+        const autoReviewEnabled = await this.resolveAutoReviewEnabled();
+        const session = new CodexAppServerAgentSession(sessionConfig, null, this.logger, () => this.spawnAppServer(launchContext?.env, { goalsEnabled, agentId: launchContext?.agentId }), this.sessionDeps(), options?.persistSession === false, goalsEnabled, autoReviewEnabled, launchContext?.agentId);
         await session.connect();
         return session;
     }
@@ -3678,13 +4084,14 @@ export class CodexAppServerAgentClient {
             cwd: overrides?.cwd ?? storedConfig.cwd ?? process.cwd(),
         };
         const goalsEnabled = await this.resolveGoalsEnabled();
-        const session = new CodexAppServerAgentSession(merged, handle, this.logger, () => this.spawnAppServer(launchContext?.env, { goalsEnabled }), this.deps, false, goalsEnabled);
+        const autoReviewEnabled = await this.resolveAutoReviewEnabled();
+        const session = new CodexAppServerAgentSession(merged, handle, this.logger, () => this.spawnAppServer(launchContext?.env, { goalsEnabled, agentId: launchContext?.agentId }), this.sessionDeps(), false, goalsEnabled, autoReviewEnabled, launchContext?.agentId);
         await session.connect();
         return session;
     }
     async listPersistedAgents(options) {
         const child = await this.spawnAppServer();
-        const client = this.deps._createCodexClient?.(child, this.logger) ??
+        const client = this.deps._createCodexClient?.(child, this.logger, () => ({})) ??
             new CodexAppServerClient(child, this.logger);
         try {
             await client.request("initialize", buildCodexAppServerInitializeParams());
@@ -3734,7 +4141,7 @@ export class CodexAppServerAgentClient {
                             threadId,
                         },
                     },
-                    timeline,
+                    timeline: timeline.map((entry) => entry.item),
                 };
             }));
             return descriptors;