fix(agent): harden Codex goal recovery

Author: tatoalo

packages/agent/src/adapters/codex-app-server/codex-app-server-agent.test.ts

@@ -46,7 +46,12 @@ function makeStubRpc(responses: Record<string, unknown>) {
           message: `Invalid request: missing field \`${missing}\``,
         };
       }
-      return (responses[method] ?? {}) as T;
+      const response = responses[method];
+      return (
+        typeof response === "function"
+          ? await response(params)
+          : (response ?? {})
+      ) as T;
     },
     notify() {},
     async close() {},
@@ -494,6 +499,52 @@ describe("CodexAppServerAgent", () => {
     });
   });
 
+  it("retries queued goal cancellation after an interrupt failure", async () => {
+    let interruptAttempts = 0;
+    const stub = makeStubRpc({
+      "thread/start": { thread: { id: "thr_1" } },
+      "thread/goal/set": {
+        goal: { objective: "Ship the fix", status: "paused" },
+      },
+      "turn/interrupt": () => {
+        interruptAttempts++;
+        if (interruptAttempts === 1) {
+          throw new Error("interrupt failed");
+        }
+        return {};
+      },
+    });
+    const { client } = makeFakeClient();
+    const agent = new CodexAppServerAgent(client, {
+      processOptions: { binaryPath: "/bundle/codex" },
+      rpcFactory: stub.factory,
+    });
+    await agent.newSession({ cwd: "/repo" } as unknown as NewSessionRequest);
+
+    await agent.prompt({
+      sessionId: "thr_1",
+      prompt: [{ type: "text", text: "/goal pause" }],
+    } as unknown as PromptRequest);
+    stub.emit("turn/started", { turn: { id: "goal_tick_1" } });
+    await Promise.resolve();
+    await Promise.resolve();
+    stub.emit("turn/started", { turn: { id: "goal_tick_2" } });
+    await Promise.resolve();
+
+    expect(
+      stub.requests.filter((request) => request.method === "turn/interrupt"),
+    ).toEqual([
+      {
+        method: "turn/interrupt",
+        params: { threadId: "thr_1", turnId: "goal_tick_1" },
+      },
+      {
+        method: "turn/interrupt",
+        params: { threadId: "thr_1", turnId: "goal_tick_2" },
+      },
+    ]);
+  });
+
   it("includes buffered command output when completion omits aggregatedOutput", async () => {
     const stub = makeStubRpc({
       initialize: {},

packages/agent/src/adapters/codex-app-server/codex-app-server-agent.ts

@@ -814,12 +814,14 @@ export class CodexAppServerAgent extends BaseAcpAgent {
 
   private interruptQueuedGoalTurn(turnId: string | undefined): void {
     if (!this.cancelNextGoalTurn || !this.threadId || !turnId) return;
-    this.cancelNextGoalTurn = false;
     void this.rpc
       .request(APP_SERVER_METHODS.TURN_INTERRUPT, {
         threadId: this.threadId,
         turnId,
       })
+      .then(() => {
+        this.cancelNextGoalTurn = false;
+      })
       .catch((error) =>
         this.logger.warn("Queued goal turn interrupt failed", error),
       );

packages/agent/src/sagas/resume-saga.test.ts

@@ -641,6 +641,19 @@ describe("ResumeSaga", () => {
         ],
         expected: null,
       },
+      {
+        name: "skips malformed newer goal notifications",
+        entries: [
+          createNotification(POSTHOG_NOTIFICATIONS.CODEX_GOAL, {
+            goal: { objective: "Ship the fix", status: "paused" },
+          }),
+          createNotification(POSTHOG_NOTIFICATIONS.CODEX_GOAL, {
+            goal: { objective: "Invalid goal", status: "unknown" },
+          }),
+          createNotification(POSTHOG_NOTIFICATIONS.CODEX_GOAL, {}),
+        ],
+        expected: { objective: "Ship the fix", status: "paused" },
+      },
       {
         name: "leaves goal state undefined when no notification exists",
         entries: [createUserMessage("Hello")],

packages/agent/src/sagas/resume-saga.ts

@@ -146,7 +146,7 @@ export class ResumeSaga extends Saga<ResumeInput, ResumeOutput> {
       const goal = (notification?.params as { goal?: unknown } | undefined)
         ?.goal;
       if (goal === null) return null;
-      if (!goal || typeof goal !== "object") return undefined;
+      if (!goal || typeof goal !== "object") continue;
       const value = goal as Record<string, unknown>;
       if (
         typeof value.objective === "string" &&
@@ -158,7 +158,6 @@ export class ResumeSaga extends Saga<ResumeInput, ResumeOutput> {
           status: value.status as NativeGoalState["status"],
         };
       }
-      return undefined;
     }
     return undefined;
   }