fix(auto-reply): stranded retry runs own no client queued-turn lifecycle

obviyus · obviyus · commit aeba21694a40 · 2026-07-10T12:28:59.000+05:30
diff --git a/src/auto-reply/reply/agent-runner.misc.runreplyagent.test.ts b/src/auto-reply/reply/agent-runner.misc.runreplyagent.test.ts
@@ -3487,6 +3487,7 @@ describe("runReplyAgent private message_tool_only final warning (#85714)", () =>
     sendPolicyDenied?: boolean;
     isHeartbeat?: boolean;
     replyOperation?: ReturnType<typeof createReplyOperation>;
+    queuedLifecycle?: FollowupRun["queuedLifecycle"];
   }) {
     const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-stranded-"));
     const storePath = path.join(tmp, "sessions.json");
@@ -3543,6 +3544,7 @@ describe("runReplyAgent private message_tool_only final warning (#85714)", () =>
       ...(params.strandedReplyRetry ? { strandedReplyRetry: true } : {}),
       enqueuedAt: Date.now(),
       ...(params.transcriptPrompt ? { transcriptPrompt: params.transcriptPrompt } : {}),
+      ...(params.queuedLifecycle ? { queuedLifecycle: params.queuedLifecycle } : {}),
       run: {
         agentId: "main",
         agentDir: "/tmp/agent",
@@ -3603,7 +3605,11 @@ describe("runReplyAgent private message_tool_only final warning (#85714)", () =>
   });
 
   it("enqueues a one-shot recovery retry by default for substantive stranded finals", async () => {
-    const { finalAssistantText } = await runPrivateFinalCase({});
+    const parentOnComplete = vi.fn();
+    const parentLifecycle = { onComplete: parentOnComplete };
+    const { finalAssistantText } = await runPrivateFinalCase({
+      queuedLifecycle: parentLifecycle,
+    });
 
     expect(warnPrivateFinalSpy).toHaveBeenCalledTimes(1);
     expect(vi.mocked(enqueueFollowupRun)).toHaveBeenCalledTimes(1);
@@ -3614,6 +3620,10 @@ describe("runReplyAgent private message_tool_only final warning (#85714)", () =>
     expect(retryRun?.strandedReplyRetry).toBe(true);
     expect(retryRun?.prompt).toContain("message(action=send)");
     expect(retryRun?.prompt).toContain(finalAssistantText);
+    // System retry must not inherit the client turn's one-shot lifecycle identity.
+    expect(retryRun?.queuedLifecycle).toBeUndefined();
+    expect(parentLifecycle.onComplete).toBe(parentOnComplete);
+    expect(parentOnComplete).not.toHaveBeenCalled();
   });
 
   it("uses visible final text, not raw assistant text, in the recovery retry prompt", async () => {
diff --git a/src/auto-reply/reply/followup-runner.test.ts b/src/auto-reply/reply/followup-runner.test.ts
@@ -5547,6 +5547,8 @@ describe("createFollowupRunner messaging delivery and dedupe", () => {
   it("enqueues a one-shot recovery retry for substantive message-tool-only queued followup finals", async () => {
     const finalText =
       "Here is the answer the queued user asked for. It includes enough detail to be a visible response, and it has another sentence so the substantive-final detector treats it as a real reply.";
+    const parentOnComplete = vi.fn();
+    const parentLifecycle = { onComplete: parentOnComplete };
     const queued = baseQueuedRun("discord");
     const { onBlockReply } = await runMessagingCase({
       agentResult: {
@@ -5557,6 +5559,7 @@ describe("createFollowupRunner messaging delivery and dedupe", () => {
         ...queued,
         originatingChannel: "discord",
         originatingTo: "channel:C1",
+        queuedLifecycle: parentLifecycle,
         run: {
           ...queued.run,
           sourceReplyDeliveryMode: "message_tool_only",
@@ -5578,6 +5581,9 @@ describe("createFollowupRunner messaging delivery and dedupe", () => {
     expect(retry?.run.sourceReplyDeliveryMode).toBe("message_tool_only");
     expect(retry?.prompt).toContain("message(action=send)");
     expect(retry?.prompt).toContain(finalText);
+    // System retry detaches from the client turn lifecycle; parent completion owns onComplete once.
+    expect(retry?.queuedLifecycle).toBeUndefined();
+    expect(parentOnComplete).toHaveBeenCalledTimes(1);
   });
 
   it("excludes raw trace and status payloads from queued stranded recovery prompts", async () => {
diff --git a/src/auto-reply/reply/stranded-reply-recovery.test.ts b/src/auto-reply/reply/stranded-reply-recovery.test.ts
@@ -0,0 +1,48 @@
+import { describe, expect, it, vi } from "vitest";
+import { completeFollowupRunLifecycle, markFollowupRunEnqueued } from "./queue/types.js";
+import {
+  buildStrandedReplyRetryFollowupRun,
+  STRANDED_REPLY_RETRY_MARKER,
+} from "./stranded-reply-recovery.js";
+import { createMockFollowupRun } from "./test-helpers.js";
+
+describe("buildStrandedReplyRetryFollowupRun lifecycle ownership", () => {
+  it("does not share the client turn's queuedLifecycle with the system retry", () => {
+    const onComplete = vi.fn();
+    const onEnqueued = vi.fn(() => true);
+    const parent = createMockFollowupRun({
+      prompt: "user question",
+      transcriptPrompt: "user question",
+      queuedLifecycle: { onComplete, onEnqueued },
+      admissionSessionId: "sess-rotated",
+      onFollowupAdmissionWaitChange: vi.fn(),
+    });
+
+    const retry = buildStrandedReplyRetryFollowupRun(parent, {
+      finalText: "A substantive stranded final that must be re-delivered via message(action=send).",
+      sourceReplyDeliveryMode: "message_tool_only",
+    });
+
+    expect(retry.queuedLifecycle).toBeUndefined();
+    expect(retry.strandedReplyRetry).toBe(true);
+    expect(retry.summaryLine).toBe(STRANDED_REPLY_RETRY_MARKER);
+    // Session routing stays; only the client-turn lifecycle identity is detached.
+    expect(retry.admissionSessionId).toBe("sess-rotated");
+    expect(retry.onFollowupAdmissionWaitChange).toBe(parent.onFollowupAdmissionWaitChange);
+    expect(retry.run.sessionKey).toBe(parent.run.sessionKey);
+
+    // mark/complete no-op when lifecycle is absent (drop-policy onDrop path too).
+    expect(markFollowupRunEnqueued(retry)).toBe(true);
+    expect(onEnqueued).not.toHaveBeenCalled();
+    completeFollowupRunLifecycle(retry);
+    expect(onComplete).not.toHaveBeenCalled();
+
+    // Parent still owns the one-shot lifecycle; retry completion must not steal it.
+    expect(markFollowupRunEnqueued(parent)).toBe(true);
+    expect(onEnqueued).toHaveBeenCalledTimes(1);
+    completeFollowupRunLifecycle(parent);
+    expect(onComplete).toHaveBeenCalledTimes(1);
+    completeFollowupRunLifecycle(parent);
+    expect(onComplete).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/src/auto-reply/reply/stranded-reply-recovery.ts b/src/auto-reply/reply/stranded-reply-recovery.ts
@@ -42,6 +42,10 @@ export function buildStrandedReplyRetryFollowupRun(
     transcriptPrompt: undefined,
     userTurnTranscriptRecorder: undefined,
     currentInboundContext: undefined,
+    // Internally generated system turn: the client turn's lifecycle (gateway cancel
+    // identity) completes with the parent run. queuedLifecycle is one-shot WeakSet-tracked,
+    // so a shared object would be double-owned and free cancel while the retry still runs.
+    queuedLifecycle: undefined,
     run: {
       ...base.run,
       sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,
