@getpaseo/server 0.1.75 → 0.1.77

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

@@ -11,11 +11,13 @@ import { curateAgentActivity } from "../activity-curator.js";
 import { mapCodexRolloutToolCall, mapCodexToolCallFromThreadItem, } from "./codex/tool-call-mapper.js";
 import { createProviderEnv, createProviderEnvSpec, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
 import { findExecutable, isCommandAvailable } from "../../../utils/executable.js";
+import { createPathEquivalenceMatcher } from "../../../utils/path.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 { 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) {
@@ -38,11 +40,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)
@@ -91,6 +95,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",
@@ -107,12 +116,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(", ");
@@ -484,7 +511,8 @@ function filterCodexThreadsByCwd(threads, cwd) {
     // falls back to process.cwd() if the field is missing, so we only match
     // here when the row genuinely carries a cwd string — otherwise threads
     // with no cwd would falsely match the daemon's own cwd.
-    return threads.filter((thread) => typeof thread.cwd === "string" && thread.cwd === cwd);
+    const matchesCwd = createPathEquivalenceMatcher(cwd);
+    return threads.filter((thread) => typeof thread.cwd === "string" && matchesCwd(thread.cwd));
 }
 function toAgentUsage(tokenUsage) {
     const usage = toObjectRecord(tokenUsage);
@@ -1070,6 +1098,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();
@@ -1139,15 +1190,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;
     }
@@ -1179,7 +1238,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,
+                });
             }
         }
     }
@@ -1296,6 +1359,12 @@ const ItemLifecycleNotificationSchema = z
         .passthrough(),
 })
     .passthrough();
+const ContextCompactedNotificationSchema = z
+    .object({
+    threadId: z.string(),
+    turnId: z.string().optional(),
+})
+    .passthrough();
 const CodexEventTurnAbortedNotificationSchema = z
     .object({
     msg: z
@@ -1511,6 +1580,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"),
@@ -1952,12 +2033,13 @@ function buildCodexCustomProviderConfig(runtimeSettings, customProvider) {
     };
 }
 class CodexAppServerAgentSession {
-    constructor(config, resumeHandle, logger, spawnAppServer, deps = {}, ephemeral = false, goalsEnabled = false, agentId) {
+    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;
@@ -1993,6 +2075,12 @@ 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;
@@ -2009,7 +2097,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) {
@@ -2094,7 +2182,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 : [];
@@ -2102,14 +2190,16 @@ 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({
@@ -2330,56 +2420,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;
@@ -2391,6 +2443,7 @@ class CodexAppServerAgentSession {
                 ? this.config.networkAccess
                 : preset.networkAccess),
         };
+        applyApprovalsReviewerParam(params, preset);
         if (this.config.model) {
             params.model = this.config.model;
         }
@@ -2420,10 +2473,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;
@@ -2444,8 +2568,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() {
@@ -2471,7 +2600,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;
@@ -2496,6 +2628,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;
         }
@@ -2700,7 +2835,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",
@@ -2711,12 +2852,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 {
@@ -2730,6 +2885,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";
@@ -2841,7 +3025,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,
@@ -2851,13 +3035,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() {
@@ -2932,6 +3127,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":
@@ -3085,6 +3283,7 @@ class CodexAppServerAgentSession {
             if (subAgentCallId) {
                 this.upsertSubAgentChildItem(subAgentCallId, parsed.itemId, {
                     type: "assistant_message",
+                    messageId: parsed.itemId,
                     text,
                 });
                 this.emitSubAgentActivityUpdate(subAgentCallId, "running");
@@ -3096,6 +3295,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,
@@ -3200,6 +3400,8 @@ class CodexAppServerAgentSession {
         this.pendingFileChangeOutputDeltas.clear();
         this.pendingAssistantMessageBoundary = false;
         this.warnedIncompleteEditToolCallIds.clear();
+        this.unpairedCompactionNotificationCompletions = 0;
+        this.unpairedCompactionItemCompletions = 0;
     }
     handlePlanUpdatedNotification(parsed) {
         const timelineItem = mapCodexPlanToToolCall({
@@ -3230,6 +3432,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);
@@ -3326,6 +3577,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,
@@ -3407,7 +3671,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) {
@@ -3432,6 +3702,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,
@@ -3711,6 +3989,7 @@ export class CodexAppServerAgentClient {
         this.provider = CODEX_PROVIDER;
         this.capabilities = CODEX_APP_SERVER_CAPABILITIES;
         this.goalsEnabledPromise = null;
+        this.autoReviewEnabledPromise = null;
     }
     sessionDeps() {
         return {
@@ -3740,6 +4019,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"];
@@ -3771,7 +4072,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, agentId: launchContext?.agentId }), this.sessionDeps(), options?.persistSession === false, goalsEnabled, launchContext?.agentId);
+        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;
     }
@@ -3784,7 +4086,8 @@ 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, agentId: launchContext?.agentId }), this.sessionDeps(), false, goalsEnabled, launchContext?.agentId);
+        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;
     }
@@ -3840,7 +4143,7 @@ export class CodexAppServerAgentClient {
                             threadId,
                         },
                     },
-                    timeline,
+                    timeline: timeline.map((entry) => entry.item),
                 };
             }));
             return descriptors;