fix(recovery): reset command lane when abort leaves pre-existing task blocked

hanZeng-08 · hanZeng-08 · commit 067926251dc7 · 2026-06-12T08:35:18.000+08:00
diff --git a/src/logging/diagnostic-stuck-session-recovery.runtime.test.ts b/src/logging/diagnostic-stuck-session-recovery.runtime.test.ts
@@ -259,6 +259,40 @@ describe("stuck session recovery", () => {
     expect(mocks.resetCommandLane).not.toHaveBeenCalled();
   });
 
+  it("releases the session lane when abort+drain succeeds but the lane task is still executing", async () => {
+    mocks.resolveActiveEmbeddedRunHandleSessionId.mockReturnValue("session-1");
+    mocks.abortEmbeddedAgentRun.mockReturnValue(true);
+    mocks.waitForEmbeddedAgentRunEnd.mockResolvedValue(true);
+    mocks.resetCommandLane.mockReturnValue(1);
+    mocks.getCommandLaneActiveTaskIds.mockReturnValue([101]).mockReturnValue([101]);
+    mocks.getCommandLaneSnapshot.mockReturnValue({
+      lane: "session:agent:main:main",
+      queuedCount: 0,
+      activeCount: 1,
+      maxConcurrent: 1,
+      draining: false,
+      generation: 0,
+    });
+
+    const outcome = await recoverStuckDiagnosticSession({
+      sessionId: "session-1",
+      sessionKey: "agent:main:main",
+      ageMs: 720_000,
+      queueDepth: 0,
+      allowActiveAbort: true,
+    });
+
+    expect(outcome).toMatchObject({
+      status: "aborted",
+      action: "abort_embedded_run",
+      aborted: true,
+      drained: true,
+      forceCleared: false,
+      released: 1,
+    });
+    expect(mocks.resetCommandLane).toHaveBeenCalledWith("session:agent:main:main");
+  });
+
   it("keeps the lane when a fresh turn started during the abort even with lane-queued work", async () => {
     mocks.resolveActiveEmbeddedRunHandleSessionId.mockReturnValue("session-fresh-queued");
     mocks.abortEmbeddedAgentRun.mockReturnValue(true);
diff --git a/src/logging/diagnostic-stuck-session-recovery.runtime.ts b/src/logging/diagnostic-stuck-session-recovery.runtime.ts
@@ -252,7 +252,8 @@ export async function recoverStuckDiagnosticSession(
       }
     }
 
-    const queuedCount = sessionLane ? getCommandLaneSnapshot(sessionLane).queuedCount : 0;
+    const postAbortLaneSnapshot = sessionLane ? getCommandLaneSnapshot(sessionLane) : undefined;
+    const queuedCount = postAbortLaneSnapshot?.queuedCount ?? 0;
     // A task id active now but not before the abort means the lane already
     // unwedged and pumped fresh work; resetting it would double-run the lane.
     const laneStartedFreshTask =
@@ -261,10 +262,23 @@ export async function recoverStuckDiagnosticSession(
     // Queued turns ride the session queue (params.queueDepth), not only the lane
     // queue; without this signal a cleanly aborted wedged lane never resets.
     const hasQueuedSessionWork = (params.queueDepth ?? 0) > 0;
+    // A run may have been aborted+drained from the embedded-run registry while its
+    // underlying command-lane task is still executing (e.g. waitForCompactionRetry
+    // or in-flight tool execution). If the lane is still blocked by pre-existing
+    // active tasks we must reset it so queued work can drain.
+    const laneStillBlockedByPreExistingTask =
+      !laneStartedFreshTask &&
+      postAbortLaneSnapshot !== undefined &&
+      postAbortLaneSnapshot.activeCount > 0;
     const released =
       sessionLane &&
       !laneStartedFreshTask &&
-      (queuedCount > 0 || hasQueuedSessionWork || !activeSessionId || !aborted || !drained)
+      (queuedCount > 0 ||
+        hasQueuedSessionWork ||
+        !activeSessionId ||
+        !aborted ||
+        !drained ||
+        laneStillBlockedByPreExistingTask)
         ? resetCommandLane(sessionLane)
         : 0;
 
