Interrupt late-started goal commands on cancel

Author: benbrandt

src/CodexCommands.ts

@@ -165,7 +165,7 @@ export class CodexCommands {
                 return { handled: true };
             }
             case "goal": {
-                return await this.runGoalCommand(sessionState, command.rest);
+                return await this.runGoalCommand(sessionState, command.rest, options);
             }
             case "review": {
                 const target = this.buildReviewTarget(command.rest);
@@ -266,16 +266,16 @@ export class CodexCommands {
             sessionState.sessionId,
             target,
             (turnId, threadId) => {
-                if (options.onTurnStarted) {
-                    options.onTurnStarted(turnId, threadId);
-                } else {
-                    sessionState.currentTurnId = turnId;
-                }
+                this.handleCommandTurnStarted(sessionState, options, turnId, threadId);
             },
         ));
     }
 
-    private async runGoalCommand(sessionState: SessionState, rest: string): Promise<CommandHandleResult> {
+    private async runGoalCommand(
+        sessionState: SessionState,
+        rest: string,
+        options: CommandHandleOptions,
+    ): Promise<CommandHandleResult> {
         const sessionId = sessionState.sessionId;
         const argument = rest.trim();
         if (argument.length === 0) {
@@ -291,7 +291,7 @@ export class CodexCommands {
                 return this.createGoalCommandResult(await this.runWithProcessCheck(() => this.codexAcpClient.resumeGoal(
                     sessionId,
                     (turnId) => {
-                        sessionState.currentTurnId = turnId;
+                        this.handleCommandTurnStarted(sessionState, options, turnId, sessionId);
                     },
                 )));
             case "clear":
@@ -315,11 +315,24 @@ export class CodexCommands {
             sessionId,
             argument,
             (turnId) => {
-                sessionState.currentTurnId = turnId;
+                this.handleCommandTurnStarted(sessionState, options, turnId, sessionId);
             },
         )));
     }
 
+    private handleCommandTurnStarted(
+        sessionState: SessionState,
+        options: CommandHandleOptions,
+        turnId: string,
+        threadId: string,
+    ): void {
+        if (options.onTurnStarted) {
+            options.onTurnStarted(turnId, threadId);
+        } else {
+            sessionState.currentTurnId = turnId;
+        }
+    }
+
     private createGoalCommandResult(turnCompleted: TurnCompletedNotification | null): CommandHandleResult {
         if (turnCompleted === null) {
             return { handled: true };

src/__tests__/CodexACPAgent/CodexAcpClient.test.ts

@@ -1491,6 +1491,51 @@ describe('ACP server test', { timeout: 40_000 }, () => {
         expect(promptResolved).toBe(true);
     });
 
+    it('interrupts a late-started goal slash command after the ACP prompt request is cancelled', async () => {
+        const { mockFixture } = setupPromptFixture();
+        const goalCompleted = deferred<TurnCompletedNotification | null>();
+        let startGoalTurn: () => void = () => {};
+        const goalRunSpy = vi.spyOn(mockFixture.getCodexAppServerClient(), "runGoalSet")
+            .mockImplementation((_params, onTurnStarted) => {
+                startGoalTurn = () => onTurnStarted?.("goal-turn-id");
+                return goalCompleted.promise;
+            });
+        const turnInterruptSpy = vi.spyOn(mockFixture.getCodexAcpClient(), "turnInterrupt")
+            .mockImplementation(async ({threadId, turnId}) => {
+                goalCompleted.resolve({
+                    threadId,
+                    turn: createTurn(turnId, "interrupted"),
+                });
+            });
+        const controller = new AbortController();
+
+        const promptPromise = mockFixture.getCodexAcpAgent().prompt({
+            sessionId: "session-id",
+            prompt: [{ type: "text", text: "/goal Ship the migration and keep tests green" }],
+        }, controller.signal);
+
+        await vi.waitFor(() => {
+            expect(goalRunSpy).toHaveBeenCalledWith({
+                threadId: "session-id",
+                objective: "Ship the migration and keep tests green",
+                status: "active",
+            }, expect.any(Function));
+        });
+
+        controller.abort();
+        await expect(promptPromise).resolves.toMatchObject({stopReason: "cancelled"});
+        expect(turnInterruptSpy).not.toHaveBeenCalled();
+
+        startGoalTurn();
+
+        await vi.waitFor(() => {
+            expect(turnInterruptSpy).toHaveBeenCalledWith({
+                threadId: "session-id",
+                turnId: "goal-turn-id",
+            });
+        });
+    });
+
     it('does not hang when goal set starts no continuation turn', async () => {
         const mockFixture = createCodexMockTestFixture();
         const codexAppServerClient = mockFixture.getCodexAppServerClient();