fix(codex): cap native-subagent completion delivery retries

liuhao1024 · liuhao1024 · commit 601f4cbc6119 · 2026-06-29T13:53:08.000+08:00
The CodexNativeSubagentMonitor's completion delivery retry loop had no maximum attempt count or deadline. A permanently non-durable delivery (e.g. silent parent reply) would reschedule every 5 minutes forever, re-invoking deliverAgentHarnessTaskCompletion on each tick. Add DEFAULT_MAX_COMPLETION_DELIVERY_ATTEMPTS (6, matching the delay array length) and a completionDeliveryMaxAttempts option. When attempts reach the limit, mark the delivery as failed and clear the pending state instead of rescheduling. Fixes #97593
diff --git a/extensions/codex/src/app-server/native-subagent-monitor.test.ts b/extensions/codex/src/app-server/native-subagent-monitor.test.ts
@@ -793,6 +793,64 @@ describe("CodexNativeSubagentMonitor", () => {
     );
   });
 
+  it("abandons completion delivery after max retry attempts", async () => {
+    vi.useFakeTimers();
+    const client = createClient();
+    const runtime = createRuntime();
+    // Permanently non-durable delivery
+    runtime.deliverAgentHarnessTaskCompletion.mockResolvedValue({
+      delivered: false,
+      path: "none",
+      error: "parent response silent",
+    });
+    const maxAttempts = 3;
+    const monitor = new CodexNativeSubagentMonitor(client, runtime, {
+      completionDeliveryRetryDelaysMs: [100, 200, 300],
+      completionDeliveryMaxAttempts: maxAttempts,
+    });
+    monitor.registerParent({
+      parentThreadId: "parent-thread",
+      requesterSessionKey: "agent:main:discord:channel:C123",
+      taskRuntimeScope: createTaskScope(),
+      agentId: "main",
+    });
+
+    const completion = nativeCompletionNotification({
+      agentPath: "child-thread",
+      statusLabel: "completed",
+      result: "child final result",
+    });
+
+    await notifyChildStarted(client);
+    await client.notify(completion);
+
+    // First delivery attempt happens immediately
+    expect(runtime.deliverAgentHarnessTaskCompletion).toHaveBeenCalledTimes(1);
+
+    // Advance through all retry delays
+    for (let i = 0; i < maxAttempts + 2; i++) {
+      await vi.advanceTimersByTimeAsync(500);
+    }
+
+    // Should have attempted exactly maxAttempts times (1 initial + maxAttempts-1 retries)
+    expect(runtime.deliverAgentHarnessTaskCompletion).toHaveBeenCalledTimes(maxAttempts);
+
+    // Should have marked delivery as failed
+    expect(runtime.setDetachedTaskDeliveryStatusByRunId).toHaveBeenCalledWith(
+      expect.objectContaining({
+        runId: "codex-thread:child-thread",
+        deliveryStatus: "failed",
+        error: expect.stringContaining("abandoned after"),
+      }),
+    );
+
+    // No more retries after give-up
+    await vi.advanceTimersByTimeAsync(1_000_000);
+    expect(runtime.deliverAgentHarnessTaskCompletion).toHaveBeenCalledTimes(maxAttempts);
+
+    vi.useRealTimers();
+  });
+
   it("reconciles transcript final text before delivering empty Codex completion notifications", async () => {
     const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-codex-subagent-"));
     const codexHome = path.join(tempDir, "codex-home");
diff --git a/extensions/codex/src/app-server/native-subagent-monitor.ts b/extensions/codex/src/app-server/native-subagent-monitor.ts
@@ -80,6 +80,7 @@ type MonitorOptions = {
   codexHome?: string;
   transcriptPollDelaysMs?: readonly number[];
   completionDeliveryRetryDelaysMs?: readonly number[];
+  completionDeliveryMaxAttempts?: number;
   taskRowReconcileIntervalMs?: number;
 };
 
@@ -89,6 +90,7 @@ const DEFAULT_TRANSCRIPT_POLL_DELAYS_MS = [
 const DEFAULT_COMPLETION_DELIVERY_RETRY_DELAYS_MS = [
   5_000, 15_000, 30_000, 60_000, 120_000, 300_000,
 ];
+const DEFAULT_MAX_COMPLETION_DELIVERY_ATTEMPTS = DEFAULT_COMPLETION_DELIVERY_RETRY_DELAYS_MS.length;
 const DEFAULT_TASK_ROW_RECONCILE_INTERVAL_MS = 10_000;
 const RECENT_TERMINAL_TASK_RECONCILE_GRACE_MS = 60_000;
 // Codex's recorder uses this filename contract; non-canonical names keep the
@@ -140,6 +142,7 @@ export class CodexNativeSubagentMonitor {
   private codexHome?: string;
   private transcriptPollDelaysMs: readonly number[];
   private completionDeliveryRetryDelaysMs: readonly number[];
+  private maxCompletionDeliveryAttempts: number;
   private taskRowReconcileTimer?: ReturnType<typeof setInterval>;
 
   constructor(
@@ -152,6 +155,8 @@ export class CodexNativeSubagentMonitor {
       options.transcriptPollDelaysMs ?? DEFAULT_TRANSCRIPT_POLL_DELAYS_MS;
     this.completionDeliveryRetryDelaysMs =
       options.completionDeliveryRetryDelaysMs ?? DEFAULT_COMPLETION_DELIVERY_RETRY_DELAYS_MS;
+    this.maxCompletionDeliveryAttempts =
+      options.completionDeliveryMaxAttempts ?? DEFAULT_MAX_COMPLETION_DELIVERY_ATTEMPTS;
     this.startTaskRowReconciler(
       options.taskRowReconcileIntervalMs ?? DEFAULT_TASK_ROW_RECONCILE_INTERVAL_MS,
     );
@@ -614,10 +619,41 @@ export class CodexNativeSubagentMonitor {
     });
   }
 
+  private markCompletionDeliveryFailed(
+    completion: CodexNativeSubagentCompletion,
+    error: string,
+  ): void {
+    const taskRuntime = this.getTaskRuntimeForChild(completion.childThreadId);
+    if (!taskRuntime) {
+      return;
+    }
+    taskRuntime.setDetachedTaskDeliveryStatusByRunId({
+      runId: codexNativeSubagentRunId(completion.childThreadId),
+      deliveryStatus: "failed",
+      error,
+    });
+  }
+
   private scheduleCompletionDeliveryRetry(childState: ChildState): void {
     if (!childState.pendingCompletion || childState.completionDeliveryTimer) {
       return;
     }
+    if (childState.completionDeliveryAttempt >= this.maxCompletionDeliveryAttempts - 1) {
+      const completion = childState.pendingCompletion;
+      childState.pendingCompletion = undefined;
+      childState.pendingCompletionEventAt = undefined;
+      childState.completionDeliveryAttempt = 0;
+      this.markCompletionDeliveryFailed(
+        completion,
+        `completion delivery abandoned after ${this.maxCompletionDeliveryAttempts} attempts`,
+      );
+      embeddedAgentLog.warn("Codex native subagent completion delivery abandoned", {
+        parentThreadId: childState.parentThreadId,
+        childThreadId: completion.childThreadId,
+        attempts: this.maxCompletionDeliveryAttempts,
+      });
+      return;
+    }
     const attempt = childState.completionDeliveryAttempt;
     const delayMs =
       this.completionDeliveryRetryDelaysMs[
