@junctionpanel/server 0.1.41 → 0.1.43

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

@@ -11,6 +11,7 @@ import { buildCodexRuntimeExtra, DEFAULT_CODEX_MODE_ID, isCodexPlanModeEnabled,
 import { writeImageAttachment } from "./image-attachments.js";
 const DEFAULT_TIMEOUT_MS = 14 * 24 * 60 * 60 * 1000;
 const TURN_START_TIMEOUT_MS = 90 * 1000;
+const TURN_COMPLETION_SETTLE_DELAY_MS = 75;
 const CODEX_PROVIDER = "codex";
 const CODEX_APP_SERVER_CAPABILITIES = {
     supportsStreaming: true,
@@ -695,6 +696,60 @@ function formatProposedPlanChunk(text, options) {
     }
     return parts.join("");
 }
+function buildCompletedCodexTimelineItem(item, options) {
+    const timelineItem = threadItemToTimeline(item, {
+        includeUserMessage: false,
+        cwd: options.cwd ?? null,
+    });
+    if (!timelineItem) {
+        return null;
+    }
+    const normalizedItemType = normalizeCodexThreadItemType(typeof item.type === "string" ? item.type : undefined);
+    const itemId = item.id;
+    if (timelineItem.type === "tool_call" && normalizedItemType === "commandExecution") {
+        const callId = timelineItem.callId || itemId;
+        if (callId && options.state.emittedExecCommandCompletedCallIds.has(callId)) {
+            return null;
+        }
+    }
+    if (itemId && options.state.emittedItemCompletedIds.has(itemId)) {
+        return null;
+    }
+    if (timelineItem.type === "assistant_message" && itemId) {
+        const buffered = options.state.pendingAgentMessages.get(itemId);
+        if (buffered && buffered.length > 0) {
+            timelineItem.text = buffered;
+        }
+    }
+    if (timelineItem.type === "assistant_message" && normalizedItemType === "plan" && itemId) {
+        const bufferedPlanText = options.state.pendingPlanTexts.get(itemId) ?? "";
+        const finalPlanText = typeof item.text === "string" ? item.text : "";
+        if (bufferedPlanText.length > 0) {
+            const trailingText = finalPlanText.startsWith(bufferedPlanText)
+                ? finalPlanText.slice(bufferedPlanText.length)
+                : "";
+            timelineItem.text = formatProposedPlanChunk(trailingText, {
+                close: true,
+            });
+        }
+        else if (finalPlanText.trim().length > 0) {
+            timelineItem.text = formatProposedPlanBlock(finalPlanText);
+        }
+    }
+    if (timelineItem.type === "reasoning" && itemId) {
+        const buffered = options.state.pendingReasoning.get(itemId);
+        if (buffered && buffered.length > 0) {
+            timelineItem.text = buffered.join("");
+        }
+    }
+    if (itemId) {
+        options.state.emittedItemCompletedIds.add(itemId);
+        options.state.pendingAgentMessages.delete(itemId);
+        options.state.pendingReasoning.delete(itemId);
+        options.state.pendingPlanTexts.delete(itemId);
+    }
+    return timelineItem;
+}
 function planStepsToTodoItems(steps) {
     return steps.map((entry) => ({
         text: entry.step,
@@ -1492,6 +1547,8 @@ export const __codexAppServerInternals = {
     shouldRetryInitializeWithoutExperimentalApi,
     shouldRetryTurnStartWithoutCollaborationMode,
     formatProposedPlanBlock,
+    formatProposedPlanChunk,
+    buildCompletedCodexTimelineItem,
     normalizeCodexQuestionDescriptors,
     parseUpdatedQuestionAnswers,
     buildCodexPermissionsResponse,
@@ -1536,6 +1593,8 @@ class CodexAppServerAgentSession {
         this.nativePlanModeSupported = null;
         this.pendingPlanTexts = new Map();
         this.cachedSkills = [];
+        this.turnCompletionInFlight = false;
+        this.deferredTurnCompletion = null;
         this.logger = logger.child({ module: "agent", provider: CODEX_PROVIDER });
         if (config.modeId === undefined) {
             throw new Error("Codex agent requires modeId to be specified");
@@ -2058,6 +2117,7 @@ class CodexAppServerAgentSession {
                         ? "cancel"
                         : "decline");
             pending.resolve({ decision });
+            this.scheduleDeferredTurnCompletionAfterPermissionResponse();
             return;
         }
         if (pending.kind === "file") {
@@ -2068,14 +2128,17 @@ class CodexAppServerAgentSession {
                         ? "cancel"
                         : "decline");
             pending.resolve({ decision });
+            this.scheduleDeferredTurnCompletionAfterPermissionResponse();
             return;
         }
         if (pending.kind === "permissions") {
             pending.resolve(buildCodexPermissionsResponse(response, pending.permissions));
+            this.scheduleDeferredTurnCompletionAfterPermissionResponse();
             return;
         }
         if (pending.kind === "elicitation") {
             pending.resolve(buildCodexElicitationResponse(response));
+            this.scheduleDeferredTurnCompletionAfterPermissionResponse();
             return;
         }
         // tool/requestUserInput
@@ -2104,6 +2167,7 @@ class CodexAppServerAgentSession {
             answers["default"] = { answers: fallbackAnswers && fallbackAnswers.length > 0 ? fallbackAnswers : [decision] };
         }
         pending.resolve({ answers });
+        this.scheduleDeferredTurnCompletionAfterPermissionResponse();
     }
     describePersistence() {
         if (!this.currentThreadId)
@@ -2147,6 +2211,7 @@ class CodexAppServerAgentSession {
         this.pendingPermissionHandlers.clear();
         this.pendingPermissions.clear();
         this.resolvedPermissionRequests.clear();
+        this.clearDeferredTurnCompletion();
         this.eventQueue?.end();
         this.eventQueue = null;
         if (this.client) {
@@ -2269,12 +2334,248 @@ class CodexAppServerAgentSession {
         return await codexAppServerTurnInputFromPrompt(blocks, this.logger);
     }
     emitEvent(event) {
-        if (event.type === "timeline") {
-            if (event.item.type === "assistant_message") {
-                this.pendingAgentMessages.clear();
+        this.eventQueue?.push(event);
+    }
+    hasOutstandingPermissionRequests() {
+        return this.pendingPermissionHandlers.size > 0;
+    }
+    clearDeferredTurnCompletion() {
+        if (this.deferredTurnCompletion?.timer) {
+            clearTimeout(this.deferredTurnCompletion.timer);
+        }
+        this.deferredTurnCompletion = null;
+    }
+    scheduleDeferredTurnCompletion(parsed, options) {
+        const waitingOnPermission = options?.waitingOnPermission ??
+            this.deferredTurnCompletion?.waitingOnPermission ??
+            this.hasOutstandingPermissionRequests();
+        this.clearDeferredTurnCompletion();
+        this.turnCompletionInFlight = true;
+        const deferred = {
+            parsed,
+            turnId: this.currentTurnId,
+            waitingOnPermission,
+            timer: null,
+        };
+        deferred.timer = setTimeout(() => {
+            void this.flushDeferredTurnCompletion(deferred.turnId);
+        }, TURN_COMPLETION_SETTLE_DELAY_MS);
+        this.deferredTurnCompletion = deferred;
+    }
+    markDeferredTurnCompletionAwaitingPermissions() {
+        if (!this.deferredTurnCompletion) {
+            return;
+        }
+        this.scheduleDeferredTurnCompletion(this.deferredTurnCompletion.parsed, {
+            waitingOnPermission: true,
+        });
+    }
+    discardDeferredTurnCompletion(reason) {
+        const deferred = this.deferredTurnCompletion;
+        if (!deferred) {
+            return;
+        }
+        this.logger.trace({
+            reason,
+            threadId: this.currentThreadId,
+            turnId: deferred.turnId,
+        }, "Discarding deferred Codex turn completion after resumed activity");
+        this.clearDeferredTurnCompletion();
+        this.turnCompletionInFlight = false;
+    }
+    noteTurnActivityAfterPermission(activity) {
+        const deferred = this.deferredTurnCompletion;
+        if (!deferred || !deferred.waitingOnPermission || this.hasOutstandingPermissionRequests()) {
+            return;
+        }
+        this.discardDeferredTurnCompletion(activity);
+    }
+    async flushDeferredTurnCompletion(turnId) {
+        const deferred = this.deferredTurnCompletion;
+        if (!deferred || deferred.turnId !== turnId) {
+            return;
+        }
+        if (this.hasOutstandingPermissionRequests()) {
+            this.scheduleDeferredTurnCompletion(deferred.parsed, {
+                waitingOnPermission: true,
+            });
+            return;
+        }
+        this.clearDeferredTurnCompletion();
+        await this.finalizeTurnCompletion(deferred.parsed);
+    }
+    scheduleDeferredTurnCompletionAfterPermissionResponse() {
+        if (!this.deferredTurnCompletion || this.hasOutstandingPermissionRequests()) {
+            return;
+        }
+        this.scheduleDeferredTurnCompletion(this.deferredTurnCompletion.parsed, {
+            waitingOnPermission: true,
+        });
+    }
+    clearTurnState() {
+        this.clearDeferredTurnCompletion();
+        this.currentTurnId = null;
+        this.emittedItemStartedIds.clear();
+        this.emittedItemCompletedIds.clear();
+        this.emittedExecCommandStartedCallIds.clear();
+        this.emittedExecCommandCompletedCallIds.clear();
+        this.pendingAgentMessages.clear();
+        this.pendingReasoning.clear();
+        this.pendingCommandOutputDeltas.clear();
+        this.pendingFileChangeOutputDeltas.clear();
+        this.pendingPlanTexts.clear();
+        this.warnedIncompleteEditToolCallIds.clear();
+        this.turnCompletionInFlight = false;
+    }
+    hasPendingBufferedCompletionContent() {
+        return (this.pendingAgentMessages.size > 0 ||
+            this.pendingReasoning.size > 0 ||
+            this.pendingPlanTexts.size > 0);
+    }
+    emitCompletedThreadItem(item, source) {
+        const timelineItem = buildCompletedCodexTimelineItem(item, {
+            cwd: this.config.cwd ?? null,
+            state: {
+                pendingAgentMessages: this.pendingAgentMessages,
+                pendingReasoning: this.pendingReasoning,
+                pendingPlanTexts: this.pendingPlanTexts,
+                emittedExecCommandCompletedCallIds: this.emittedExecCommandCompletedCallIds,
+                emittedItemCompletedIds: this.emittedItemCompletedIds,
+            },
+        });
+        if (!timelineItem) {
+            return false;
+        }
+        const itemId = item.id;
+        if (timelineItem.type === "tool_call") {
+            this.warnOnIncompleteEditToolCall(timelineItem, source, item);
+        }
+        this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+        if (itemId) {
+            this.emittedItemStartedIds.delete(itemId);
+            this.pendingCommandOutputDeltas.delete(itemId);
+            this.pendingFileChangeOutputDeltas.delete(itemId);
+        }
+        return true;
+    }
+    async reconcileTurnCompletionFromThreadRead() {
+        if (!this.client || !this.currentThreadId) {
+            return 0;
+        }
+        const response = (await this.client.request("thread/read", {
+            threadId: this.currentThreadId,
+            includeTurns: true,
+        }));
+        const turns = Array.isArray(response?.thread?.turns) ? response.thread.turns : [];
+        const lastTurn = turns[turns.length - 1];
+        const items = Array.isArray(lastTurn?.items) ? lastTurn.items : [];
+        let emitted = 0;
+        for (const item of items) {
+            if (this.emitCompletedThreadItem(item, "thread_read_completion")) {
+                emitted += 1;
+            }
+        }
+        return emitted;
+    }
+    flushPendingCompletionFallback() {
+        let emitted = 0;
+        for (const [itemId, chunks] of Array.from(this.pendingReasoning.entries())) {
+            const text = chunks.join("");
+            if (text.length === 0) {
+                this.pendingReasoning.delete(itemId);
+                continue;
             }
+            this.emitEvent({
+                type: "timeline",
+                provider: CODEX_PROVIDER,
+                item: { type: "reasoning", text },
+            });
+            this.emittedItemCompletedIds.add(itemId);
+            this.pendingReasoning.delete(itemId);
+            emitted += 1;
+        }
+        for (const [itemId, text] of Array.from(this.pendingAgentMessages.entries())) {
+            if (text.length === 0) {
+                this.pendingAgentMessages.delete(itemId);
+                continue;
+            }
+            this.emitEvent({
+                type: "timeline",
+                provider: CODEX_PROVIDER,
+                item: { type: "assistant_message", text },
+            });
+            this.emittedItemCompletedIds.add(itemId);
+            this.pendingAgentMessages.delete(itemId);
+            emitted += 1;
+        }
+        for (const [itemId, text] of Array.from(this.pendingPlanTexts.entries())) {
+            if (text.trim().length === 0) {
+                this.pendingPlanTexts.delete(itemId);
+                continue;
+            }
+            this.emitEvent({
+                type: "timeline",
+                provider: CODEX_PROVIDER,
+                item: {
+                    type: "assistant_message",
+                    text: formatProposedPlanChunk("", { close: true }),
+                },
+            });
+            this.emittedItemCompletedIds.add(itemId);
+            this.pendingPlanTexts.delete(itemId);
+            emitted += 1;
+        }
+        return emitted;
+    }
+    emitTerminalTurnEvent(parsed) {
+        if (parsed.status === "failed") {
+            this.emitEvent({
+                type: "turn_failed",
+                provider: CODEX_PROVIDER,
+                error: parsed.errorMessage ?? "Codex turn failed",
+            });
+            return;
+        }
+        if (parsed.status === "interrupted") {
+            this.emitEvent({ type: "turn_canceled", provider: CODEX_PROVIDER, reason: "interrupted" });
+            return;
+        }
+        this.emitEvent({ type: "turn_completed", provider: CODEX_PROVIDER, usage: this.latestUsage });
+    }
+    async finalizeTurnCompletion(parsed) {
+        let terminalEventEmitted = false;
+        try {
+            if (parsed.status === "completed" && this.hasPendingBufferedCompletionContent()) {
+                this.logger.trace({
+                    pendingAgentMessages: this.pendingAgentMessages.size,
+                    pendingReasoning: this.pendingReasoning.size,
+                    pendingPlanTexts: this.pendingPlanTexts.size,
+                    threadId: this.currentThreadId,
+                    turnId: this.currentTurnId,
+                }, "Codex turn completed with buffered items still pending; reconciling before closing stream");
+                try {
+                    const emitted = await this.reconcileTurnCompletionFromThreadRead();
+                    this.logger.trace({ emitted, threadId: this.currentThreadId, turnId: this.currentTurnId }, "Reconciled Codex turn completion from thread/read");
+                }
+                catch (error) {
+                    this.logger.warn({ error, threadId: this.currentThreadId, turnId: this.currentTurnId }, "Failed to reconcile Codex turn completion from thread/read");
+                }
+                const fallbackEmitted = this.flushPendingCompletionFallback();
+                if (fallbackEmitted > 0) {
+                    this.logger.warn({ fallbackEmitted, threadId: this.currentThreadId, turnId: this.currentTurnId }, "Flushed buffered Codex completion items without canonical item/completed notifications");
+                }
+            }
+            this.emitTerminalTurnEvent(parsed);
+            terminalEventEmitted = true;
+        }
+        finally {
+            if (!terminalEventEmitted) {
+                this.logger.warn({ status: parsed.status, threadId: this.currentThreadId, turnId: this.currentTurnId }, "Codex turn completion exited before emitting a terminal event; emitting fallback terminal event");
+                this.emitTerminalTurnEvent(parsed);
+            }
+            this.clearTurnState();
+            this.eventQueue?.end();
         }
-        this.eventQueue?.push(event);
     }
     handleNotification(method, params) {
         const parsed = CodexNotificationSchema.parse({ method, params });
@@ -2284,43 +2585,38 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "turn_started") {
+            this.clearTurnState();
             this.currentTurnId = parsed.turnId;
-            this.emittedItemStartedIds.clear();
-            this.emittedItemCompletedIds.clear();
-            this.emittedExecCommandStartedCallIds.clear();
-            this.emittedExecCommandCompletedCallIds.clear();
-            this.pendingCommandOutputDeltas.clear();
-            this.pendingFileChangeOutputDeltas.clear();
-            this.warnedIncompleteEditToolCallIds.clear();
             this.emitEvent({ type: "turn_started", provider: CODEX_PROVIDER });
             return;
         }
         if (parsed.kind === "turn_completed") {
-            if (parsed.status === "failed") {
-                this.emitEvent({
-                    type: "turn_failed",
-                    provider: CODEX_PROVIDER,
-                    error: parsed.errorMessage ?? "Codex turn failed",
-                });
+            // A later failed/interrupted terminal status must replace a deferred
+            // "completed" status so we do not hide a real terminal error behind
+            // the settle window.
+            if (this.turnCompletionInFlight) {
+                if (parsed.status === "completed") {
+                    this.scheduleDeferredTurnCompletion(parsed);
+                    return;
+                }
+                if (this.deferredTurnCompletion) {
+                    this.clearDeferredTurnCompletion();
+                    this.turnCompletionInFlight = false;
+                }
+                else {
+                    return;
+                }
             }
-            else if (parsed.status === "interrupted") {
-                this.emitEvent({ type: "turn_canceled", provider: CODEX_PROVIDER, reason: "interrupted" });
+            if (parsed.status === "completed") {
+                this.scheduleDeferredTurnCompletion(parsed);
+                return;
             }
-            else {
-                this.emitEvent({ type: "turn_completed", provider: CODEX_PROVIDER, usage: this.latestUsage });
-            }
-            this.emittedItemStartedIds.clear();
-            this.emittedItemCompletedIds.clear();
-            this.emittedExecCommandStartedCallIds.clear();
-            this.emittedExecCommandCompletedCallIds.clear();
-            this.pendingCommandOutputDeltas.clear();
-            this.pendingFileChangeOutputDeltas.clear();
-            this.pendingPlanTexts.clear();
-            this.warnedIncompleteEditToolCallIds.clear();
-            this.eventQueue?.end();
+            this.turnCompletionInFlight = true;
+            void this.finalizeTurnCompletion(parsed);
             return;
         }
         if (parsed.kind === "plan_updated") {
+            this.noteTurnActivityAfterPermission("plan_updated");
             const items = planStepsToTodoItems(parsed.plan.map((entry) => ({
                 step: entry.step ?? "",
                 status: entry.status ?? "pending",
@@ -2333,6 +2629,7 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "plan_delta") {
+            this.noteTurnActivityAfterPermission("plan_delta");
             const previous = this.pendingPlanTexts.get(parsed.itemId) ?? "";
             const next = previous + parsed.delta;
             this.pendingPlanTexts.set(parsed.itemId, next);
@@ -2374,25 +2671,30 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "agent_message_delta") {
+            this.noteTurnActivityAfterPermission("agent_message_delta");
             const prev = this.pendingAgentMessages.get(parsed.itemId) ?? "";
             this.pendingAgentMessages.set(parsed.itemId, prev + parsed.delta);
             return;
         }
         if (parsed.kind === "reasoning_delta") {
+            this.noteTurnActivityAfterPermission("reasoning_delta");
             const prev = this.pendingReasoning.get(parsed.itemId) ?? [];
             prev.push(parsed.delta);
             this.pendingReasoning.set(parsed.itemId, prev);
             return;
         }
         if (parsed.kind === "exec_command_output_delta") {
+            this.noteTurnActivityAfterPermission("exec_command_output_delta");
             this.appendOutputDeltaChunk(this.pendingCommandOutputDeltas, parsed.callId, parsed.chunk, { decodeBase64: true });
             return;
         }
         if (parsed.kind === "file_change_output_delta") {
+            this.noteTurnActivityAfterPermission("file_change_output_delta");
             this.appendOutputDeltaChunk(this.pendingFileChangeOutputDeltas, parsed.itemId, parsed.delta);
             return;
         }
         if (parsed.kind === "exec_command_started") {
+            this.noteTurnActivityAfterPermission("exec_command_started");
             if (parsed.callId) {
                 this.emittedExecCommandStartedCallIds.add(parsed.callId);
                 this.pendingCommandOutputDeltas.delete(parsed.callId);
@@ -2409,6 +2711,7 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "exec_command_completed") {
+            this.noteTurnActivityAfterPermission("exec_command_completed");
             const bufferedOutput = this.consumeOutputDelta(this.pendingCommandOutputDeltas, parsed.callId);
             const timelineItem = mapCodexExecNotificationToToolCall({
                 callId: parsed.callId,
@@ -2427,6 +2730,7 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "patch_apply_started") {
+            this.noteTurnActivityAfterPermission("patch_apply_started");
             if (parsed.callId) {
                 this.pendingFileChangeOutputDeltas.delete(parsed.callId);
             }
@@ -2446,6 +2750,7 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "patch_apply_completed") {
+            this.noteTurnActivityAfterPermission("patch_apply_completed");
             const bufferedOutput = this.consumeOutputDelta(this.pendingFileChangeOutputDeltas, parsed.callId);
             const timelineItem = mapCodexPatchNotificationToToolCall({
                 callId: parsed.callId,
@@ -2467,76 +2772,18 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "item_completed") {
+            this.noteTurnActivityAfterPermission("item_completed");
             // Codex emits mirrored lifecycle notifications via both `codex/event/item_*`
             // and canonical `item/*`. We render only the canonical channel to avoid
             // duplicated assistant/reasoning rows.
             if (parsed.source === "codex_event") {
                 return;
             }
-            const timelineItem = threadItemToTimeline(parsed.item, {
-                includeUserMessage: false,
-                cwd: this.config.cwd ?? null,
-            });
-            if (timelineItem) {
-                const normalizedItemType = normalizeCodexThreadItemType(typeof parsed.item.type === "string" ? parsed.item.type : undefined);
-                const itemId = parsed.item.id;
-                // For commandExecution items, codex/event/exec_command_* is authoritative.
-                // Keep item/completed as fallback only when no exec_command completion was seen.
-                if (timelineItem.type === "tool_call" &&
-                    normalizedItemType === "commandExecution") {
-                    const callId = timelineItem.callId || itemId;
-                    if (callId && this.emittedExecCommandCompletedCallIds.has(callId)) {
-                        return;
-                    }
-                }
-                if (itemId && this.emittedItemCompletedIds.has(itemId)) {
-                    return;
-                }
-                if (timelineItem.type === "assistant_message" && itemId) {
-                    const buffered = this.pendingAgentMessages.get(itemId);
-                    if (buffered && buffered.length > 0) {
-                        timelineItem.text = buffered;
-                    }
-                }
-                if (timelineItem.type === "assistant_message" &&
-                    normalizedItemType === "plan" &&
-                    itemId) {
-                    const bufferedPlanText = this.pendingPlanTexts.get(itemId) ?? "";
-                    const finalPlanText = typeof parsed.item.text === "string" ? parsed.item.text : "";
-                    if (bufferedPlanText.length > 0) {
-                        const trailingText = finalPlanText.startsWith(bufferedPlanText)
-                            ? finalPlanText.slice(bufferedPlanText.length)
-                            : "";
-                        timelineItem.text = formatProposedPlanChunk(trailingText, {
-                            close: true,
-                        });
-                        this.pendingPlanTexts.delete(itemId);
-                    }
-                    else if (finalPlanText.trim().length > 0) {
-                        timelineItem.text = formatProposedPlanBlock(finalPlanText);
-                    }
-                }
-                if (timelineItem.type === "reasoning" && itemId) {
-                    const buffered = this.pendingReasoning.get(itemId);
-                    if (buffered && buffered.length > 0) {
-                        timelineItem.text = buffered.join("");
-                    }
-                }
-                if (timelineItem.type === "tool_call") {
-                    this.warnOnIncompleteEditToolCall(timelineItem, "item_completed", parsed.item);
-                }
-                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
-                if (itemId) {
-                    this.emittedItemCompletedIds.add(itemId);
-                    this.emittedItemStartedIds.delete(itemId);
-                    this.pendingCommandOutputDeltas.delete(itemId);
-                    this.pendingFileChangeOutputDeltas.delete(itemId);
-                    this.pendingPlanTexts.delete(itemId);
-                }
-            }
+            this.emitCompletedThreadItem(parsed.item, "item_completed");
             return;
         }
         if (parsed.kind === "item_started") {
+            this.noteTurnActivityAfterPermission("item_started");
             if (parsed.source === "codex_event") {
                 return;
             }
@@ -2642,6 +2889,7 @@ class CodexAppServerAgentSession {
             : parsed.networkApprovalContext
                 ? "Allow network access"
                 : "Run command";
+        this.markDeferredTurnCompletionAwaitingPermissions();
         const request = {
             id: requestId,
             provider: CODEX_PROVIDER,
@@ -2685,6 +2933,7 @@ class CodexAppServerAgentSession {
     handleFileChangeApprovalRequest(requestMethod, params, rawRequestId) {
         const parsed = params;
         const requestId = toPendingPermissionId(rawRequestId ?? parsed.itemId);
+        this.markDeferredTurnCompletionAwaitingPermissions();
         const request = {
             id: requestId,
             provider: CODEX_PROVIDER,
@@ -2718,6 +2967,7 @@ class CodexAppServerAgentSession {
         const parsed = params;
         const requestId = toPendingPermissionId(rawRequestId ?? parsed.itemId);
         const questions = normalizeCodexQuestionDescriptors(parsed.questions);
+        this.markDeferredTurnCompletionAwaitingPermissions();
         const request = {
             id: requestId,
             provider: CODEX_PROVIDER,
@@ -2756,6 +3006,7 @@ class CodexAppServerAgentSession {
     handlePermissionsApprovalRequest(requestMethod, params, rawRequestId) {
         const parsed = params;
         const requestId = toPendingPermissionId(rawRequestId ?? parsed.itemId);
+        this.markDeferredTurnCompletionAwaitingPermissions();
         const request = {
             id: requestId,
             provider: CODEX_PROVIDER,
@@ -2803,6 +3054,7 @@ class CodexAppServerAgentSession {
             : parsed.serverName
                 ? `Respond to ${parsed.serverName}`
                 : "Respond to MCP server";
+        this.markDeferredTurnCompletionAwaitingPermissions();
         const request = {
             id: requestId,
             provider: CODEX_PROVIDER,
@@ -2852,6 +3104,12 @@ class CodexAppServerAgentSession {
         });
     }
 }
+Object.assign(__codexAppServerInternals, {
+    TURN_COMPLETION_SETTLE_DELAY_MS,
+    createTestSession(config, resumeHandle, logger, spawnAppServer) {
+        return new CodexAppServerAgentSession(config, resumeHandle, logger, spawnAppServer);
+    },
+});
 export class CodexAppServerAgentClient {
     constructor(logger, runtimeSettings) {
         this.logger = logger;