feat: Add /goal support (#240)

* feat: Add /goal support

* Suppress multiple identical notifications

* Wait on turns

* Wait for goal turn

* Add newlines after notifications

* Remove unsupported edit subcommand

* Handle goal commands without continuation turns

* Separate goal status updates from prior text

* Potential fix for pull request finding 'Unused variable, import, function or class'

Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com>

* Interrupt late-started goal commands on cancel

* Suppress stale turn notifications after routing them

* Wait for thread idle when no goal turn starts

* Handle cancellation before goal turn routing

* Wait for goal updates before finishing goal set

* Add grace periods for goal turn routing

* Wait for goal notifications in ACP client

* Wait for goal turn completion before resolving

* Potential fix for pull request finding 'Unused variable, import, function or class'

Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com>

---------

Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com>

Author: benbrandt

src/CodexAcpClient.ts

@@ -33,6 +33,7 @@ import type {
     SkillsListResponse,
     SandboxPolicy,
     Thread,
+    ThreadGoalStatus,
     ThreadSourceKind,
     TurnCompletedNotification,
     UserInput,
@@ -334,6 +335,39 @@ export class CodexAcpClient {
         await this.codexClient.runCompact({threadId: sessionId});
     }
 
+    async setGoal(
+        sessionId: string,
+        objective: string,
+        onTurnStarted?: (turnId: string) => void,
+    ): Promise<TurnCompletedNotification | null> {
+        return await this.codexClient.runGoalSet({
+            threadId: sessionId,
+            objective,
+            status: "active",
+        }, onTurnStarted);
+    }
+
+    async setGoalStatus(sessionId: string, status: ThreadGoalStatus): Promise<void> {
+        await this.codexClient.runGoalSet({
+            threadId: sessionId,
+            status,
+        });
+    }
+
+    async resumeGoal(
+        sessionId: string,
+        onTurnStarted?: (turnId: string) => void,
+    ): Promise<TurnCompletedNotification | null> {
+        return await this.codexClient.runGoalSet({
+            threadId: sessionId,
+            status: "active",
+        }, onTurnStarted);
+    }
+
+    async clearGoal(sessionId: string): Promise<void> {
+        await this.codexClient.runGoalClear({threadId: sessionId});
+    }
+
     async awaitMcpServerStartup(serverNames: Array<string>, afterVersion: number): Promise<McpStartupResult> {
         return await this.codexClient.awaitMcpServerStartup(serverNames, afterVersion);
     }

src/CodexAcpServer.ts

@@ -14,6 +14,7 @@ import type {
     ReasoningEffortOption,
     Thread,
     ThreadItem,
+    TurnCompletedNotification,
     UserInput
 } from "./app-server/v2";
 import type {RateLimitsMap} from "./RateLimitsMap";
@@ -66,6 +67,12 @@ import packageJson from "../package.json";
 import {isJetBrains2026_1Client} from "./JBUtils";
 import {resolveTerminalOutputMode, type TerminalOutputMode} from "./TerminalOutputMode";
 
+export interface ThreadGoalSnapshot {
+    objective: string;
+    status: string;
+    tokenBudget: number | null;
+}
+
 export interface SessionState {
     sessionId: string,
     currentModelId: string,
@@ -87,6 +94,7 @@ export interface SessionState {
     currentModelSupportsFast: boolean;
     sessionMcpServers?: Array<string>;
     terminalOutputMode: TerminalOutputMode;
+    currentGoal?: ThreadGoalSnapshot | null;
 }
 
 interface ActiveAuthState {
@@ -1398,6 +1406,13 @@ export class CodexAcpServer {
         sessionState.lastTokenUsage = null;
         const activePrompt = this.trackActivePrompt(params.sessionId);
         let pendingTurnStart: PendingTurnStart | null = null;
+        const ensurePendingTurnStart = (): PendingTurnStart => {
+            if (pendingTurnStart === null) {
+                pendingTurnStart = this.createPendingTurnStart();
+                this.pendingTurnStarts.set(params.sessionId, pendingTurnStart);
+            }
+            return pendingTurnStart;
+        };
         const disposePromptRequestCancellation = this.observePromptRequestCancellation(signal, sessionState, activePrompt);
 
         try {
@@ -1417,6 +1432,9 @@ export class CodexAcpServer {
             }
 
             const commandPromise = this.availableCommands.tryHandleCommand(params.prompt, sessionState, {
+                onTurnStartPending: () => {
+                    ensurePendingTurnStart();
+                },
                 onTurnStarted: (turnId, threadId) => {
                     const turn = {threadId, turnId};
                     activePrompt.currentTurn = turn;
@@ -1425,6 +1443,7 @@ export class CodexAcpServer {
                         return;
                     }
                     sessionState.currentTurnId = turnId;
+                    pendingTurnStart?.resolve(turnId);
                 },
             });
             void commandPromise.catch((err) => {
@@ -1483,8 +1502,7 @@ export class CodexAcpServer {
                 sessionState.fastModeEnabled,
                 sessionState.currentModelSupportsFast,
             );
-            pendingTurnStart = this.createPendingTurnStart();
-            this.pendingTurnStarts.set(params.sessionId, pendingTurnStart);
+            ensurePendingTurnStart();
             const sendPromptPromise = this.runWithProcessCheck(
                 () => this.codexAcpClient.sendPrompt(
                     params,
@@ -1546,10 +1564,11 @@ export class CodexAcpServer {
             logger.log("Prompt completed", {sessionId: params.sessionId});
             disposePromptRequestCancellation();
             sessionState.currentTurnId = null;
-            if (pendingTurnStart !== null && this.pendingTurnStarts.get(params.sessionId) === pendingTurnStart) {
+            const registeredPendingTurnStart = this.pendingTurnStarts.get(params.sessionId);
+            if (registeredPendingTurnStart !== undefined) {
                 this.pendingTurnStarts.delete(params.sessionId);
+                registeredPendingTurnStart.resolve(null);
             }
-            pendingTurnStart?.resolve(null);
             activePrompt.complete();
         }
     }