fix(recovery): skip recovery for issues with scheduled future monitors

jelsco · claude · jelsco · commit b314d84f8a38 · 2026-05-21T08:30:47.000-06:00
Both the post-run handoff decision (decideSuccessfulRunHandoff) and the
periodic stranded-issue sweep (reconcileStrandedAssignedIssues) were
classifying in_progress issues with succeeded runs as "missing disposition"
even when the issue had a future monitorNextCheckAt. This caused false-positive
recovery loops on deliberately-parked issues (e.g., LinkedIn content calendar
posts waiting for a publish-runner routine).

The issue-graph-liveness system already had hasScheduledMonitor() that
correctly skipped such issues, but these two other recovery paths did not.

Changes:
- Add hasScheduledMonitor boolean to decideSuccessfulRunHandoff input type
  and skip when true
- Select monitorNextCheckAt in handleSuccessfulRunHandoff issue query and
  pass it to the decision function
- Add monitorNextCheckAt &gt; now check in reconcileStrandedAssignedIssues
  after the hasActiveExecutionPath guard
- Unit test for the new skip in successful-run-handoff.test.ts
- Two integration tests in heartbeat-process-recovery.test.ts covering
  both the handoff and sweep paths

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/server/src/__tests__/heartbeat-process-recovery.test.ts b/server/src/__tests__/heartbeat-process-recovery.test.ts
@@ -2914,6 +2914,62 @@ describeEmbeddedPostgres("heartbeat orphaned process recovery", () => {
     });
   });
 
+  it("skips successful-run handoff when issue has a future monitorNextCheckAt", async () => {
+    const { companyId, agentId, runId, issueId } = await seedQueuedIssueRunFixture();
+    const futureDate = new Date(Date.now() + 60 * 60 * 1000);
+    await db.update(issues).set({ monitorNextCheckAt: futureDate }).where(eq(issues.id, issueId));
+
+    mockAdapterExecute.mockImplementationOnce(async (ctx: { runId: string }) => {
+      await db.insert(issueComments).values({
+        companyId,
+        issueId,
+        authorAgentId: agentId,
+        createdByRunId: ctx.runId,
+        body: "Parked post awaiting publish-runner routine.",
+      });
+      return {
+        exitCode: 0,
+        signal: null,
+        timedOut: false,
+        errorMessage: null,
+        summary: "Parked post awaiting publish-runner routine.",
+        provider: "test",
+        model: "test-model",
+      };
+    });
+    const heartbeat = heartbeatService(db);
+
+    await heartbeat.resumeQueuedRuns();
+    await waitForRunToSettle(heartbeat, runId, 5_000);
+    await waitForHeartbeatIdle(db, 5_000);
+
+    const handoffWakeups = await db
+      .select()
+      .from(agentWakeupRequests)
+      .where(eq(agentWakeupRequests.agentId, agentId))
+      .then((rows) => rows.filter((w) => w.reason === "finish_successful_run_handoff"));
+    expect(handoffWakeups).toHaveLength(0);
+  });
+
+  it("skips stranded sweep when issue has a future monitorNextCheckAt", async () => {
+    const { issueId } = await seedStrandedIssueFixture({
+      status: "in_progress",
+      runStatus: "succeeded",
+      livenessState: "advanced",
+    });
+    const futureDate = new Date(Date.now() + 60 * 60 * 1000);
+    await db.update(issues).set({ monitorNextCheckAt: futureDate }).where(eq(issues.id, issueId));
+
+    const heartbeat = heartbeatService(db);
+    const result = await heartbeat.reconcileStrandedAssignedIssues();
+    expect(result.continuationRequeued).toBe(0);
+    expect(result.successfulRunHandoffEscalated).toBe(0);
+    expect(result.escalated).toBe(0);
+
+    const issue = await db.select().from(issues).where(eq(issues.id, issueId)).then((rows) => rows[0] ?? null);
+    expect(issue?.status).toBe("in_progress");
+  });
+
   it("does not reconcile user-assigned work through the agent stranded-work recovery path", async () => {
     const { issueId, runId } = await seedStrandedIssueFixture({
       status: "todo",
diff --git a/server/src/services/heartbeat.ts b/server/src/services/heartbeat.ts
@@ -4027,6 +4027,7 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})
         assigneeUserId: issues.assigneeUserId,
         executionState: issues.executionState,
         projectId: issues.projectId,
+        monitorNextCheckAt: issues.monitorNextCheckAt,
       })
       .from(issues)
       .where(and(eq(issues.id, issueId), eq(issues.companyId, run.companyId)))
@@ -4186,6 +4187,7 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})
       taskKey,
       hasActiveExecutionPath: Boolean(activeExecutionPath),
       hasQueuedWake: Boolean(queuedWake),
+      hasScheduledMonitor: Boolean(issue?.monitorNextCheckAt && issue.monitorNextCheckAt.getTime() > Date.now()),
       hasPendingInteractionOrApproval: Boolean(pendingInteraction || pendingApproval),
       hasExplicitBlockerPath: Boolean(explicitBlocker),
       hasOpenRecoveryIssue: Boolean(openRecoveryIssue),
diff --git a/server/src/services/recovery/service.ts b/server/src/services/recovery/service.ts
@@ -2015,6 +2015,11 @@ export function recoveryService(db: Db, deps: { enqueueWakeup: RecoveryWakeup })
         continue;
       }
 
+      if (issue.monitorNextCheckAt && issue.monitorNextCheckAt.getTime() > Date.now()) {
+        result.skipped += 1;
+        continue;
+      }
+
       if (await isAutomaticRecoverySuppressedByPauseHold(db, issue.companyId, issue.id, treeControlSvc)) {
         result.skipped += 1;
         continue;
diff --git a/server/src/services/recovery/successful-run-handoff.test.ts b/server/src/services/recovery/successful-run-handoff.test.ts
@@ -48,6 +48,7 @@ function decide(overrides: Partial<Parameters<typeof decideSuccessfulRunHandoff>
     taskKey: "issue-1",
     hasActiveExecutionPath: false,
     hasQueuedWake: false,
+    hasScheduledMonitor: false,
     hasPendingInteractionOrApproval: false,
     hasExplicitBlockerPath: false,
     hasOpenRecoveryIssue: false,
@@ -124,6 +125,13 @@ describe("successful run handoff decision", () => {
     });
   });
 
+  it("skips when issue has a scheduled future monitor", () => {
+    expect(decide({ hasScheduledMonitor: true })).toEqual({
+      kind: "skip",
+      reason: "issue has a scheduled future monitor",
+    });
+  });
+
   it("does not queue when a successful run has no progress signal", () => {
     expect(decide({ livenessState: null, detectedProgressSummary: null })).toEqual({
       kind: "skip",
diff --git a/server/src/services/recovery/successful-run-handoff.ts b/server/src/services/recovery/successful-run-handoff.ts
@@ -338,6 +338,7 @@ export function decideSuccessfulRunHandoff(input: {
   taskKey: string | null;
   hasActiveExecutionPath: boolean;
   hasQueuedWake: boolean;
+  hasScheduledMonitor: boolean;
   hasPendingInteractionOrApproval: boolean;
   hasExplicitBlockerPath: boolean;
   hasOpenRecoveryIssue: boolean;
@@ -372,6 +373,7 @@ export function decideSuccessfulRunHandoff(input: {
   }
   if (input.hasActiveExecutionPath) return { kind: "skip", reason: "issue already has an active execution path" };
   if (input.hasQueuedWake) return { kind: "skip", reason: "issue already has a queued or deferred wake" };
+  if (input.hasScheduledMonitor) return { kind: "skip", reason: "issue has a scheduled future monitor" };
   if (input.hasPendingInteractionOrApproval) {
     return { kind: "skip", reason: "pending interaction or approval owns the next action" };
   }
