@penclipai/server 2026.704.0 → 2026.714.0

package/dist/services/recovery/service.js

@@ -3,6 +3,7 @@ import { DEFAULT_ISSUE_GRAPH_LIVENESS_AUTO_RECOVERY_LOOKBACK_HOURS, MAX_ISSUE_GR
 import { agents, agentWakeupRequests, approvals, activityLog, companies, heartbeatRunEvents, heartbeatRunWatchdogDecisions, heartbeatRuns, issueAttachments, issueComments, issueApprovals, issueRecoveryActions, issueRelations, issueThreadInteractions, issues, } from "@penclipai/db";
 import { parseObject, asBoolean, asNumber } from "../../adapters/utils.js";
 import { runningProcesses } from "../../adapters/index.js";
+import { visibleIssueCondition } from "../issue-visibility.js";
 import { forbidden, notFound } from "../../errors.js";
 import { logger } from "../../middleware/logger.js";
 import { isPidAlive, isProcessGroupAlive, terminateLocalService } from "../local-service-supervisor.js";
@@ -25,7 +26,7 @@ import { classifyIssueGraphLiveness, } from "./issue-graph-liveness.js";
 import { recoveryAssigneeAdapterOverrides, withRecoveryModelProfileHint, } from "./model-profile-hint.js";
 import { isAutomaticRecoverySuppressedByPauseHold } from "./pause-hold-guard.js";
 const EXECUTION_PATH_HEARTBEAT_RUN_STATUSES = ["queued", "running", "scheduled_retry"];
-const UNSUCCESSFUL_HEARTBEAT_RUN_TERMINAL_STATUSES = ["failed", "cancelled", "timed_out"];
+const UNSUCCESSFUL_HEARTBEAT_RUN_TERMINAL_STATUSES = ["interrupted", "failed", "cancelled", "timed_out"];
 export const ACTIVE_RUN_OUTPUT_SUSPICION_THRESHOLD_MS = 60 * 60 * 1000;
 export const ACTIVE_RUN_OUTPUT_CRITICAL_THRESHOLD_MS = 4 * 60 * 60 * 1000;
 export const ACTIVE_RUN_OUTPUT_CONTINUE_REARM_MS = 30 * 60 * 1000;
@@ -102,6 +103,7 @@ const TRANSIENT_INFRA_CONTINUATION_ERROR_CODES = new Set([
     "adapter_failed",
     "codex_transient_upstream",
     "claude_transient_upstream",
+    "provider_quota",
     "timeout",
 ]);
 const NON_RETRYABLE_CONTINUATION_ERROR_CODES = new Set([
@@ -426,6 +428,17 @@ export function recoveryService(db, deps) {
             .limit(1)
             .then((rows) => Boolean(rows[0]));
     }
+    async function hasPersistedDurableWaitPath(issue) {
+        if (issue.monitorNextCheckAt)
+            return true;
+        return db
+            .select({ id: issueRelations.issueId })
+            .from(issueRelations)
+            .innerJoin(issues, eq(issueRelations.issueId, issues.id))
+            .where(and(eq(issueRelations.companyId, issue.companyId), eq(issueRelations.relatedIssueId, issue.id), eq(issueRelations.type, "blocks"), eq(issues.companyId, issue.companyId), notInArray(issues.status, ["done", "cancelled"]), isNull(issues.hiddenAt)))
+            .limit(1)
+            .then((rows) => Boolean(rows[0]));
+    }
     async function hasQueuedIssueWake(companyId, issueId, agentId) {
         return db
             .select({ id: agentWakeupRequests.id })
@@ -434,6 +447,51 @@ export function recoveryService(db, deps) {
             .limit(1)
             .then((rows) => Boolean(rows[0]));
     }
+    async function getLatestAcceptedContinuationInteraction(companyId, issueId) {
+        return db
+            .select({
+            id: issueThreadInteractions.id,
+            kind: issueThreadInteractions.kind,
+            status: issueThreadInteractions.status,
+            continuationPolicy: issueThreadInteractions.continuationPolicy,
+            sourceRunId: issueThreadInteractions.sourceRunId,
+            resolvedAt: issueThreadInteractions.resolvedAt,
+            updatedAt: issueThreadInteractions.updatedAt,
+        })
+            .from(issueThreadInteractions)
+            .where(and(eq(issueThreadInteractions.companyId, companyId), eq(issueThreadInteractions.issueId, issueId), eq(issueThreadInteractions.status, "accepted"), inArray(issueThreadInteractions.continuationPolicy, ["wake_assignee", "wake_assignee_on_accept"])))
+            .orderBy(desc(sql `coalesce(${issueThreadInteractions.resolvedAt}, ${issueThreadInteractions.updatedAt})`), desc(issueThreadInteractions.id))
+            .limit(1)
+            .then((rows) => rows[0] ?? null);
+    }
+    async function hasSuccessfulIssueRunSince(companyId, issueId, agentId, since, interactionId) {
+        return db
+            .select({ id: heartbeatRuns.id })
+            .from(heartbeatRuns)
+            .where(and(eq(heartbeatRuns.companyId, companyId), eq(heartbeatRuns.agentId, agentId), eq(heartbeatRuns.status, "succeeded"), sql `${heartbeatRuns.contextSnapshot} ->> 'issueId' = ${issueId}`, interactionId
+            ? sql `${heartbeatRuns.contextSnapshot} ->> 'interactionId' = ${interactionId}`
+            : sql `true`, or(gte(heartbeatRuns.createdAt, since), gte(heartbeatRuns.finishedAt, since))))
+            .limit(1)
+            .then((rows) => Boolean(rows[0]));
+    }
+    async function getLatestIssueRunSince(companyId, issueId, agentId, since) {
+        return db
+            .select({
+            id: heartbeatRuns.id,
+            agentId: heartbeatRuns.agentId,
+            status: heartbeatRuns.status,
+            error: heartbeatRuns.error,
+            errorCode: heartbeatRuns.errorCode,
+            contextSnapshot: heartbeatRuns.contextSnapshot,
+            livenessState: heartbeatRuns.livenessState,
+            resultJson: heartbeatRuns.resultJson,
+        })
+            .from(heartbeatRuns)
+            .where(and(eq(heartbeatRuns.companyId, companyId), eq(heartbeatRuns.agentId, agentId), sql `${heartbeatRuns.contextSnapshot} ->> 'issueId' = ${issueId}`, or(gte(heartbeatRuns.createdAt, since), gte(heartbeatRuns.finishedAt, since))))
+            .orderBy(desc(heartbeatRuns.createdAt), desc(heartbeatRuns.id))
+            .limit(1)
+            .then((rows) => rows[0] ?? null);
+    }
     // GGU-809: visible-progress signal for stranded-recovery escalation guard.
     // Returns true if the assignee posted a comment, OR any attachment was added
     // to the issue, within `windowMs`. Used to suppress false-positive recovery
@@ -656,7 +714,7 @@ export function recoveryService(db, deps) {
             updatedAt: issues.updatedAt,
         })
             .from(issues)
-            .where(and(eq(issues.companyId, companyId), eq(issues.originKind, STALE_ACTIVE_RUN_EVALUATION_ORIGIN_KIND), eq(issues.originId, runId), isNull(issues.hiddenAt), notInArray(issues.status, ["done", "cancelled"])))
+            .where(and(eq(issues.companyId, companyId), eq(issues.originKind, STALE_ACTIVE_RUN_EVALUATION_ORIGIN_KIND), eq(issues.originId, runId), visibleIssueCondition(), notInArray(issues.status, ["done", "cancelled"])))
             .limit(1);
         return row ?? null;
     }
@@ -673,7 +731,7 @@ export function recoveryService(db, deps) {
         const [row] = await db
             .select({ id: issues.id, identifier: issues.identifier, status: issues.status })
             .from(issues)
-            .where(and(eq(issues.companyId, companyId), eq(issues.originKind, STALE_ACTIVE_RUN_EVALUATION_ORIGIN_KIND), eq(issues.originId, runId), isNull(issues.hiddenAt), eq(issues.status, "done")))
+            .where(and(eq(issues.companyId, companyId), eq(issues.originKind, STALE_ACTIVE_RUN_EVALUATION_ORIGIN_KIND), eq(issues.originId, runId), visibleIssueCondition(), eq(issues.status, "done")))
             .orderBy(desc(issues.updatedAt))
             .limit(1);
         return row ?? null;
@@ -750,7 +808,7 @@ export function recoveryService(db, deps) {
         const [issue] = await db
             .select()
             .from(issues)
-            .where(and(eq(issues.companyId, run.companyId), eq(issues.id, issueId), isNull(issues.hiddenAt)))
+            .where(and(eq(issues.companyId, run.companyId), eq(issues.id, issueId), visibleIssueCondition()))
             .limit(1);
         return issue ?? null;
     }
@@ -1060,7 +1118,7 @@ export function recoveryService(db, deps) {
                 ? db
                     .select({ id: issues.id, identifier: issues.identifier, title: issues.title, status: issues.status })
                     .from(issues)
-                    .where(and(eq(issues.companyId, input.run.companyId), eq(issues.parentId, input.sourceIssue.id), isNull(issues.hiddenAt)))
+                    .where(and(eq(issues.companyId, input.run.companyId), eq(issues.parentId, input.sourceIssue.id), visibleIssueCondition()))
                     .orderBy(desc(issues.updatedAt))
                     .limit(8)
                 : Promise.resolve([]),
@@ -1414,12 +1472,27 @@ export function recoveryService(db, deps) {
     async function scanSilentActiveRuns(opts) {
         const now = opts?.now ?? new Date();
         const suspicionBefore = new Date(now.getTime() - ACTIVE_RUN_OUTPUT_SUSPICION_THRESHOLD_MS);
-        const candidates = await db
+        let candidates = await db
             .select()
             .from(heartbeatRuns)
             .where(and(opts?.companyId ? eq(heartbeatRuns.companyId, opts.companyId) : undefined, eq(heartbeatRuns.status, "running"), sql `coalesce(${heartbeatRuns.lastOutputAt}, ${heartbeatRuns.processStartedAt}, ${heartbeatRuns.startedAt}, ${heartbeatRuns.createdAt}) <= ${suspicionBefore.toISOString()}::timestamptz`))
             .orderBy(asc(heartbeatRuns.createdAt))
             .limit(100);
+        if (opts?.issueCreatedAtGte) {
+            const issueIds = [...new Set(candidates.flatMap((run) => {
+                    const context = parseObject(run.contextSnapshot);
+                    const issueId = context.issueId ?? context.taskId;
+                    return typeof issueId === "string" && issueId.length > 0 ? [issueId] : [];
+                }))];
+            const eligibleIssueIds = new Set(issueIds.length > 0
+                ? (await db.select({ id: issues.id }).from(issues).where(and(inArray(issues.id, issueIds), gte(issues.createdAt, opts.issueCreatedAtGte)))).map((issue) => issue.id)
+                : []);
+            candidates = candidates.filter((run) => {
+                const context = parseObject(run.contextSnapshot);
+                const issueId = context.issueId ?? context.taskId;
+                return typeof issueId === "string" && eligibleIssueIds.has(issueId);
+            });
+        }
         const result = {
             scanned: candidates.length,
             created: 0,
@@ -1563,7 +1636,7 @@ export function recoveryService(db, deps) {
         return db
             .select()
             .from(issues)
-            .where(and(eq(issues.companyId, companyId), eq(issues.originKind, STRANDED_ISSUE_RECOVERY_ORIGIN_KIND), eq(issues.originId, sourceIssueId), isNull(issues.hiddenAt), notInArray(issues.status, ["done", "cancelled"])))
+            .where(and(eq(issues.companyId, companyId), eq(issues.originKind, STRANDED_ISSUE_RECOVERY_ORIGIN_KIND), eq(issues.originId, sourceIssueId), visibleIssueCondition(), notInArray(issues.status, ["done", "cancelled"])))
             .orderBy(desc(issues.createdAt))
             .limit(1)
             .then((rows) => rows[0] ?? null);
@@ -2008,7 +2081,7 @@ export function recoveryService(db, deps) {
         const openChildren = await db
             .select({ id: issues.id, identifier: issues.identifier })
             .from(issues)
-            .where(and(eq(issues.companyId, issue.companyId), eq(issues.parentId, issue.id), isNull(issues.hiddenAt), notInArray(issues.status, ["done", "cancelled"])));
+            .where(and(eq(issues.companyId, issue.companyId), eq(issues.parentId, issue.id), visibleIssueCondition(), notInArray(issues.status, ["done", "cancelled"])));
         const blockedByIssueIds = [...new Set([...existingBlockers.map((row) => row.id), ...openChildren.map((row) => row.id)])];
         if (blockedByIssueIds.length === 0)
             return null;
@@ -2189,11 +2262,11 @@ export function recoveryService(db, deps) {
         }
         return updated;
     }
-    async function reconcileStrandedAssignedIssues() {
+    async function reconcileStrandedAssignedIssues(opts) {
         const candidates = await db
             .select()
             .from(issues)
-            .where(and(isNull(issues.assigneeUserId), inArray(issues.status, ["todo", "in_progress", "in_review"]), or(sql `${issues.assigneeAgentId} is not null`, eq(issues.status, "in_review"))));
+            .where(and(isNull(issues.assigneeUserId), inArray(issues.status, ["todo", "in_progress", "in_review"]), or(sql `${issues.assigneeAgentId} is not null`, eq(issues.status, "in_review")), opts?.issueCreatedAtGte ? gte(issues.createdAt, opts.issueCreatedAtGte) : undefined));
         const result = {
             assignmentDispatched: 0,
             dispatchRequeued: 0,
@@ -2246,6 +2319,10 @@ export function recoveryService(db, deps) {
                 continue;
             }
             const latestRun = await getLatestIssueRun(issue.companyId, issue.id);
+            if (latestRun?.status === "succeeded" && await hasPersistedDurableWaitPath(issue)) {
+                result.skipped += 1;
+                continue;
+            }
             if (isStrandedIssueRecoveryIssue(issue) && isUnsuccessfulTerminalIssueRun(latestRun)) {
                 const updated = await escalateStrandedRecoveryIssueInPlace({
                     issue,
@@ -2261,6 +2338,52 @@ export function recoveryService(db, deps) {
                 }
                 continue;
             }
+            const acceptedContinuationInteraction = await getLatestAcceptedContinuationInteraction(issue.companyId, issue.id);
+            const acceptedInteractionResolvedAt = acceptedContinuationInteraction
+                ? acceptedContinuationInteraction.resolvedAt ?? acceptedContinuationInteraction.updatedAt
+                : null;
+            if (acceptedContinuationInteraction && acceptedInteractionResolvedAt && !pendingExecutionState) {
+                const successfulRunSinceResolution = await hasSuccessfulIssueRunSince(issue.companyId, issue.id, agentId, acceptedInteractionResolvedAt, acceptedContinuationInteraction.id);
+                if (!successfulRunSinceResolution) {
+                    if (!agentInvokable) {
+                        result.skipped += 1;
+                        continue;
+                    }
+                    if (await hasQueuedIssueWake(issue.companyId, issue.id, agentId)) {
+                        result.skipped += 1;
+                        continue;
+                    }
+                    if (await isInvocationBudgetBlocked(issue, agentId)) {
+                        result.skipped += 1;
+                        continue;
+                    }
+                    const latestPostResolutionRun = await getLatestIssueRunSince(issue.companyId, issue.id, agentId, acceptedInteractionResolvedAt);
+                    const queued = await enqueueStrandedIssueRecovery({
+                        issueId: issue.id,
+                        agentId,
+                        reason: "issue_continuation_needed",
+                        retryReason: "issue_continuation_needed",
+                        source: "issue.interaction_continuation_recovery",
+                        retryOfRunId: latestPostResolutionRun?.id ?? acceptedContinuationInteraction.sourceRunId ?? latestRun?.id ?? null,
+                        extraContext: {
+                            mutation: "interaction",
+                            interactionId: acceptedContinuationInteraction.id,
+                            interactionKind: acceptedContinuationInteraction.kind,
+                            interactionStatus: acceptedContinuationInteraction.status,
+                            interactionContinuationPolicy: acceptedContinuationInteraction.continuationPolicy,
+                            interactionResolvedAt: acceptedInteractionResolvedAt.toISOString(),
+                        },
+                    });
+                    if (queued) {
+                        result.continuationRequeued += 1;
+                        result.issueIds.push(issue.id);
+                    }
+                    else {
+                        result.skipped += 1;
+                    }
+                    continue;
+                }
+            }
             if (issue.status === "in_review") {
                 if (!participantAgentId || !pendingExecutionState) {
                     result.skipped += 1;
@@ -2611,7 +2734,7 @@ export function recoveryService(db, deps) {
             monitorAttemptCount: issues.monitorAttemptCount,
         })
             .from(issues)
-            .where(and(isNull(issues.hiddenAt), notInArray(issues.originKind, [RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation]))));
+            .where(and(visibleIssueCondition(), notInArray(issues.originKind, [RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation]))));
         const [issueRows, relationRows, agentRows, activeRunRows, activeIssueRunRows, wakeRows, interactionRows, approvalRows, recoveryIssueRows, recoveryActionRows,] = await Promise.all([
             issueRowsPromise,
             db
@@ -2651,7 +2774,7 @@ export function recoveryService(db, deps) {
             })
                 .from(issues)
                 .innerJoin(heartbeatRuns, eq(issues.executionRunId, heartbeatRuns.id))
-                .where(and(isNull(issues.hiddenAt), notInArray(issues.originKind, [RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation]), inArray(heartbeatRuns.status, [...EXECUTION_PATH_HEARTBEAT_RUN_STATUSES]))),
+                .where(and(visibleIssueCondition(), notInArray(issues.originKind, [RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation]), inArray(heartbeatRuns.status, [...EXECUTION_PATH_HEARTBEAT_RUN_STATUSES]))),
             db
                 .select({
                 companyId: agentWakeupRequests.companyId,
@@ -2687,7 +2810,7 @@ export function recoveryService(db, deps) {
                 originId: issues.originId,
             })
                 .from(issues)
-                .where(and(isNull(issues.hiddenAt), inArray(issues.originKind, [
+                .where(and(visibleIssueCondition(), inArray(issues.originKind, [
                 STRANDED_ISSUE_RECOVERY_ORIGIN_KIND,
                 RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation,
             ]), notInArray(issues.status, ["done", "cancelled"]))),
@@ -2763,7 +2886,7 @@ export function recoveryService(db, deps) {
         return db
             .select()
             .from(issues)
-            .where(and(eq(issues.companyId, companyId), eq(issues.originKind, RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation), eq(issues.originId, incidentKey), isNull(issues.hiddenAt), notInArray(issues.status, ["done", "cancelled"])))
+            .where(and(eq(issues.companyId, companyId), eq(issues.originKind, RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation), eq(issues.originId, incidentKey), visibleIssueCondition(), notInArray(issues.status, ["done", "cancelled"])))
             .limit(1)
             .then((rows) => rows[0] ?? null);
     }
@@ -2771,7 +2894,7 @@ export function recoveryService(db, deps) {
         const byFingerprint = await db
             .select()
             .from(issues)
-            .where(and(eq(issues.companyId, finding.companyId), eq(issues.originKind, RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation), eq(issues.originFingerprint, livenessRecoveryLeafFingerprint(finding)), isNull(issues.hiddenAt), notInArray(issues.status, ["done", "cancelled"])))
+            .where(and(eq(issues.companyId, finding.companyId), eq(issues.originKind, RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation), eq(issues.originFingerprint, livenessRecoveryLeafFingerprint(finding)), visibleIssueCondition(), notInArray(issues.status, ["done", "cancelled"])))
             .limit(1)
             .then((rows) => rows[0] ?? null);
         if (byFingerprint)
@@ -2780,7 +2903,7 @@ export function recoveryService(db, deps) {
         const openRecoveries = await db
             .select()
             .from(issues)
-            .where(and(eq(issues.companyId, finding.companyId), eq(issues.originKind, RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation), isNull(issues.hiddenAt), notInArray(issues.status, ["done", "cancelled"])));
+            .where(and(eq(issues.companyId, finding.companyId), eq(issues.originKind, RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation), visibleIssueCondition(), notInArray(issues.status, ["done", "cancelled"])));
         return openRecoveries.find((row) => {
             const parsed = parseLivenessIncidentKey(row.originId);
             return parsed?.state === finding.state && parsed.leafIssueId === leafIssueId;
@@ -2830,7 +2953,7 @@ export function recoveryService(db, deps) {
         const openRecoveries = await db
             .select()
             .from(issues)
-            .where(and(eq(issues.originKind, RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation), isNull(issues.hiddenAt), notInArray(issues.status, ["done", "cancelled"])));
+            .where(and(eq(issues.originKind, RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation), visibleIssueCondition(), notInArray(issues.status, ["done", "cancelled"])));
         const result = {
             retired: 0,
             activeSkipped: 0,
@@ -2878,7 +3001,7 @@ export function recoveryService(db, deps) {
         const closedRecoveries = await db
             .select()
             .from(issues)
-            .where(and(eq(issues.originKind, RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation), isNull(issues.hiddenAt), inArray(issues.status, ["done", "cancelled"])));
+            .where(and(eq(issues.originKind, RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation), visibleIssueCondition(), inArray(issues.status, ["done", "cancelled"])));
         let blockerRelationsRemoved = 0;
         for (const recovery of closedRecoveries) {
             if (await removeRecoveryBlockerFromSource(recovery)) {
@@ -3221,14 +3344,40 @@ export function recoveryService(db, deps) {
             enqueueFailed: 0,
             issueIds: [],
         };
+        const source = opts?.source ?? "issue_graph_liveness.backstop";
+        const requestedByActorId = source === "workspace.finalize"
+            ? "heartbeat_finalize"
+            : "issue_graph_liveness_backstop";
+        const payloadBackstop = source === "workspace.finalize"
+            ? "workspace_finalize_reconciliation"
+            : "issue_graph_liveness_reconciliation";
+        const useCursor = !opts?.blockerIssueId;
         const queryCandidates = (afterIssueId) => {
             const filters = [
                 eq(issues.status, "blocked"),
-                isNull(issues.hiddenAt),
+                visibleIssueCondition(),
                 sql `${issues.assigneeAgentId} is not null`,
             ];
+            if (opts?.companyId)
+                filters.push(eq(issues.companyId, opts.companyId));
             if (afterIssueId)
                 filters.push(gt(issues.id, afterIssueId));
+            if (opts?.blockerIssueId) {
+                filters.push(eq(issueRelations.companyId, issues.companyId), eq(issueRelations.type, "blocks"), eq(issueRelations.issueId, opts.blockerIssueId), eq(issueRelations.relatedIssueId, issues.id));
+                return db
+                    .select({
+                    id: issues.id,
+                    companyId: issues.companyId,
+                    identifier: issues.identifier,
+                    assigneeAgentId: issues.assigneeAgentId,
+                    totalCount: sql `count(*) over()::int`,
+                })
+                    .from(issueRelations)
+                    .innerJoin(issues, eq(issueRelations.relatedIssueId, issues.id))
+                    .where(and(...filters))
+                    .orderBy(asc(issues.id))
+                    .limit(RESOLVED_DEPENDENCY_WAKE_BACKSTOP_CANDIDATE_LIMIT);
+            }
             return db
                 .select({
                 id: issues.id,
@@ -3242,8 +3391,8 @@ export function recoveryService(db, deps) {
                 .orderBy(asc(issues.id))
                 .limit(RESOLVED_DEPENDENCY_WAKE_BACKSTOP_CANDIDATE_LIMIT);
         };
-        let candidateRows = await queryCandidates(resolvedDependencyWakeBackstopCandidateCursor);
-        if (candidateRows.length === 0 && resolvedDependencyWakeBackstopCandidateCursor) {
+        let candidateRows = await queryCandidates(useCursor ? resolvedDependencyWakeBackstopCandidateCursor : null);
+        if (useCursor && candidateRows.length === 0 && resolvedDependencyWakeBackstopCandidateCursor) {
             resolvedDependencyWakeBackstopCandidateCursor = null;
             candidateRows = await queryCandidates(null);
         }
@@ -3252,14 +3401,18 @@ export function recoveryService(db, deps) {
         result.checked = candidates.length;
         result.candidateLimitSkipped = Math.max(0, totalCandidateCount - candidates.length);
         const lastCandidate = candidates[candidates.length - 1] ?? null;
-        resolvedDependencyWakeBackstopCandidateCursor =
-            result.candidateLimitSkipped > 0 && lastCandidate ? lastCandidate.id : null;
+        if (useCursor) {
+            resolvedDependencyWakeBackstopCandidateCursor =
+                result.candidateLimitSkipped > 0 && lastCandidate ? lastCandidate.id : null;
+        }
         if (result.candidateLimitSkipped > 0) {
             logger.warn({
                 processed: candidates.length,
                 skipped: result.candidateLimitSkipped,
                 limit: RESOLVED_DEPENDENCY_WAKE_BACKSTOP_CANDIDATE_LIMIT,
-                nextCursor: resolvedDependencyWakeBackstopCandidateCursor,
+                nextCursor: useCursor ? resolvedDependencyWakeBackstopCandidateCursor : null,
+                source,
+                blockerIssueId: opts?.blockerIssueId ?? null,
             }, "issue graph liveness backstop deferred resolved dependency wake candidates past page limit");
         }
         const candidatesByCompany = new Map();
@@ -3321,16 +3474,16 @@ export function recoveryService(db, deps) {
                             issueId: candidate.id,
                             resolvedBlockerIssueId,
                             blockerIssueIds: readiness.blockerIssueIds,
-                            backstop: "issue_graph_liveness_reconciliation",
+                            backstop: payloadBackstop,
                         },
                         idempotencyKey,
                         requestedByActorType: "system",
-                        requestedByActorId: "issue_graph_liveness_backstop",
+                        requestedByActorId,
                         contextSnapshot: {
                             issueId: candidate.id,
                             taskId: candidate.id,
                             wakeReason: ISSUE_BLOCKERS_RESOLVED_WAKE_REASON,
-                            source: "issue_graph_liveness.backstop",
+                            source,
                             resolvedBlockerIssueId,
                             blockerIssueIds: readiness.blockerIssueIds,
                         },
@@ -3354,7 +3507,7 @@ export function recoveryService(db, deps) {
                         entityType: "issue",
                         entityId: candidate.id,
                         details: {
-                            source: "issue_graph_liveness.backstop",
+                            source,
                             wakeupRunId: wake.id,
                             idempotencyKey,
                             resolvedBlockerIssueId,
@@ -3365,17 +3518,28 @@ export function recoveryService(db, deps) {
                 catch (err) {
                     result.deferredOrFailed += 1;
                     result.enqueueFailed += 1;
-                    logger.warn({ err, issueId: candidate.id, agentId, idempotencyKey }, "failed to enqueue dependency wake from issue graph liveness backstop");
+                    logger.warn({ err, issueId: candidate.id, agentId, idempotencyKey, source }, "failed to enqueue dependency wake from issue graph liveness backstop");
                 }
             }
         }
         if (result.healed > 0) {
-            logger.warn({ healed: result.healed, issueIds: result.issueIds }, "issue graph liveness backstop healed resolved blocked dependency wakes");
+            logger.warn({ healed: result.healed, issueIds: result.issueIds, source, blockerIssueId: opts?.blockerIssueId ?? null }, "issue graph liveness backstop healed resolved blocked dependency wakes");
         }
         return result;
     }
     async function reconcileIssueGraphLiveness(opts) {
-        const findings = await collectIssueGraphLivenessFindings();
+        let findings = await collectIssueGraphLivenessFindings();
+        if (opts?.issueCreatedAtGte) {
+            const findingIssueIds = [...new Set(findings.map((finding) => finding.recoveryIssueId))];
+            const eligibleIssueIds = new Set(findingIssueIds.length === 0
+                ? []
+                : (await db
+                    .select({ id: issues.id })
+                    .from(issues)
+                    .where(and(inArray(issues.id, findingIssueIds), gte(issues.createdAt, opts.issueCreatedAtGte))))
+                    .map((issue) => issue.id));
+            findings = findings.filter((finding) => eligibleIssueIds.has(finding.recoveryIssueId));
+        }
         const experimentalSettings = await instanceSettings.getExperimental();
         const autoRecoveryEnabled = asBoolean(experimentalSettings.enableIssueGraphLivenessAutoRecovery, true) || opts?.force === true;
         const lookbackHours = normalizeIssueGraphLivenessAutoRecoveryLookbackHours(opts?.lookbackHours ?? experimentalSettings.issueGraphLivenessAutoRecoveryLookbackHours);
@@ -3413,10 +3577,6 @@ export function recoveryService(db, deps) {
             escalationIssueIds: [],
             retiredRecoveryIssueIds: obsoleteRecoveryCleanup.retiredIssueIds,
         };
-        if (!autoRecoveryEnabled) {
-            result.skippedAutoRecoveryDisabled = findings.length;
-            return result;
-        }
         const dependencyWakeBackstop = await reconcileResolvedDependencyWakeBackstop({
             runId: opts?.runId ?? null,
         });
@@ -3431,6 +3591,10 @@ export function recoveryService(db, deps) {
         result.dependencyWakeDeferredOrFailed = dependencyWakeBackstop.deferredOrFailed;
         result.dependencyWakeEnqueueFailed = dependencyWakeBackstop.enqueueFailed;
         result.dependencyWakeIssueIds = dependencyWakeBackstop.issueIds;
+        if (!autoRecoveryEnabled) {
+            result.skippedAutoRecoveryDisabled = findings.length;
+            return result;
+        }
         for (const finding of findings) {
             if (!isLivenessFindingInsideAutoRecoveryLookback(finding, cutoff, updatedAtByIssueKey)) {
                 result.skippedOutsideLookback += 1;
@@ -3557,6 +3721,7 @@ export function recoveryService(db, deps) {
         reconcileStrandedAssignedIssues,
         sweepStaleIssueLocks,
         buildIssueGraphLivenessAutoRecoveryPreview,
+        reconcileResolvedDependencyWakeBackstop,
         reconcileIssueGraphLiveness,
         readRecoveryTimerIntervalMs,
     };