fix: preserve ACP v1 prompt across goal continuations (#33)

Model: gpt-6

Author: Leeeon233

AGENTS.md

@@ -33,6 +33,12 @@
 
 ## Docs
 
+- ACP v1 prompt completion follows native Goal continuations across turn boundaries. Keep
+  the prompt and interaction handlers open until the goal stops and its last native turn
+  drains, or the turn fails/is cancelled. Never issue another `turn/start` after a routed
+  `/goal` turn; Codex owns continuation. Cancellation also pauses the goal before returning.
+- A persistent active goal does not create a prompt or live presence by itself. Goal metadata
+  remains a separate Core snapshot; do not add a private execution lifecycle protocol.
 - Codex app-server usage: see https://github.com/openai/codex/blob/main/codex-rs/app-server/README.md when touching protocol/transport details, adding or consuming JSON-RPC methods, handling approvals/turn events, or updating generated schema/clients.
 - App-server events: prefer `thread/*`, `turn/*`, and `item/*` event surfaces; avoid the deprecated `codex/event/*` API (planned removal). Keep implementations aligned with generated types in `src/app-server` (including `v2` exports).
 - Steer uses app-server `turn/steer` on the tracked active turn. Correlate `clientUserMessageId` and acknowledge only the matching `item/completed(userMessage)`; never emulate steer with a second `turn/start`.

docs/goal-extension.md

@@ -41,14 +41,16 @@ Common statuses are `active`, `paused`, `blocked`, `limited`, and `complete`. Op
 
 ## Lifecycle architecture
 
-A goal belongs to the ACP session, not to an individual `session/prompt` request. Goal activity and prompt activity are independent:
+A goal belongs to the ACP session. Its durable state is separate from the ACP v1 prompt lifecycle:
 
 - `status: active` means the persistent objective can drive more work; it does not mean an ACP prompt is currently executing.
-- A prompt completes when its current backend turn reaches a quiescent boundary, even when the goal remains active.
-- A later autonomous cycle may publish more session updates outside that completed prompt.
-- While a turn is running, clients use steering or prompt queueing when advertised. While the session is quiescent, clients may send an ordinary `session/prompt`.
+- Once a prompt is executing an active goal, it remains open across native Codex turn completions and automatic continuations. Codex schedules those continuations; the adapter does not submit duplicate turns.
+- The prompt returns only after the goal becomes complete, paused, blocked, limited, or cleared and the final native turn has drained. A failed or interrupted turn also ends the prompt. Goal completion before the last text chunk does not truncate that output.
+- `/goal set` (an objective) and `/goal resume` follow the same lifecycle. An explicit continuation prompt is needed only when the goal control operation started no native turn at all.
+- Cancellation pauses the goal before returning, including when cancelled between native turns. Connection loss fails the pending prompt.
+- While a prompt is open, clients use steering or prompt queueing when advertised. A stored active goal outside a prompt does not establish live presence.
 
-This separation prevents a persistent goal from monopolizing the session's prompt slot and lets clients model “working now” independently from “objective remains active.”
+This uses the standard ACP v1 request/response completion boundary: one prompt may contain multiple model exchanges. It requires no Core execution extension. A v2 implementation should use standard `state_update` notifications instead of treating prompt acceptance as completion.
 
 ## Codex mapping and compatibility
 

src/CodexAcpClient.ts

@@ -924,6 +924,12 @@ export class CodexAcpClient {
         }
     }
 
+    onConnectionClosed(callback: () => void): () => void {
+        const close = this.codexClient.connection.onClose(callback);
+        const dispose = this.codexClient.connection.onDispose(callback);
+        return () => { close.dispose(); dispose.dispose(); };
+    }
+
     private enqueueSessionNotification(sessionId: string, operation: () => void | Promise<void>): void {
         const run = async () => {
             try {

src/CodexAcpServer.ts

@@ -56,6 +56,7 @@ import {
 import type {TokenCount} from "./TokenCount";
 import {toPromptUsage} from "./TokenCount";
 import {CodexCommands, GOAL_CONTINUATION_PROMPT} from "./CodexCommands";
+import {GoalPromptLifecycle} from "./GoalPromptLifecycle";
 import {SteeringQueue} from "./SteeringQueue";
 import type {QuotaMeta} from "./QuotaMeta";
 import {logger} from "./Logger";
@@ -259,6 +260,7 @@ interface ActivePrompt {
     cancelSignal: Promise<null>;
     signal: AbortSignal;
     currentTurn: { threadId: string, turnId: string } | null;
+    hasCompletedTurn: boolean;
     requestCancel: () => void;
     requestClose: () => void;
     complete: () => void;
@@ -2771,6 +2773,7 @@ export class CodexAcpServer {
             cancelSignal,
             signal: abortController.signal,
             currentTurn: null,
+            hasCompletedTurn: false,
             requestCancel: () => {
                 if (abortController.signal.aborted) {
                     return;
@@ -3020,6 +3023,12 @@ export class CodexAcpServer {
         let recoverableSessionFailure = sessionState.sessionFailure;
         sessionState.currentTurnId = null;
         const activePrompt = this.trackActivePrompt(params.sessionId);
+        const goalLifecycle = new GoalPromptLifecycle(params.sessionId, sessionState.currentGoal?.status === "active");
+        const cancelGoalLifecycle = () => goalLifecycle.cancel();
+        activePrompt.signal.addEventListener("abort", cancelGoalLifecycle);
+        const disposeGoalConnection = this.codexAcpClient.onConnectionClosed(() => {
+            goalLifecycle.fail(new Error("Codex connection closed during goal continuation"));
+        });
         let pendingTurnStart: PendingTurnStart | null = null;
         const ensurePendingTurnStart = (): PendingTurnStart => {
             if (pendingTurnStart === null) {
@@ -3078,6 +3087,25 @@ export class CodexAcpServer {
             };
             await this.codexAcpClient.subscribeToSessionEvents(params.sessionId,
                 async (event) => {
+                    if (this.activePrompts.get(params.sessionId) === activePrompt) {
+                        goalLifecycle.observe(event);
+                        if (event.method === "turn/started" && event.params.threadId === params.sessionId) {
+                            const turn = {threadId: params.sessionId, turnId: event.params.turn.id};
+                            activePrompt.currentTurn = turn;
+                            if (this.promptShouldStop(params.sessionId, activePrompt)) {
+                                this.interruptLateStartedTurn(turn);
+                                return;
+                            }
+                            recoverableSessionFailure = sessionState.sessionFailure;
+                            promptNotificationsActive = true;
+                        }
+                        if (event.method === "turn/completed" &&
+                            event.params.threadId === params.sessionId &&
+                            activePrompt.currentTurn?.turnId === event.params.turn.id) {
+                            activePrompt.currentTurn = null;
+                            activePrompt.hasCompletedTurn = true;
+                        }
+                    }
                     await this.handleSteerAppliedNotification(params.sessionId, event, activePrompt);
                     await observeInteraction(event);
                     if (!promptNotificationsActive) {
@@ -3111,6 +3139,7 @@ export class CodexAcpServer {
                 },
                 onTurnStarted: (turnId, threadId) => {
                     const turn = {threadId, turnId};
+                    if (threadId === params.sessionId) goalLifecycle.startTurn(turnId);
                     activePrompt.currentTurn = turn;
                     if (this.promptShouldStop(params.sessionId, activePrompt)) {
                         this.interruptLateStartedTurn(turn);
@@ -3138,7 +3167,7 @@ export class CodexAcpServer {
                     logger.error(`Command for cancelled prompt ${params.sessionId} failed after prompt returned`, err);
                 }
             });
-            const commandResult = await Promise.race([
+            let commandResult = await Promise.race([
                 commandPromise,
                 activePrompt.closeSignal,
                 this.cancelBeforeTurnStarted(activePrompt),
@@ -3147,6 +3176,15 @@ export class CodexAcpServer {
                 return cancelledPromptResponse();
             }
             if (commandResult.handled) {
+                if (commandResult.turnCompleted) {
+                    await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+                    const firstCommandTurn = commandResult.turnCompleted;
+                    const completed = await this.runWithProcessCheck(() => Promise.race([
+                        goalLifecycle.waitForCompletion(firstCommandTurn), activePrompt.closeSignal,
+                    ]));
+                    if (completed === null) return cancelledPromptResponse();
+                    commandResult = {...commandResult, turnCompleted: completed};
+                }
                 promptNotificationsActive = false;
                 logger.log("Prompt handled by a command");
                 await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
@@ -3214,6 +3252,7 @@ export class CodexAcpServer {
             );
             sessionState.lastTokenUsage = null;
             ensurePendingTurnStart();
+            goalLifecycle.prepareTurn();
             const sendPromptPromise = this.runWithProcessCheck(
                 () => this.codexAcpClient.sendPrompt(
                     effectiveParams,
@@ -3225,6 +3264,11 @@ export class CodexAcpServer {
                     sessionState.additionalDirectories,
                     (turnId) => {
                         const turn = {threadId: params.sessionId, turnId};
+                        if (!goalLifecycle.startSubmittedTurn(turnId)) {
+                            pendingTurnStart?.resolve(turnId);
+                            onTurnStarted?.();
+                            return;
+                        }
                         activePrompt.currentTurn = turn;
                         if (this.promptShouldStop(params.sessionId, activePrompt)) {
                             this.interruptLateStartedTurn(turn);
@@ -3251,6 +3295,12 @@ export class CodexAcpServer {
                 return cancelledPromptResponse();
             }
 
+            await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+            const firstPromptTurn = turnCompleted;
+            turnCompleted = await this.runWithProcessCheck(() => Promise.race([
+                goalLifecycle.waitForCompletion(firstPromptTurn), activePrompt.closeSignal,
+            ]));
+            if (turnCompleted === null) return cancelledPromptResponse();
             await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
             if (turnCompleted.turn.status === "completed") {
                 await eventHandler.waitForNativeSubagents(activePrompt.signal);
@@ -3314,6 +3364,7 @@ export class CodexAcpServer {
                     };
                     activePrompt.currentTurn = null;
                     sessionState.currentTurnId = null;
+                    goalLifecycle.prepareTurn();
                     const implementationPromise = this.runWithProcessCheck(
                         () => this.codexAcpClient.sendPrompt(
                             implementationRequest,
@@ -3325,6 +3376,7 @@ export class CodexAcpServer {
                             sessionState.additionalDirectories,
                             (turnId) => {
                                 const turn = {threadId: params.sessionId, turnId};
+                                if (!goalLifecycle.startSubmittedTurn(turnId)) return;
                                 activePrompt.currentTurn = turn;
                                 if (this.promptShouldStop(params.sessionId, activePrompt)) {
                                     this.interruptLateStartedTurn(turn);
@@ -3354,6 +3406,12 @@ export class CodexAcpServer {
                         return cancelledPromptResponse();
                     }
 
+                    await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+                    const firstImplementationTurn = turnCompleted;
+                    turnCompleted = await this.runWithProcessCheck(() => Promise.race([
+                        goalLifecycle.waitForCompletion(firstImplementationTurn), activePrompt.closeSignal,
+                    ]));
+                    if (turnCompleted === null) return cancelledPromptResponse();
                     await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
                     if (turnCompleted.turn.status === "completed") {
                         await eventHandler.waitForNativeSubagents(activePrompt.signal);
@@ -3445,6 +3503,16 @@ export class CodexAcpServer {
             }
             throw err;
         } finally {
+            // A cancelled v1 prompt must not leave Codex's idle goal scheduler
+            // starting more foreground turns after the response is returned.
+            if ((promptWasCancelled || activePrompt.signal.aborted) && sessionState.currentGoal?.status === "active") {
+                try {
+                    const goal = await this.runWithProcessCheck(() => this.codexAcpClient.setGoalStatus(params.sessionId, "paused"));
+                    await this.publishGoalSnapshot(sessionState, toThreadGoalSnapshot(goal), false);
+                } catch (error) {
+                    logger.error("Failed to pause goal after prompt cancellation", error);
+                }
+            }
             // The app-server subscription is session-scoped and outlives this prompt. Flip routing before
             // awaiting disposal so queued late notifications cannot enter prompt-local buffers.
             promptNotificationsActive = false;
@@ -3469,6 +3537,9 @@ export class CodexAcpServer {
             }
             logger.log("Prompt completed", {sessionId: params.sessionId});
             await eventHandler?.dispose();
+            disposeGoalConnection();
+            goalLifecycle.fail(new Error("ACP prompt closed"));
+            activePrompt.signal.removeEventListener("abort", cancelGoalLifecycle);
             disposePromptRequestCancellation();
             sessionState.currentTurnId = null;
             const registeredPendingTurnStart = this.pendingTurnStarts.get(params.sessionId);
@@ -3601,6 +3672,14 @@ export class CodexAcpServer {
             return;
         }
 
+        const activePrompt = this.activePrompts.get(params.sessionId);
+        // There may be no native turn in the gap before automatic continuation.
+        // Abort the owning prompt without interrupting its already-completed turn.
+        if (activePrompt?.hasCompletedTurn && activePrompt.currentTurn === null) {
+            activePrompt.requestCancel();
+            return;
+        }
+        if (activePrompt?.currentTurn) activePrompt.requestCancel();
         // After turnInterrupt(), Codex will send turn/completed, which naturally completes awaitTurnCompleted().
         await this.interruptSessionTurn(sessionState, "Cancel", false);
     }

src/CodexCommands.ts

@@ -36,16 +36,14 @@ export const GOAL_CONTINUATION_PROMPT: acp.ContentBlock[] = [{
 /**
  * Slash `/goal set|resume` can finish a short Codex setup turn before real work
  * begins. Native Codex CLI continues active goals at idle via `on_thread_idle`;
- * Lody's UI `_session/goal` path chains continuation when `setGoal`/`resumeGoal`
- * return no turn. Slash commands must chain the same way when a setup turn
- * completes (or when no turn starts), otherwise the prompt ends with
- * `stopReason: end_turn` while the goal banner stays active. Codex may also
- * continue internally; this adapter keeps work bound to the slash prompt lifecycle.
+ * If Codex started a turn, the ACP prompt follows its native goal continuations.
+ * Only bootstrap with an explicit prompt when goal setup started no turn at all;
+ * starting another turn after a completed setup races Codex's idle scheduler.
  */
 export function resolveGoalCommandHandleResult(
     turnCompleted: TurnCompletedNotification | null,
 ): CommandHandleResult {
-    if (turnCompleted?.turn.status === "interrupted") {
+    if (turnCompleted !== null) {
         return { handled: true, turnCompleted };
     }
     return { handled: false, prompt: GOAL_CONTINUATION_PROMPT };

src/GoalPromptLifecycle.ts

@@ -0,0 +1,89 @@
+import type {ServerNotification} from "./app-server";
+import type {TurnCompletedNotification} from "./app-server/v2";
+
+/**
+ * One ACP v1 prompt can own several native Codex turns. Observe the native
+ * continuation rather than starting another turn (Codex owns goal scheduling).
+ * This observer exists only while a prompt is open; a stored goal alone never
+ * starts a prompt or establishes live presence.
+ */
+export class GoalPromptLifecycle {
+    private goalActive: boolean;
+    private currentTurnId: string | null = null;
+    private completed: TurnCompletedNotification | null = null;
+    private failure: Error | null = null;
+    private waiter: (() => void) | null = null;
+    private cancelled = false;
+
+    constructor(private readonly sessionId: string, goalActive: boolean) {
+        this.goalActive = goalActive;
+    }
+
+    startTurn(turnId: string): void {
+        if (this.currentTurnId === turnId) return;
+        this.currentTurnId = turnId;
+        this.completed = null;
+    }
+
+    prepareTurn(): void {
+        this.currentTurnId = null;
+        this.completed = null;
+    }
+
+    /** A delayed turn/start response must not overwrite already-observed native work. */
+    startSubmittedTurn(turnId: string): boolean {
+        if (this.currentTurnId !== null || this.completed !== null) return false;
+        this.startTurn(turnId);
+        return true;
+    }
+
+    observe(event: ServerNotification): void {
+        if (event.method === "thread/goal/updated" && event.params.threadId === this.sessionId) {
+            this.goalActive = event.params.goal.status === "active";
+        } else if (event.method === "thread/goal/cleared" && event.params.threadId === this.sessionId) {
+            this.goalActive = false;
+        } else if (event.method === "turn/started" && event.params.threadId === this.sessionId) {
+            this.startTurn(event.params.turn.id);
+        } else if (event.method === "turn/completed" && event.params.threadId === this.sessionId) {
+            this.recordCompletion(event.params);
+        } else {
+            return;
+        }
+        this.waiter?.();
+    }
+
+    private recordCompletion(event: TurnCompletedNotification): void {
+        this.completed = event;
+        if (this.currentTurnId === event.turn.id) this.currentTurnId = null;
+    }
+
+    cancel(): void {
+        this.cancelled = true;
+        this.waiter?.();
+    }
+
+    fail(error: Error): void {
+        this.failure = error;
+        this.waiter?.();
+    }
+
+    async waitForCompletion(first: TurnCompletedNotification): Promise<TurnCompletedNotification | null> {
+        // /review may execute on another thread, outside this session's goal.
+        if (first.threadId !== this.sessionId) return first;
+        // The serialized event handler may already have observed later turns by
+        // the time runTurn's promise resumes. Never replace their state with A.
+        if (this.completed === null) this.recordCompletion(first);
+        const result = await new Promise<TurnCompletedNotification | null>((resolve, reject) => {
+            this.waiter = () => {
+                if (this.failure) reject(this.failure);
+                else if (this.cancelled && this.currentTurnId === null) resolve(null);
+                else if (this.completed && this.currentTurnId === null &&
+                    (!this.goalActive || this.completed.turn.status !== "completed")) {
+                    resolve(this.completed);
+                }
+            };
+            this.waiter();
+        }).finally(() => { this.waiter = null; });
+        return result;
+    }
+}