@paperclipai/server 2026.824.0 → 2026.825.0-beta.1

package/dist/services/recovery/service.js

@@ -1,5 +1,5 @@
 import { and, asc, desc, eq, gt, gte, inArray, isNull, notInArray, or, sql } from "drizzle-orm";
-import { DEFAULT_ISSUE_GRAPH_LIVENESS_AUTO_RECOVERY_LOOKBACK_HOURS, MAX_ISSUE_GRAPH_LIVENESS_AUTO_RECOVERY_LOOKBACK_HOURS, MIN_ISSUE_GRAPH_LIVENESS_AUTO_RECOVERY_LOOKBACK_HOURS, PROVIDER_QUOTA_MONITOR_SERVICE_NAME, } from "@paperclipai/shared";
+import { DEFAULT_ISSUE_GRAPH_LIVENESS_AUTO_RECOVERY_LOOKBACK_HOURS, MAX_ISSUE_GRAPH_LIVENESS_AUTO_RECOVERY_LOOKBACK_HOURS, MIN_ISSUE_GRAPH_LIVENESS_AUTO_RECOVERY_LOOKBACK_HOURS, PROVIDER_QUOTA_MONITOR_SERVICE_NAME, ISSUE_DISPOSITION_REPAIR_RETRY_REASON, } from "@paperclipai/shared";
 import { agents, agentWakeupRequests, approvals, activityLog, companies, heartbeatRunEvents, heartbeatRunWatchdogDecisions, heartbeatRuns, issueAttachments, issueComments, issueApprovals, issueRecoveryActions, issueRelations, issueThreadInteractions, issues, } from "@paperclipai/db";
 import { parseObject, asBoolean, asNumber } from "../../adapters/utils.js";
 import { runningProcesses } from "../../adapters/index.js";
@@ -9,6 +9,7 @@ import { logger } from "../../middleware/logger.js";
 import { isPidAlive, isProcessGroupAlive, terminateLocalService } from "../local-service-supervisor.js";
 import { redactCurrentUserText } from "../../log-redaction.js";
 import { redactSensitiveText } from "../../redaction.js";
+import { isUniqueViolation } from "../../db-errors.js";
 import { logActivity } from "../activity-log.js";
 import { budgetService } from "../budgets.js";
 import { instanceSettingsService } from "../instance-settings.js";
@@ -16,8 +17,9 @@ import { issueRecoveryActionService } from "../issue-recovery-actions.js";
 import { issueTreeControlService } from "../issue-tree-control.js";
 import { TERMINAL_HEARTBEAT_RUN_STATUSES, issueService } from "../issues.js";
 import { applyIssueMonitorPolicyTransition, normalizeIssueExecutionPolicy, parseIssueExecutionState, } from "../issue-execution-policy.js";
-import { ISSUE_BLOCKERS_RESOLVED_WAKE_REASON, buildIssueBlockersResolvedWakeIdempotencyKey, findExistingIssueBlockersResolvedWakeForAnyKey, } from "../issue-dependency-wakeups.js";
+import { ISSUE_BLOCKERS_RESOLVED_WAKE_REASON, buildIssueBlockersResolvedWakeStateKey, findExistingIssueBlockersResolvedWakeForReadyState, } from "../issue-dependency-wakeups.js";
 import { evaluateAgentInvokabilityFromDb } from "../agent-invokability.js";
+import { isHeartbeatWakeOnDemandEnabled } from "../heartbeat-policy.js";
 import { getRunLogStore } from "../run-log-store.js";
 import { DEFAULT_MAX_SUCCESSFUL_RUN_HANDOFF_ATTEMPTS, FINISH_SUCCESSFUL_RUN_HANDOFF_REASON, SUCCESSFUL_RUN_MISSING_STATE_REASON, buildSuccessfulRunHandoffExhaustedNotice, isPluginManagedIssueLifecycle, noticeMetadataReferencesRecoveryAction, } from "./successful-run-handoff.js";
 import { buildExecutionReviewParticipantRecoveryNoticeSeed, buildExecutionReviewParticipantUnavailableNoticeSeed, buildStrandedRecoveryEscalationNotice, } from "./stranded-notice.js";
@@ -25,6 +27,7 @@ import { RECOVERY_ORIGIN_KINDS, buildIssueGraphLivenessLeafKey, isStrandedIssueR
 import { classifyIssueGraphLiveness, } from "./issue-graph-liveness.js";
 import { recoveryAssigneeAdapterOverrides, withRecoveryModelProfileHint, } from "./model-profile-hint.js";
 import { isAutomaticRecoverySuppressedByPauseHold } from "./pause-hold-guard.js";
+import { collectDispositionRepairSourceState, dispositionRepairDelayMs, DISPOSITION_REPAIR_MAX_ATTEMPTS, } from "./disposition-repair.js";
 const EXECUTION_PATH_HEARTBEAT_RUN_STATUSES = ["queued", "running", "scheduled_retry"];
 const UNSUCCESSFUL_HEARTBEAT_RUN_TERMINAL_STATUSES = ["interrupted", "failed", "cancelled", "timed_out"];
 export const ACTIVE_RUN_OUTPUT_SUSPICION_THRESHOLD_MS = 60 * 60 * 1000;
@@ -36,6 +39,8 @@ const STRANDED_ISSUE_RECOVERY_ORIGIN_KIND = RECOVERY_ORIGIN_KINDS.strandedIssueR
 const STALE_ACTIVE_RUN_EVALUATION_ORIGIN_KIND = RECOVERY_ORIGIN_KINDS.staleActiveRunEvaluation;
 const DEFERRED_WAKE_CONTEXT_KEY = "_paperclipWakeContext";
 const EXECUTION_REVIEW_PARTICIPANT_RECOVERY_REASON = "execution_review_participant_recovery";
+const STRANDED_BOARD_ESCALATION_POLICY = "board_escalation_no_takeover_v1";
+const DISPOSITION_REPAIR_IDEMPOTENCY_INDEX = "agent_wakeup_requests_disposition_repair_idempotency_uq";
 const RESOLVED_DEPENDENCY_WAKE_BACKSTOP_CANDIDATE_LIMIT = 500;
 const SESSIONED_LOCAL_ADAPTERS = new Set([
     "claude_local",
@@ -43,6 +48,7 @@ const SESSIONED_LOCAL_ADAPTERS = new Set([
     "cursor",
     "gemini_local",
     "hermes_local",
+    "kimi_local",
     "opencode_local",
     "pi_local",
 ]);
@@ -147,6 +153,10 @@ function readWorkspaceValidationFingerprint(latestRun) {
     const payload = readWorkspaceValidationPayload(latestRun);
     return readNonEmptyString(payload?.fingerprint);
 }
+function readConfigurationIncompleteFingerprint(latestRun) {
+    const payload = parseObject(parseObject(latestRun?.resultJson).configurationIncomplete);
+    return readNonEmptyString(payload?.fingerprint);
+}
 function readNonEmptyString(value) {
     return typeof value === "string" && value.trim().length > 0 ? value : null;
 }
@@ -287,6 +297,14 @@ export function classifyAdapterFailureForRecovery(latestRun, now = new Date()) {
 }
 export function classifyContinuationFailure(latestRun) {
     const errorCode = readNonEmptyString(latestRun?.errorCode);
+    if (errorCode === CONTINUATION_WAITING_ON_REVIEW_ERROR_CODE) {
+        return {
+            kind: "deliberate_wait_without_target",
+            maxAttempts: DISPOSITION_REPAIR_MAX_ATTEMPTS,
+            baseBackoffMs: CONTINUATION_RECOVERY_TRANSIENT_BASE_BACKOFF_MS,
+            errorCode,
+        };
+    }
     if (errorCode && NON_RETRYABLE_CONTINUATION_ERROR_CODES.has(errorCode)) {
         return { kind: "non_retryable", maxAttempts: 0, baseBackoffMs: 0, errorCode };
     }
@@ -1307,8 +1325,11 @@ export function recoveryService(db, deps) {
                 issueId: input.sourceIssue?.id ?? null,
                 projectId: input.sourceIssue?.projectId ?? null,
             });
-            if ((await isAgentInvokable(candidate)) && !budgetBlock)
+            if ((await isAgentInvokable(candidate)) &&
+                isHeartbeatWakeOnDemandEnabled(candidate) &&
+                !budgetBlock) {
                 return candidate.id;
+            }
         }
         return null;
     }
@@ -1423,15 +1444,6 @@ export function recoveryService(db, deps) {
                 maybe.constraint_name === "issues_active_stale_run_evaluation_uq" ||
                 typeof maybe.message === "string" && maybe.message.includes("issues_active_stale_run_evaluation_uq"));
     }
-    function isUniqueStrandedIssueRecoveryConflict(error) {
-        const maybe = unwrapDatabaseConflictError(error);
-        if (!maybe)
-            return false;
-        return maybe.code === "23505" &&
-            (maybe.constraint === "issues_active_stranded_issue_recovery_uq" ||
-                maybe.constraint_name === "issues_active_stranded_issue_recovery_uq" ||
-                typeof maybe.message === "string" && maybe.message.includes("issues_active_stranded_issue_recovery_uq"));
-    }
     async function ensureSourceIssueCommentedForStaleEvaluation(input) {
         if (!input.sourceIssue || ["done", "cancelled"].includes(input.sourceIssue.status))
             return false;
@@ -1856,15 +1868,6 @@ export function recoveryService(db, deps) {
         });
         return row;
     }
-    async function findOpenStrandedIssueRecoveryIssue(companyId, sourceIssueId) {
-        return db
-            .select()
-            .from(issues)
-            .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);
-    }
     function isStrandedIssueRecoveryIssue(issue) {
         return issue.originKind === STRANDED_ISSUE_RECOVERY_ORIGIN_KIND;
     }
@@ -1889,260 +1892,22 @@ export function recoveryService(db, deps) {
             "- Next action: the assigned recovery owner or board operator should fix the runtime/adapter problem, resolve or reassign the original source issue, then mark this recovery issue done or cancelled.",
         ].join("\n");
     }
-    async function resolveStrandedIssueRecoveryOwnerAgentId(issue, preferredOwnerAgentId) {
-        const candidateIds = [];
-        if (preferredOwnerAgentId)
-            candidateIds.push(preferredOwnerAgentId);
-        if (issue.assigneeAgentId) {
-            const assignee = await getAgent(issue.assigneeAgentId);
-            if (assignee?.reportsTo)
-                candidateIds.push(assignee.reportsTo);
-        }
-        if (issue.createdByAgentId) {
-            const creator = await getAgent(issue.createdByAgentId);
-            if (creator?.reportsTo)
-                candidateIds.push(creator.reportsTo);
-            candidateIds.push(issue.createdByAgentId);
-        }
-        const roleCandidates = await db
-            .select()
-            .from(agents)
-            .where(and(eq(agents.companyId, issue.companyId), inArray(agents.role, ["cto", "ceo"])))
-            .orderBy(sql `case when ${agents.role} = 'cto' then 0 else 1 end`, asc(agents.createdAt));
-        candidateIds.push(...roleCandidates.map((agent) => agent.id));
-        if (issue.assigneeAgentId)
-            candidateIds.push(issue.assigneeAgentId);
-        const seen = new Set();
-        for (const agentId of candidateIds) {
-            if (seen.has(agentId))
-                continue;
-            seen.add(agentId);
-            const candidate = await getAgent(agentId);
-            if (!candidate || candidate.companyId !== issue.companyId)
-                continue;
-            const budgetBlock = await budgets.getInvocationBlock(issue.companyId, candidate.id, {
-                issueId: issue.id,
-                projectId: issue.projectId,
-            });
-            if ((await isAgentInvokable(candidate)) && !budgetBlock)
-                return candidate.id;
-        }
-        return null;
-    }
-    async function resolveInvokableRecoveryAgentId(issue, agentId) {
-        if (!agentId)
-            return null;
-        const candidate = await getAgent(agentId);
-        if (!candidate || candidate.companyId !== issue.companyId)
-            return null;
-        const budgetBlock = await budgets.getInvocationBlock(issue.companyId, candidate.id, {
-            issueId: issue.id,
-            projectId: issue.projectId,
-        });
-        return (await isAgentInvokable(candidate)) && !budgetBlock ? candidate.id : null;
-    }
-    async function resolveStrandedRecoveryRouting(input) {
-        const originalAgentId = input.latestRun?.agentId ?? input.issue.assigneeAgentId;
-        const returnOwnerAgentId = input.issue.assigneeAgentId ?? originalAgentId;
-        const routeToOriginal = input.recoveryCause === "process_lost" ||
-            input.recoveryCause === SUCCESSFUL_RUN_MISSING_STATE_REASON ||
-            input.recoveryCause === "codex_output_inactivity_monitor";
-        if (input.recoveryCause === "provider_quota") {
-            const retryAgentId = await resolveInvokableRecoveryAgentId(input.issue, originalAgentId);
-            if (!retryAgentId) {
-                return {
-                    ownerAgentId: await resolveStrandedIssueRecoveryOwnerAgentId(input.issue),
-                    returnOwnerAgentId: originalAgentId,
-                    routingFallbackReason: "The original assignee is not invokable; quota recovery fell through to the manager ladder.",
-                };
-            }
-            return {
-                ownerAgentId: null,
-                returnOwnerAgentId: retryAgentId,
-                routingFallbackReason: null,
-            };
-        }
-        if (routeToOriginal) {
-            const ownerAgentId = await resolveInvokableRecoveryAgentId(input.issue, originalAgentId);
-            if (ownerAgentId) {
-                return { ownerAgentId, returnOwnerAgentId: originalAgentId, routingFallbackReason: null };
-            }
-            return {
-                ownerAgentId: await resolveStrandedIssueRecoveryOwnerAgentId(input.issue),
-                returnOwnerAgentId: originalAgentId,
-                routingFallbackReason: "The original assignee is not invokable; recovery fell through to the manager ladder.",
-            };
-        }
+    function resolveStrandedRecoveryRouting(input) {
+        const originalAgentId = input.issue.assigneeAgentId ?? input.latestRun?.agentId ?? null;
         return {
-            ownerAgentId: await resolveStrandedIssueRecoveryOwnerAgentId(input.issue, input.preferredOwnerAgentId),
-            returnOwnerAgentId,
-            routingFallbackReason: null,
+            returnOwnerAgentId: originalAgentId,
         };
     }
-    function buildStrandedIssueRecoveryDescription(input) {
-        const sourceIssue = issueUiLink({ identifier: input.issue.identifier, id: input.issue.id }, input.prefix);
-        const runLink = input.latestRun
-            ? `[\`${input.latestRun.id}\`](/${input.prefix}/agents/${input.latestRun.agentId}/runs/${input.latestRun.id})`
-            : "none";
-        if (input.recoveryCause === SUCCESSFUL_RUN_MISSING_STATE_REASON) {
-            const sourceRunId = input.successfulRunHandoffEvidence?.sourceRunId;
-            const sourceRunLink = sourceRunId && input.latestRun
-                ? `[\`${sourceRunId}\`](/${input.prefix}/agents/${input.latestRun.agentId}/runs/${sourceRunId})`
-                : "unknown";
-            const missingDisposition = input.successfulRunHandoffEvidence?.missingDisposition ?? "clear_next_step";
-            return [
-                "Paperclip exhausted the bounded corrective handoff for a successful run that still has no valid issue disposition.",
-                "",
-                "This is not a runtime/adapter crash report. The source run succeeded; the remaining problem is the missing `done`, `in_review`, `blocked`, delegated follow-up, or explicit continuation path.",
-                "",
-                "## Safe Evidence",
-                "",
-                `- Source issue: ${sourceIssue}`,
-                `- Source run: ${sourceRunLink}`,
-                `- Corrective handoff run: ${runLink}`,
-                `- Source assignee: ${agentUiLink(input.sourceAssignee ?? null, input.prefix)}`,
-                `- Latest issue status: \`${input.issue.status}\``,
-                `- Latest handoff run status: \`${input.latestRun?.status ?? "unknown"}\``,
-                `- Normalized cause: \`${SUCCESSFUL_RUN_MISSING_STATE_REASON}\``,
-                `- Missing disposition: \`${missingDisposition}\``,
-                "- Suggested manager action: choose and record a valid issue disposition without copying transcript content.",
-                "",
-                "## Required Action",
-                "",
-                "- Inspect the source issue and run metadata, not raw transcript excerpts.",
-                "- Choose a valid issue disposition: `done`/`cancelled`, `in_review` with an owner, `blocked` with first-class blockers, delegated follow-up work, or an explicit continuation path.",
-                "- When the source issue has a clear owner and disposition, mark this recovery issue done.",
-            ].join("\n");
-        }
-        const retryReason = readNonEmptyString(parseObject(input.latestRun?.contextSnapshot)?.retryReason) ?? "unknown";
-        const failureSummary = summarizeRunFailureForIssueComment(input.latestRun);
-        const isReviewParticipantRecovery = input.recoveryCause === "execution_review_participant_recovery";
-        const detectedInvariant = isReviewParticipantRecovery
-            ? "execution_review_participant_recovery"
-            : "stranded_assigned_issue";
-        const requiredAction = isReviewParticipantRecovery
-            ? [
-                "- Inspect the latest reviewer run and the pending execution-review stage.",
-                "- Fix the reviewer runtime, restore the source issue to `in_review` with a live participant, or record an intentional manual resolution.",
-                "- When the source issue has a live review path or has been intentionally resolved, mark this recovery issue done.",
-            ]
-            : [
-                "- Inspect the latest run and source issue state.",
-                "- Fix the runtime/adapter problem, reassign the source issue, or convert the source issue into a clear manual-review state.",
-                "- When the source issue has a live execution path or has been intentionally resolved, mark this recovery issue done.",
-            ];
-        return [
-            isReviewParticipantRecovery
-                ? "Paperclip exhausted automatic recovery for a pending execution-review participant and created this explicit recovery task."
-                : "Paperclip exhausted automatic recovery for an assigned issue and created this explicit recovery task.",
-            "",
-            "## Source",
-            "",
-            `- Source issue: ${sourceIssue}`,
-            `- Previous source status: \`${input.previousStatus}\``,
-            `- Latest retry run: ${runLink}`,
-            `- Latest retry status: \`${input.latestRun?.status ?? "unknown"}\``,
-            `- Detected invariant: \`${detectedInvariant}\``,
-            `- Retry reason: \`${retryReason}\``,
-            failureSummary ? `- Failure: ${failureSummary.trim()}` : "- Failure: none recorded",
-            "",
-            "## Ownership",
-            "",
-            "- Selected owner: the first invokable manager/creator/executive candidate with budget available.",
-            "",
-            "## Required Action",
-            "",
-            ...requiredAction,
-        ].join("\n");
-    }
-    async function ensureStrandedIssueRecoveryIssue(input) {
-        if (isStrandedIssueRecoveryIssue(input.issue))
-            return null;
-        const existing = await findOpenStrandedIssueRecoveryIssue(input.issue.companyId, input.issue.id);
-        if (existing)
-            return existing;
-        const ownerAgentId = await resolveStrandedIssueRecoveryOwnerAgentId(input.issue);
-        if (!ownerAgentId)
-            return null;
-        const prefix = await getCompanyIssuePrefix(input.issue.companyId);
-        const sourceAssignee = input.issue.assigneeAgentId ? await getAgent(input.issue.assigneeAgentId) : null;
-        const recoveryCause = input.recoveryCause ?? "stranded_assigned_issue";
-        let recovery;
-        try {
-            recovery = await issuesSvc.create(input.issue.companyId, {
-                title: recoveryCause === SUCCESSFUL_RUN_MISSING_STATE_REASON
-                    ? `Recover missing next step ${input.issue.identifier ?? input.issue.title}`
-                    : `Recover stalled issue ${input.issue.identifier ?? input.issue.title}`,
-                description: buildStrandedIssueRecoveryDescription({
-                    issue: input.issue,
-                    latestRun: input.latestRun,
-                    previousStatus: input.previousStatus,
-                    prefix,
-                    recoveryCause,
-                    successfulRunHandoffEvidence: input.successfulRunHandoffEvidence,
-                    sourceAssignee,
-                }),
-                status: "todo",
-                priority: input.issue.priority,
-                parentId: input.issue.id,
-                projectId: input.issue.projectId,
-                goalId: input.issue.goalId,
-                assigneeAgentId: ownerAgentId,
-                assigneeAdapterOverrides: recoveryAssigneeAdapterOverrides("status_only"),
-                originKind: STRANDED_ISSUE_RECOVERY_ORIGIN_KIND,
-                originId: input.issue.id,
-                originRunId: input.latestRun?.id ?? null,
-                originFingerprint: [
-                    STRANDED_ISSUE_RECOVERY_ORIGIN_KIND,
-                    input.issue.companyId,
-                    input.issue.id,
-                    recoveryCause,
-                    input.latestRun?.id ?? "no-run",
-                ].join(":"),
-                billingCode: input.issue.billingCode,
-                inheritExecutionWorkspaceFromIssueId: input.issue.id,
-            });
-        }
-        catch (error) {
-            if (!isUniqueStrandedIssueRecoveryConflict(error))
-                throw error;
-            const raced = await findOpenStrandedIssueRecoveryIssue(input.issue.companyId, input.issue.id);
-            if (!raced)
-                throw error;
-            return raced;
-        }
-        await deps.enqueueWakeup(ownerAgentId, {
-            source: "assignment",
-            triggerDetail: "system",
-            reason: "issue_assigned",
-            payload: withRecoveryModelProfileHint({
-                issueId: recovery.id,
-                sourceIssueId: input.issue.id,
-                strandedRunId: input.latestRun?.id ?? null,
-                recoveryCause,
-            }, "status_only"),
-            requestedByActorType: "system",
-            requestedByActorId: null,
-            contextSnapshot: withRecoveryModelProfileHint({
-                issueId: recovery.id,
-                taskId: recovery.id,
-                wakeReason: "issue_assigned",
-                source: STRANDED_ISSUE_RECOVERY_ORIGIN_KIND,
-                sourceIssueId: input.issue.id,
-                strandedRunId: input.latestRun?.id ?? null,
-                recoveryCause,
-            }, "status_only"),
-        });
-        return recovery;
-    }
     function strandedRecoveryActionKind(cause) {
         return cause === SUCCESSFUL_RUN_MISSING_STATE_REASON
             ? "missing_disposition"
-            : cause === "workspace_validation_failed"
-                ? "workspace_validation"
-                : cause === "configuration_incomplete"
-                    ? "configuration_validation"
-                    : "stranded_assigned_issue";
+            : cause === "deliberate_wait_without_target"
+                ? "deliberate_wait_without_target"
+                : cause === "workspace_validation_failed"
+                    ? "workspace_validation"
+                    : cause === "configuration_incomplete"
+                        ? "configuration_validation"
+                        : "stranded_assigned_issue";
     }
     function strandedRecoveryActionFingerprint(input) {
         if (input.recoveryCause === "workspace_validation_failed") {
@@ -2157,6 +1922,23 @@ export function recoveryService(db, deps) {
                 ].join(":");
             }
         }
+        // A configuration-incomplete failure that carries a stable identity (for
+        // example an unresolved workspace base ref) dedupes per that identity, so a
+        // different requested ref makes a new recovery action while the same ref
+        // reuses one. Configuration gaps with no fingerprint fall back to the
+        // issue-and-cause scope below.
+        if (input.recoveryCause === "configuration_incomplete") {
+            const configurationFingerprint = readConfigurationIncompleteFingerprint(input.latestRun);
+            if (configurationFingerprint) {
+                return [
+                    "source_scoped_recovery",
+                    input.issue.companyId,
+                    input.issue.id,
+                    input.recoveryCause,
+                    configurationFingerprint,
+                ].join(":");
+            }
+        }
         return [
             "source_scoped_recovery",
             input.issue.companyId,
@@ -2189,20 +1971,25 @@ export function recoveryService(db, deps) {
     }
     async function ensureSourceScopedStrandedRecoveryAction(input) {
         const recoveryCause = resolveStrandedRecoveryCause(input.latestRun, input.recoveryCause);
-        const routing = await resolveStrandedRecoveryRouting({
+        const routing = resolveStrandedRecoveryRouting({
             issue: input.issue,
             latestRun: input.latestRun,
-            recoveryCause,
-            preferredOwnerAgentId: input.recoveryOwnerAgentId,
         });
-        const ownerAgentId = routing.ownerAgentId;
+        const isProviderQuotaWait = recoveryCause === "provider_quota";
         const now = new Date();
         const action = await recoveryActionsSvc.upsertSourceScoped({
             companyId: input.issue.companyId,
             sourceIssueId: input.issue.id,
+            // A configuration-incomplete failure carries a per-identity fingerprint
+            // (for example the unresolved workspace base ref). A different ref is a
+            // distinct blocker, so it must get a new recovery action and notify the
+            // operator, not overwrite the active action of the prior ref.
+            supersedeOnIdentityChange: recoveryCause === "configuration_incomplete",
+            preserveExistingOwner: true,
             kind: strandedRecoveryActionKind(recoveryCause),
-            ownerType: recoveryCause === "provider_quota" && !ownerAgentId ? "system" : ownerAgentId ? "agent" : "board",
-            ownerAgentId,
+            ownerType: isProviderQuotaWait ? "system" : "board",
+            ownerAgentId: null,
+            ownerUserId: null,
             previousOwnerAgentId: input.issue.assigneeAgentId,
             returnOwnerAgentId: routing.returnOwnerAgentId,
             cause: recoveryCause,
@@ -2220,49 +2007,40 @@ export function recoveryService(db, deps) {
                     successfulRunHandoffEvidence: input.successfulRunHandoffEvidence,
                 }),
                 failureSummary: summarizeRunFailureForIssueComment(input.latestRun)?.trim() ?? null,
-                routingFallbackReason: routing.routingFallbackReason,
             },
+            evidenceOnCreate: isProviderQuotaWait
+                ? {}
+                : { routingPolicy: STRANDED_BOARD_ESCALATION_POLICY },
             nextAction: recoveryCause === SUCCESSFUL_RUN_MISSING_STATE_REASON
-                ? "Choose and record a valid issue disposition without copying transcript content."
+                ? "Board operator: inspect the run evidence, then explicitly choose a valid issue disposition, retry the original owner, reassign, or intentionally resolve the task."
                 : recoveryCause === "process_lost"
-                    ? "Retry the original assignee from durable progress without redoing completed steps."
+                    ? "Board operator: inspect the retry history, then explicitly retry the original owner, reassign, or intentionally resolve the task."
                     : recoveryCause === "provider_quota"
                         ? "Wait for provider quota recovery, then retry the original assignee; do not wake a takeover owner."
                         : recoveryCause === "codex_output_inactivity_monitor"
-                            ? "Retry the same agent from durable progress after the output-inactivity termination."
+                            ? "Board operator: inspect the inactivity evidence, then explicitly retry the original owner, reassign, or intentionally resolve the task."
                             : recoveryCause === "workspace_validation_failed"
                                 ? readWorkspaceValidationPayload(input.latestRun)?.reason === "git_worktree_branch_incoherence"
-                                    ? "Repair the source issue git worktree branch incoherence, or choose a new execution workspace, before resuming adapter execution."
+                                    ? "Board operator: repair the source task git worktree branch incoherence or choose a new execution workspace, then explicitly retry or reassign."
                                     : readWorkspaceValidationPayload(input.latestRun)?.reason === "git_worktree_base_materialization_failed"
-                                        ? "Repair the project workspace repository URL or clone access, or configure a local checkout cwd, before resuming adapter execution."
-                                        : "Repair the source issue workspace link, project workspace cwd, or git checkout before resuming adapter execution."
+                                        ? "Board operator: repair the project workspace repository URL or clone access, or configure a local checkout cwd, then explicitly retry or reassign."
+                                        : "Board operator: repair the source task workspace link, project workspace cwd, or git checkout, then explicitly retry or reassign."
                                 : recoveryCause === "configuration_incomplete"
-                                    ? "Bind the missing secret(s) named in the run failure to the agent/project/routine env before resuming adapter execution."
+                                    ? "Board operator: bind the missing secret(s) named in the run failure, then explicitly retry the original owner or reassign."
                                     : recoveryCause === "execution_review_participant_recovery"
-                                        ? "Repair the failed review participant path, restore the source issue to in_review with a live reviewer, or record an intentional manual resolution."
-                                        : "Restore a live execution path, fix the runtime/adapter failure, or record an intentional manual resolution.",
-            wakePolicy: recoveryCause === "provider_quota" && !ownerAgentId
+                                        ? "Board operator: repair the failed review participant path, restore a live reviewer, explicitly reassign, or record an intentional resolution."
+                                        : "Board operator: inspect the evidence, repair the runtime if appropriate, then explicitly retry the original owner, reassign, or intentionally resolve the task.",
+            wakePolicy: isProviderQuotaWait
                 ? {
                     type: "monitor_only",
                     reason: recoveryCause,
                 }
-                : recoveryCause === "configuration_incomplete"
-                    ? {
-                        type: "manual_repair_required",
-                        reason: recoveryCause,
-                        ownerAgentId,
-                    }
-                    : ownerAgentId
-                        ? {
-                            type: "wake_owner",
-                            reason: "source_scoped_recovery_action",
-                            ownerAgentId,
-                        }
-                        : {
-                            type: "board_escalation",
-                            reason: "no_invokable_recovery_owner",
-                        },
-            monitorPolicy: recoveryCause === "provider_quota" && !ownerAgentId
+                : {
+                    type: "board_escalation",
+                    reason: recoveryCause,
+                    preservesSourceAssignee: true,
+                },
+            monitorPolicy: isProviderQuotaWait
                 ? { type: "wait_recovery", retryAgentId: routing.returnOwnerAgentId }
                 : null,
             maxAttempts: null,
@@ -2270,40 +2048,6 @@ export function recoveryService(db, deps) {
         });
         return action;
     }
-    async function enqueueSourceScopedStrandedRecoveryWake(input) {
-        if (input.recoveryCause === "provider_quota" && !input.action.ownerAgentId)
-            return;
-        if (input.recoveryCause === "configuration_incomplete")
-            return;
-        if (!input.action.ownerAgentId)
-            return;
-        await deps.enqueueWakeup(input.action.ownerAgentId, {
-            source: "assignment",
-            triggerDetail: "system",
-            reason: "source_scoped_recovery_action",
-            idempotencyKey: `source_scoped_recovery_action:${input.action.id}:${input.action.attemptCount}`,
-            payload: withRecoveryModelProfileHint({
-                issueId: input.issue.id,
-                sourceIssueId: input.issue.id,
-                recoveryActionId: input.action.id,
-                strandedRunId: input.latestRun?.id ?? null,
-                recoveryCause: input.recoveryCause,
-            }, "status_only"),
-            requestedByActorType: "system",
-            requestedByActorId: null,
-            contextSnapshot: withRecoveryModelProfileHint({
-                issueId: input.issue.id,
-                taskId: input.issue.id,
-                wakeReason: "source_scoped_recovery_action",
-                skipIssueComment: true,
-                source: "issue_recovery_action",
-                recoveryActionId: input.action.id,
-                sourceIssueId: input.issue.id,
-                strandedRunId: input.latestRun?.id ?? null,
-                recoveryCause: input.recoveryCause,
-            }, "status_only"),
-        });
-    }
     function readProviderQuotaRetryAt(latestRun, now) {
         const result = parseObject(latestRun?.resultJson);
         const context = parseObject(latestRun?.contextSnapshot);
@@ -2491,12 +2235,31 @@ export function recoveryService(db, deps) {
     async function existingUnresolvedBlockerIssueIds(companyId, issueId) {
         return existingUnresolvedBlockerIssues(companyId, issueId).then((rows) => rows.map((row) => row.id));
     }
-    async function resolveContinuationWaitingOnReview(issue) {
-        const existingBlockers = await existingUnresolvedBlockerIssues(issue.companyId, issue.id);
-        const openChildren = await db
+    async function openChildIssues(issue) {
+        return db
             .select({ id: issues.id, identifier: issues.identifier })
             .from(issues)
             .where(and(eq(issues.companyId, issue.companyId), eq(issues.parentId, issue.id), visibleIssueCondition(), notInArray(issues.status, ["done", "cancelled"])));
+    }
+    async function healthyOpenChildIssues(issue) {
+        const childCandidates = await db
+            .select()
+            .from(issues)
+            .where(and(eq(issues.companyId, issue.companyId), eq(issues.parentId, issue.id), visibleIssueCondition(), notInArray(issues.status, ["done", "cancelled"])));
+        const openChildren = [];
+        for (const child of childCandidates) {
+            const childState = await collectDispositionRepairSourceState(db, { issue: child });
+            if (childState.hasActiveExecutionPath || childState.hasDurableWaitingPath) {
+                openChildren.push({ id: child.id, identifier: child.identifier });
+            }
+        }
+        return openChildren;
+    }
+    async function resolveContinuationWaitingOnReview(issue) {
+        const [existingBlockers, openChildren] = await Promise.all([
+            existingUnresolvedBlockerIssues(issue.companyId, issue.id),
+            openChildIssues(issue),
+        ]);
         const blockedByIssueIds = [...new Set([...existingBlockers.map((row) => row.id), ...openChildren.map((row) => row.id)])];
         if (blockedByIssueIds.length === 0)
             return null;
@@ -2545,6 +2308,578 @@ export function recoveryService(db, deps) {
         });
         return updated;
     }
+    function readDispositionRepairAttempt(latestRun) {
+        if (!latestRun)
+            return null;
+        const context = parseObject(latestRun.contextSnapshot);
+        if (readNonEmptyString(context.retryReason) !== ISSUE_DISPOSITION_REPAIR_RETRY_REASON)
+            return null;
+        return {
+            attempt: Math.max(1, Math.floor(asNumber(context.dispositionRepairAttempt, 1))),
+            fingerprint: readNonEmptyString(context.dispositionRepairFingerprint),
+        };
+    }
+    async function resolveDispositionRepairActionAsCovered(issue, reason) {
+        const active = await recoveryActionsSvc.getActiveForIssue(issue.companyId, issue.id);
+        if (!active || active.kind !== "deliberate_wait_without_target")
+            return;
+        await recoveryActionsSvc.resolveActiveForIssue({
+            companyId: issue.companyId,
+            sourceIssueId: issue.id,
+            actionId: active.id,
+            status: "resolved",
+            outcome: "restored",
+            resolutionNote: reason,
+        });
+        await logActivity(db, {
+            companyId: issue.companyId,
+            actorType: "system",
+            actorId: "recovery",
+            agentId: null,
+            runId: null,
+            action: "issue.disposition_repair_resolved",
+            entityType: "issue_recovery_action",
+            entityId: active.id,
+            details: {
+                sourceIssueId: issue.id,
+                sourceIdentifier: issue.identifier,
+                reason,
+            },
+        });
+    }
+    async function ensureDispositionRepairAction(input) {
+        let active = await recoveryActionsSvc.getActiveForIssue(input.issue.companyId, input.issue.id);
+        if (active && (active.kind !== "deliberate_wait_without_target" ||
+            active.fingerprint !== input.fingerprint)) {
+            await recoveryActionsSvc.resolveActiveForIssue({
+                companyId: input.issue.companyId,
+                sourceIssueId: input.issue.id,
+                actionId: active.id,
+                status: "cancelled",
+                outcome: "cancelled",
+                resolutionNote: "source_state_changed",
+            });
+            await logActivity(db, {
+                companyId: input.issue.companyId,
+                actorType: "system",
+                actorId: "recovery",
+                agentId: null,
+                runId: input.latestRun?.id ?? null,
+                action: "issue.disposition_repair_fingerprint_reset",
+                entityType: "issue_recovery_action",
+                entityId: active.id,
+                details: {
+                    sourceIssueId: input.issue.id,
+                    previousFingerprint: active.fingerprint,
+                    nextFingerprint: input.fingerprint,
+                    terminalReason: "source_state_changed",
+                },
+            });
+            active = null;
+        }
+        if (active && active.attemptCount >= input.attemptCount)
+            return active;
+        return recoveryActionsSvc.upsertSourceScoped({
+            companyId: input.issue.companyId,
+            sourceIssueId: input.issue.id,
+            kind: "deliberate_wait_without_target",
+            ownerType: "agent",
+            ownerAgentId: input.issue.assigneeAgentId,
+            previousOwnerAgentId: input.issue.assigneeAgentId,
+            returnOwnerAgentId: input.issue.assigneeAgentId,
+            cause: "deliberate_wait_without_target",
+            fingerprint: input.fingerprint,
+            evidence: {
+                sourceIssueId: input.issue.id,
+                sourceIdentifier: input.issue.identifier,
+                latestRunId: input.latestRun?.id ?? null,
+                latestRunStatus: input.latestRun?.status ?? null,
+                latestRunErrorCode: input.latestRun?.errorCode ?? null,
+                sourceStateFingerprint: input.fingerprint,
+                terminalReason: null,
+            },
+            nextAction: "The original owner must replace the parked summary with a terminal, live, blocked, monitored, or typed waiting disposition.",
+            wakePolicy: {
+                type: "bounded_owner_disposition_repair",
+                retryAgentId: input.issue.assigneeAgentId,
+                attempt: input.attemptCount,
+                maxAttempts: DISPOSITION_REPAIR_MAX_ATTEMPTS,
+            },
+            maxAttempts: DISPOSITION_REPAIR_MAX_ATTEMPTS,
+            attemptCount: input.attemptCount,
+            lastAttemptAt: new Date(),
+        });
+    }
+    async function scheduleDispositionRepairAttempt(input) {
+        const agentId = input.issue.assigneeAgentId;
+        if (!agentId)
+            return null;
+        const timing = dispositionRepairDelayMs(input.attempt, input.fingerprint);
+        const now = new Date();
+        const retryAt = new Date(now.getTime() + timing.delayMs);
+        const idempotencyKey = `issue_disposition_repair:${input.issue.id}:${input.fingerprint}:${input.attempt}`;
+        const context = withRecoveryModelProfileHint({
+            issueId: input.issue.id,
+            taskId: input.issue.id,
+            wakeReason: ISSUE_DISPOSITION_REPAIR_RETRY_REASON,
+            retryReason: ISSUE_DISPOSITION_REPAIR_RETRY_REASON,
+            source: "issue.deliberate_wait_disposition_repair",
+            retryOfRunId: input.latestRun?.id ?? null,
+            recoveryActionId: input.action.id,
+            dispositionRepairFingerprint: input.fingerprint,
+            dispositionRepairAttempt: input.attempt,
+            dispositionRepairMaxAttempts: DISPOSITION_REPAIR_MAX_ATTEMPTS,
+            bypassContinuationSummaryPark: true,
+            dispositionRepairInstruction: "Revalidate the issue and replace the invalid parked summary with a durable disposition. Continue productive work when appropriate.",
+        }, "normal_model");
+        const findScheduledRun = () => db
+            .select({ run: heartbeatRuns })
+            .from(agentWakeupRequests)
+            .innerJoin(heartbeatRuns, eq(heartbeatRuns.id, agentWakeupRequests.runId))
+            .where(and(eq(agentWakeupRequests.companyId, input.issue.companyId), eq(agentWakeupRequests.idempotencyKey, idempotencyKey), sql `${agentWakeupRequests.status} <> 'skipped'`))
+            .limit(1)
+            .then((rows) => rows[0]?.run ?? null);
+        let scheduledRun = await findScheduledRun();
+        let created = false;
+        if (!scheduledRun) {
+            try {
+                if (timing.delayMs === 0) {
+                    const enqueuedRun = await deps.enqueueWakeup(agentId, {
+                        source: "automation",
+                        triggerDetail: "system",
+                        reason: ISSUE_DISPOSITION_REPAIR_RETRY_REASON,
+                        idempotencyKey,
+                        payload: withRecoveryModelProfileHint({
+                            issueId: input.issue.id,
+                            retryOfRunId: input.latestRun?.id ?? null,
+                            recoveryActionId: input.action.id,
+                            dispositionRepairFingerprint: input.fingerprint,
+                            dispositionRepairAttempt: input.attempt,
+                            bypassContinuationSummaryPark: true,
+                        }, "normal_model"),
+                        requestedByActorType: "system",
+                        requestedByActorId: null,
+                        contextSnapshot: context,
+                    });
+                    scheduledRun = enqueuedRun ?? (await findScheduledRun());
+                    created = Boolean(enqueuedRun);
+                }
+                else {
+                    scheduledRun = await db.transaction(async (tx) => {
+                        const wakeup = await tx
+                            .insert(agentWakeupRequests)
+                            .values({
+                            companyId: input.issue.companyId,
+                            agentId,
+                            source: "automation",
+                            triggerDetail: "system",
+                            reason: ISSUE_DISPOSITION_REPAIR_RETRY_REASON,
+                            payload: withRecoveryModelProfileHint({
+                                issueId: input.issue.id,
+                                retryOfRunId: input.latestRun?.id ?? null,
+                                recoveryActionId: input.action.id,
+                                dispositionRepairFingerprint: input.fingerprint,
+                                dispositionRepairAttempt: input.attempt,
+                                bypassContinuationSummaryPark: true,
+                            }, "normal_model"),
+                            status: "queued",
+                            requestedByActorType: "system",
+                            requestedByActorId: null,
+                            idempotencyKey,
+                            updatedAt: now,
+                        })
+                            .returning()
+                            .then((rows) => rows[0]);
+                        const run = await tx
+                            .insert(heartbeatRuns)
+                            .values({
+                            companyId: input.issue.companyId,
+                            agentId,
+                            invocationSource: "automation",
+                            triggerDetail: "system",
+                            status: "scheduled_retry",
+                            wakeupRequestId: wakeup.id,
+                            retryOfRunId: input.latestRun?.id ?? null,
+                            scheduledRetryAt: retryAt,
+                            scheduledRetryAttempt: input.attempt,
+                            scheduledRetryReason: ISSUE_DISPOSITION_REPAIR_RETRY_REASON,
+                            contextSnapshot: context,
+                            updatedAt: now,
+                        })
+                            .returning()
+                            .then((rows) => rows[0]);
+                        await tx
+                            .update(agentWakeupRequests)
+                            .set({ runId: run.id, updatedAt: now })
+                            .where(eq(agentWakeupRequests.id, wakeup.id));
+                        return run;
+                    });
+                    created = true;
+                }
+            }
+            catch (error) {
+                if (!isUniqueViolation(error, DISPOSITION_REPAIR_IDEMPOTENCY_INDEX))
+                    throw error;
+                const winningRun = await findScheduledRun();
+                if (!winningRun)
+                    throw error;
+                scheduledRun = winningRun;
+            }
+        }
+        if (!scheduledRun)
+            return null;
+        await db
+            .update(issueRecoveryActions)
+            .set({
+            attemptCount: input.attempt,
+            wakePolicy: {
+                type: "bounded_owner_disposition_repair",
+                retryAgentId: agentId,
+                attempt: input.attempt,
+                maxAttempts: DISPOSITION_REPAIR_MAX_ATTEMPTS,
+                baseBackoffMs: timing.baseDelayMs,
+                jitterMs: timing.jitterMs,
+                retryAt: retryAt.toISOString(),
+                scheduledRunId: scheduledRun.id,
+            },
+            timeoutAt: retryAt,
+            lastAttemptAt: now,
+            updatedAt: now,
+        })
+            .where(and(eq(issueRecoveryActions.id, input.action.id), eq(issueRecoveryActions.companyId, input.issue.companyId)));
+        if (created) {
+            await logActivity(db, {
+                companyId: input.issue.companyId,
+                actorType: "system",
+                actorId: "recovery",
+                agentId: null,
+                runId: input.latestRun?.id ?? null,
+                action: "issue.disposition_repair_scheduled",
+                entityType: "issue_recovery_action",
+                entityId: input.action.id,
+                details: {
+                    sourceIssueId: input.issue.id,
+                    sourceIdentifier: input.issue.identifier,
+                    ownerAgentId: agentId,
+                    sourceStateFingerprint: input.fingerprint,
+                    attempt: input.attempt,
+                    maxAttempts: DISPOSITION_REPAIR_MAX_ATTEMPTS,
+                    baseBackoffMs: timing.baseDelayMs,
+                    jitterMs: timing.jitterMs,
+                    retryAt: retryAt.toISOString(),
+                    scheduledRunId: scheduledRun.id,
+                },
+            });
+        }
+        return scheduledRun;
+    }
+    async function latestRecoveryActionRun(action) {
+        return db
+            .select()
+            .from(heartbeatRuns)
+            .where(and(eq(heartbeatRuns.companyId, action.companyId), sql `${heartbeatRuns.contextSnapshot} ->> 'recoveryActionId' = ${action.id}`))
+            .orderBy(desc(heartbeatRuns.createdAt), desc(heartbeatRuns.id))
+            .limit(1)
+            .then((rows) => rows[0] ?? null);
+    }
+    async function sourceHasNewPathOutsideRecoveryAction(action) {
+        const [run, wake] = await Promise.all([
+            db
+                .select({ id: heartbeatRuns.id })
+                .from(heartbeatRuns)
+                .where(and(eq(heartbeatRuns.companyId, action.companyId), inArray(heartbeatRuns.status, [...EXECUTION_PATH_HEARTBEAT_RUN_STATUSES]), sql `coalesce(${heartbeatRuns.contextSnapshot} ->> 'issueId', ${heartbeatRuns.contextSnapshot} ->> 'taskId') = ${action.sourceIssueId}`, sql `coalesce(${heartbeatRuns.contextSnapshot} ->> 'recoveryActionId', '') <> ${action.id}`))
+                .limit(1)
+                .then((rows) => rows[0] ?? null),
+            db
+                .select({ id: agentWakeupRequests.id })
+                .from(agentWakeupRequests)
+                .where(and(eq(agentWakeupRequests.companyId, action.companyId), inArray(agentWakeupRequests.status, ["queued", "claimed", "deferred_issue_execution"]), sql `coalesce(${agentWakeupRequests.payload} ->> 'issueId', ${agentWakeupRequests.payload} ->> 'taskId') = ${action.sourceIssueId}`, sql `coalesce(${agentWakeupRequests.payload} ->> 'recoveryActionId', '') <> ${action.id}`))
+                .limit(1)
+                .then((rows) => rows[0] ?? null),
+        ]);
+        return Boolean(run || wake);
+    }
+    async function reconcileActiveRecoveryActions() {
+        const rows = await db
+            .select({ action: issueRecoveryActions, issue: issues })
+            .from(issueRecoveryActions)
+            .innerJoin(issues, and(eq(issues.id, issueRecoveryActions.sourceIssueId), eq(issues.companyId, issueRecoveryActions.companyId)))
+            .where(inArray(issueRecoveryActions.status, ["active", "escalated"]));
+        const result = { requeued: 0, escalated: 0, resolved: 0, skipped: 0, issueIds: [] };
+        for (const { action, issue } of rows) {
+            const wakePolicy = parseObject(action.wakePolicy);
+            const wakePolicyType = readNonEmptyString(wakePolicy.type);
+            if (wakePolicyType !== "bounded_recovery_owner" &&
+                wakePolicyType !== "bounded_owner_disposition_repair" &&
+                action.ownerType !== "board") {
+                continue;
+            }
+            if (issue.status === "done" || issue.status === "cancelled") {
+                const resolved = await recoveryActionsSvc.resolveActiveForIssue({
+                    companyId: action.companyId,
+                    sourceIssueId: action.sourceIssueId,
+                    actionId: action.id,
+                    status: "resolved",
+                    outcome: "restored",
+                    resolutionNote: "source_terminal",
+                });
+                if (resolved) {
+                    result.resolved += 1;
+                    result.issueIds.push(issue.id);
+                }
+                continue;
+            }
+            const [sourceState, healthyChildren, hasNewSourcePath] = await Promise.all([
+                collectDispositionRepairSourceState(db, { issue }),
+                healthyOpenChildIssues(issue),
+                sourceHasNewPathOutsideRecoveryAction(action),
+            ]);
+            const durablePathRestored = action.ownerType !== "board" && sourceState.hasDurableWaitingPath;
+            if (durablePathRestored || healthyChildren.length > 0 || hasNewSourcePath) {
+                if (healthyChildren.length > 0 && !sourceState.hasDurableWaitingPath) {
+                    const blockerIds = await existingUnresolvedBlockerIssueIds(issue.companyId, issue.id);
+                    await issuesSvc.update(issue.id, {
+                        status: "blocked",
+                        blockedByIssueIds: [...new Set([
+                                ...blockerIds,
+                                ...healthyChildren.map((child) => child.id),
+                            ])],
+                    });
+                }
+                const resolved = await recoveryActionsSvc.resolveActiveForIssue({
+                    companyId: action.companyId,
+                    sourceIssueId: action.sourceIssueId,
+                    actionId: action.id,
+                    status: "resolved",
+                    outcome: "restored",
+                    resolutionNote: durablePathRestored
+                        ? `durable_path_restored:${sourceState.durablePathReason ?? "unknown"}`
+                        : healthyChildren.length > 0
+                            ? "durable_path_restored:healthy_child"
+                            : "new_source_execution_path",
+                });
+                if (resolved) {
+                    result.resolved += 1;
+                    result.issueIds.push(issue.id);
+                }
+                continue;
+            }
+            if (wakePolicyType === "bounded_owner_disposition_repair") {
+                if (await isAutomaticRecoverySuppressedByPauseHold(db, issue.companyId, issue.id, treeControlSvc)) {
+                    result.skipped += 1;
+                    continue;
+                }
+                const latestRun = await latestRecoveryActionRun(action);
+                const persistedAttempt = Math.max(action.attemptCount, Math.max(0, Math.floor(asNumber(wakePolicy.attempt, action.attemptCount))));
+                const outcome = await reconcileDispositionRepair(issue, latestRun, {
+                    historicalAttemptCount: persistedAttempt,
+                });
+                if (outcome === "queued") {
+                    result.requeued += 1;
+                    result.issueIds.push(issue.id);
+                }
+                else if (outcome === "escalated") {
+                    result.escalated += 1;
+                    result.issueIds.push(issue.id);
+                }
+                else {
+                    result.skipped += 1;
+                }
+                continue;
+            }
+            if (action.ownerType === "board")
+                continue;
+            // Legacy takeover actions remain readable and resolvable, but recovery no
+            // longer schedules another agent-owned wake for them.
+            result.skipped += 1;
+        }
+        return result;
+    }
+    async function escalateDispositionRepair(input) {
+        const action = await ensureDispositionRepairAction({
+            issue: input.issue,
+            latestRun: input.latestRun,
+            fingerprint: input.fingerprint,
+            attemptCount: input.attemptCount,
+        });
+        const now = new Date();
+        await db
+            .update(issueRecoveryActions)
+            .set({
+            status: "active",
+            ownerType: "board",
+            ownerAgentId: null,
+            ownerUserId: null,
+            maxAttempts: null,
+            evidence: {
+                ...action.evidence,
+                latestRunId: input.latestRun?.id ?? null,
+                latestRunStatus: input.latestRun?.status ?? null,
+                latestRunErrorCode: input.latestRun?.errorCode ?? null,
+                terminalReason: input.terminalReason,
+                sourceAttemptCount: input.attemptCount,
+                sourceMaxAttempts: DISPOSITION_REPAIR_MAX_ATTEMPTS,
+                routingPolicy: STRANDED_BOARD_ESCALATION_POLICY,
+            },
+            nextAction: "Inspect the evidence and choose whether to repair, retry the original owner, explicitly reassign, or resolve the source issue.",
+            wakePolicy: {
+                type: "board_escalation",
+                reason: input.terminalReason,
+                preservesSourceAssignee: true,
+            },
+            timeoutAt: null,
+            resolutionNote: input.terminalReason,
+            updatedAt: now,
+        })
+            .where(and(eq(issueRecoveryActions.id, action.id), eq(issueRecoveryActions.companyId, input.issue.companyId)));
+        const updated = await issuesSvc.update(input.issue.id, {
+            status: "blocked",
+        });
+        if (!updated)
+            return null;
+        const sourceAssigneePreserved = updated.assigneeAgentId === input.issue.assigneeAgentId &&
+            updated.assigneeUserId === input.issue.assigneeUserId;
+        await issuesSvc.addComment(input.issue.id, [
+            "Paperclip exhausted the bounded original-owner disposition repair without a durable source-state change.",
+            "",
+            `- Attempts: ${input.attemptCount}/${DISPOSITION_REPAIR_MAX_ATTEMPTS}`,
+            `- Terminal reason: \`${input.terminalReason}\``,
+            "- Recovery owner: board",
+            "- Source ownership: unchanged; reassignment requires an explicit decision or a policy-defined serious failure.",
+            "",
+            "Next action: repair the liveness disposition or request an explicit source-owner decision.",
+        ].join("\n"), {}, {
+            authorType: "system",
+            presentation: compactRecoveryPresentation("Recovery: disposition repair escalated — source owner preserved"),
+            metadata: recoveryNoticeMetadata({
+                cause: "deliberate_wait_without_target",
+                latestRun: input.latestRun,
+                recoveryActionId: action.id,
+                previousStatus: input.issue.status,
+                recoveryOwner: null,
+            }),
+        });
+        await logActivity(db, {
+            companyId: input.issue.companyId,
+            actorType: "system",
+            actorId: "recovery",
+            agentId: null,
+            runId: input.latestRun?.id ?? null,
+            action: "issue.disposition_repair_escalated",
+            entityType: "issue",
+            entityId: input.issue.id,
+            details: {
+                identifier: input.issue.identifier,
+                status: "blocked",
+                previousStatus: input.issue.status,
+                sourceStateFingerprint: input.fingerprint,
+                attemptCount: input.attemptCount,
+                maxAttempts: DISPOSITION_REPAIR_MAX_ATTEMPTS,
+                terminalReason: input.terminalReason,
+                recoveryActionId: action.id,
+                recoveryOwnerAgentId: null,
+                recoveryOwnerType: "board",
+                routingPolicy: STRANDED_BOARD_ESCALATION_POLICY,
+                sourceAssigneeBefore: {
+                    agentId: input.issue.assigneeAgentId,
+                    userId: input.issue.assigneeUserId,
+                },
+                sourceAssigneeAfter: {
+                    agentId: updated.assigneeAgentId,
+                    userId: updated.assigneeUserId,
+                },
+                sourceAssigneePreserved,
+            },
+        });
+        if (!sourceAssigneePreserved) {
+            logger.error({
+                issueId: input.issue.id,
+                beforeAssigneeAgentId: input.issue.assigneeAgentId,
+                afterAssigneeAgentId: updated.assigneeAgentId,
+                beforeAssigneeUserId: input.issue.assigneeUserId,
+                afterAssigneeUserId: updated.assigneeUserId,
+            }, "automatic disposition recovery observed a concurrent source-owner change");
+        }
+        return updated;
+    }
+    async function reconcileDispositionRepair(issue, latestRun, options = {}) {
+        const current = await db
+            .select()
+            .from(issues)
+            .where(and(eq(issues.companyId, issue.companyId), eq(issues.id, issue.id)))
+            .limit(1)
+            .then((rows) => rows[0] ?? null);
+        if (!current || current.status === "done" || current.status === "cancelled")
+            return "skipped";
+        const dependencyWait = await resolveContinuationWaitingOnReview(current);
+        if (dependencyWait) {
+            await resolveDispositionRepairActionAsCovered(current, "dependency_wait_created");
+            return "covered";
+        }
+        const state = await collectDispositionRepairSourceState(db, { issue: current });
+        if (state.hasActiveExecutionPath)
+            return "skipped";
+        if (state.hasDurableWaitingPath) {
+            await resolveDispositionRepairActionAsCovered(current, `durable_path_restored:${state.durablePathReason ?? "unknown"}`);
+            return "covered";
+        }
+        const ownerAgentId = current.assigneeAgentId;
+        const ownerAgent = ownerAgentId ? await getAgent(ownerAgentId) : null;
+        const ownerInvokable = ownerAgent && ownerAgent.companyId === current.companyId
+            ? (await isAgentInvokable(ownerAgent)) && isHeartbeatWakeOnDemandEnabled(ownerAgent)
+            : false;
+        const budgetBlocked = ownerAgentId ? await isInvocationBudgetBlocked(current, ownerAgentId) : true;
+        const previousAttempt = readDispositionRepairAttempt(latestRun);
+        const activeRepairAction = await recoveryActionsSvc.getActiveForIssue(current.companyId, current.id);
+        const runAttempt = previousAttempt?.fingerprint === state.fingerprint
+            ? previousAttempt.attempt
+            : 0;
+        const persistedAttempt = activeRepairAction?.kind === "deliberate_wait_without_target" &&
+            activeRepairAction.fingerprint === state.fingerprint
+            ? activeRepairAction.attemptCount
+            : 0;
+        // Upgrade compatibility: pre-fingerprint continuation parks already spent
+        // attempts against this unchanged source state. Seed the durable counter
+        // from that consecutive legacy history instead of granting five fresh
+        // attempts merely because the recovery-action row did not exist yet.
+        const historicalAttempt = Math.min(DISPOSITION_REPAIR_MAX_ATTEMPTS, Math.max(0, Math.floor(options.historicalAttemptCount ?? 0)));
+        const sameFingerprintAttempt = Math.max(runAttempt, persistedAttempt, historicalAttempt);
+        if (!ownerInvokable || budgetBlocked) {
+            const escalated = await escalateDispositionRepair({
+                issue: current,
+                latestRun,
+                fingerprint: state.fingerprint,
+                attemptCount: sameFingerprintAttempt,
+                terminalReason: !ownerInvokable ? "owner_not_invokable" : "owner_budget_blocked",
+            });
+            return escalated ? "escalated" : "skipped";
+        }
+        if (sameFingerprintAttempt >= DISPOSITION_REPAIR_MAX_ATTEMPTS) {
+            const escalated = await escalateDispositionRepair({
+                issue: current,
+                latestRun,
+                fingerprint: state.fingerprint,
+                attemptCount: sameFingerprintAttempt,
+                terminalReason: "unchanged_source_state_exhausted",
+            });
+            return escalated ? "escalated" : "skipped";
+        }
+        const nextAttempt = sameFingerprintAttempt + 1;
+        const action = await ensureDispositionRepairAction({
+            issue: current,
+            latestRun,
+            fingerprint: state.fingerprint,
+            attemptCount: sameFingerprintAttempt,
+        });
+        const scheduled = await scheduleDispositionRepairAttempt({
+            issue: current,
+            latestRun,
+            action,
+            fingerprint: state.fingerprint,
+            attempt: nextAttempt,
+        });
+        return scheduled ? "queued" : "skipped";
+    }
     async function escalateStrandedAssignedIssue(input) {
         if (isStrandedIssueRecoveryIssue(input.issue)) {
             return escalateStrandedRecoveryIssueInPlace({
@@ -2559,7 +2894,6 @@ export function recoveryService(db, deps) {
             previousStatus: input.previousStatus,
             latestRun: input.latestRun,
             recoveryCause,
-            recoveryOwnerAgentId: input.recoveryOwnerAgentId,
             successfulRunHandoffEvidence: input.successfulRunHandoffEvidence,
         });
         const isProviderQuotaWait = recoveryCause === "provider_quota" &&
@@ -2577,12 +2911,13 @@ export function recoveryService(db, deps) {
         const updated = await issuesSvc.update(input.issue.id, {
             status: "blocked",
             blockedByIssueIds: blockerIds,
-            assigneeAgentId: recoveryAction.ownerAgentId ?? input.issue.assigneeAgentId,
         });
         if (!updated)
             return null;
         if (isProviderQuotaWait)
             return updated;
+        const sourceAssigneePreserved = updated.assigneeAgentId === input.issue.assigneeAgentId &&
+            updated.assigneeUserId === input.issue.assigneeUserId;
         const recoveryOwner = recoveryAction.ownerAgentId ? await getAgent(recoveryAction.ownerAgentId) : null;
         const sourceAssignee = input.issue.assigneeAgentId ? await getAgent(input.issue.assigneeAgentId) : null;
         let notice = null;
@@ -2690,38 +3025,31 @@ export function recoveryService(db, deps) {
                 latestRunStatus: input.latestRun?.status ?? null,
                 latestRunErrorCode: input.latestRun?.errorCode ?? null,
                 recoveryActionId: recoveryAction.id,
+                recoveryOwnerType: recoveryAction.ownerType,
                 recoveryOwnerAgentId: recoveryAction.ownerAgentId,
                 previousOwnerAgentId: recoveryAction.previousOwnerAgentId,
                 returnOwnerAgentId: recoveryAction.returnOwnerAgentId,
+                routingPolicy: parseObject(recoveryAction.evidence).routingPolicy ?? null,
+                sourceAssigneeBefore: {
+                    agentId: input.issue.assigneeAgentId,
+                    userId: input.issue.assigneeUserId,
+                },
+                sourceAssigneeAfter: {
+                    agentId: updated.assigneeAgentId,
+                    userId: updated.assigneeUserId,
+                },
+                sourceAssigneePreserved,
                 blockerIssueIds: blockerIds,
             },
         });
-        await enqueueSourceScopedStrandedRecoveryWake({
-            action: recoveryAction,
-            issue: input.issue,
-            latestRun: input.latestRun,
-            recoveryCause,
-        });
-        if (recoveryAction.ownerAgentId && recoveryAction.ownerAgentId === input.issue.assigneeAgentId) {
-            const [currentIssue] = await db
-                .select({
-                status: issues.status,
-                assigneeAgentId: issues.assigneeAgentId,
-            })
-                .from(issues)
-                .where(eq(issues.id, input.issue.id))
-                .limit(1);
-            if (currentIssue &&
-                (currentIssue.status !== "blocked" ||
-                    currentIssue.assigneeAgentId !== recoveryAction.ownerAgentId)) {
-                const reblocked = await issuesSvc.update(input.issue.id, {
-                    status: "blocked",
-                    blockedByIssueIds: blockerIds,
-                    assigneeAgentId: recoveryAction.ownerAgentId,
-                });
-                if (reblocked)
-                    return reblocked;
-            }
+        if (!sourceAssigneePreserved) {
+            logger.error({
+                issueId: input.issue.id,
+                beforeAssigneeAgentId: input.issue.assigneeAgentId,
+                afterAssigneeAgentId: updated.assigneeAgentId,
+                beforeAssigneeUserId: input.issue.assigneeUserId,
+                afterAssigneeUserId: updated.assigneeUserId,
+            }, "automatic stranded recovery observed a concurrent source-owner change");
         }
         return updated;
     }
@@ -2845,6 +3173,7 @@ export function recoveryService(db, deps) {
             assignmentDispatched: 0,
             dispatchRequeued: 0,
             continuationRequeued: 0,
+            dispositionRepairRequeued: 0,
             productiveContinuationObserved: 0,
             successfulContinuationObserved: 0,
             orphanBlockersAssigned: 0,
@@ -2874,12 +3203,40 @@ export function recoveryService(db, deps) {
                 result.skipped += 1;
                 continue;
             }
+            let latestRun = await getLatestIssueRun(issue.companyId, issue.id);
             const agent = await getAgent(agentId);
             const agentInvokable = agent && agent.companyId === issue.companyId
                 ? await isAgentInvokable(agent)
                 : false;
             if (issue.status !== "in_review" && !agentInvokable) {
-                result.skipped += 1;
+                const classification = classifyContinuationFailure(latestRun);
+                if (classification.kind === "deliberate_wait_without_target" ||
+                    readDispositionRepairAttempt(latestRun)) {
+                    const outcome = await reconcileDispositionRepair(issue, latestRun);
+                    if (outcome === "escalated") {
+                        result.escalated += 1;
+                        result.issueIds.push(issue.id);
+                    }
+                    else {
+                        result.skipped += 1;
+                    }
+                }
+                else {
+                    const updated = await escalateStrandedAssignedIssue({
+                        issue,
+                        previousStatus: issue.status,
+                        latestRun,
+                        comment: "Paperclip cannot safely continue automatic recovery because the original assignee is not invokable. " +
+                            "The source assignment is unchanged and the board must choose the next action.",
+                    });
+                    if (updated) {
+                        result.escalated += 1;
+                        result.issueIds.push(issue.id);
+                    }
+                    else {
+                        result.skipped += 1;
+                    }
+                }
                 continue;
             }
             if (await hasActiveExecutionPath(issue.companyId, issue.id, issue.status === "in_review" ? agentId : null)) {
@@ -2894,11 +3251,44 @@ export function recoveryService(db, deps) {
                 result.skipped += 1;
                 continue;
             }
-            let latestRun = await getLatestIssueRun(issue.companyId, issue.id);
             if (isOperatorCancelledRun(latestRun)) {
                 result.operatorCancelExempted += 1;
                 continue;
             }
+            if (await isInvocationBudgetBlocked(issue, agentId)) {
+                const classification = classifyContinuationFailure(latestRun);
+                if (classification.kind === "deliberate_wait_without_target" ||
+                    readDispositionRepairAttempt(latestRun)) {
+                    const outcome = await reconcileDispositionRepair(issue, latestRun);
+                    if (outcome === "escalated") {
+                        result.escalated += 1;
+                        result.issueIds.push(issue.id);
+                    }
+                    else {
+                        result.skipped += 1;
+                    }
+                }
+                else {
+                    const updated = await escalateStrandedAssignedIssue({
+                        issue,
+                        previousStatus: issue.status,
+                        latestRun,
+                        recoveryCause: issue.status === "in_review"
+                            ? EXECUTION_REVIEW_PARTICIPANT_RECOVERY_REASON
+                            : undefined,
+                        comment: "Paperclip cannot safely continue automatic recovery because the original recovery target is over budget. " +
+                            "The source assignment is unchanged and the board must choose the next action.",
+                    });
+                    if (updated) {
+                        result.escalated += 1;
+                        result.issueIds.push(issue.id);
+                    }
+                    else {
+                        result.skipped += 1;
+                    }
+                }
+                continue;
+            }
             if (latestRun?.status === "succeeded" && await hasPersistedDurableWaitPath(issue)) {
                 result.skipped += 1;
                 continue;
@@ -2978,6 +3368,7 @@ export function recoveryService(db, deps) {
                 ? acceptedContinuationInteraction.resolvedAt ?? acceptedContinuationInteraction.updatedAt
                 : null;
             if (acceptedContinuationInteraction && acceptedInteractionResolvedAt && !pendingExecutionState) {
+                const legacyReviewParkAttempts = await summarizeRecentContinuationRetries(issue.companyId, issue.id, agentId, CONTINUATION_WAITING_ON_REVIEW_ERROR_CODE, acceptedInteractionResolvedAt);
                 const successfulRunSinceResolution = await hasSuccessfulIssueRunSince(issue.companyId, issue.id, agentId, acceptedInteractionResolvedAt, acceptedContinuationInteraction.id);
                 if (!successfulRunSinceResolution) {
                     if (!agentInvokable) {
@@ -2993,7 +3384,32 @@ export function recoveryService(db, deps) {
                         continue;
                     }
                     const latestPostResolutionRun = await getLatestIssueRunSince(issue.companyId, issue.id, agentId, acceptedInteractionResolvedAt);
-                    const { consecutive } = await summarizeRecentContinuationRetries(issue.companyId, issue.id, agentId, CONTINUATION_WAITING_ON_REVIEW_ERROR_CODE, acceptedInteractionResolvedAt);
+                    if (classifyContinuationFailure(latestPostResolutionRun).kind ===
+                        "deliberate_wait_without_target") {
+                        const resolved = await resolveContinuationWaitingOnReview(issue);
+                        if (resolved) {
+                            result.waitingOnReviewResolved += 1;
+                            result.issueIds.push(issue.id);
+                            continue;
+                        }
+                        const outcome = await reconcileDispositionRepair(issue, latestPostResolutionRun, {
+                            historicalAttemptCount: legacyReviewParkAttempts.consecutive,
+                        });
+                        if (outcome === "queued") {
+                            result.continuationRequeued += 1;
+                            result.dispositionRepairRequeued += 1;
+                            result.issueIds.push(issue.id);
+                        }
+                        else if (outcome === "escalated") {
+                            result.escalated += 1;
+                            result.issueIds.push(issue.id);
+                        }
+                        else {
+                            result.skipped += 1;
+                        }
+                        continue;
+                    }
+                    const { consecutive } = legacyReviewParkAttempts;
                     if (consecutive >= INTERACTION_CONTINUATION_REQUEUE_MAX_ATTEMPTS && latestPostResolutionRun) {
                         const resolved = await resolveContinuationWaitingOnReview(issue);
                         if (resolved) {
@@ -3058,7 +3474,6 @@ export function recoveryService(db, deps) {
                             latestRun: participantLatestRun,
                             notice: buildExecutionReviewParticipantUnavailableNoticeSeed(),
                             recoveryCause: EXECUTION_REVIEW_PARTICIPANT_RECOVERY_REASON,
-                            recoveryOwnerAgentId: participantAgentId,
                         });
                         if (updated) {
                             result.escalated += 1;
@@ -3098,7 +3513,6 @@ export function recoveryService(db, deps) {
                         previousStatus: "in_review",
                         latestRun: participantLatestRun,
                         recoveryCause: "configuration_incomplete",
-                        recoveryOwnerAgentId: participantAgentId,
                         comment: "Paperclip classified the active review participant's latest adapter failure as " +
                             "`configuration_incomplete`. Moving the issue to `blocked` with the configuration fix " +
                             "recorded instead of repeatedly requeueing the reviewer.",
@@ -3120,7 +3534,6 @@ export function recoveryService(db, deps) {
                         latestRun: participantLatestRun,
                         notice: buildExecutionReviewParticipantUnavailableNoticeSeed(),
                         recoveryCause: EXECUTION_REVIEW_PARTICIPANT_RECOVERY_REASON,
-                        recoveryOwnerAgentId: participantAgentId,
                     });
                     if (updated) {
                         result.escalated += 1;
@@ -3138,7 +3551,6 @@ export function recoveryService(db, deps) {
                         latestRun: participantLatestRun,
                         notice: buildExecutionReviewParticipantRecoveryNoticeSeed(),
                         recoveryCause: EXECUTION_REVIEW_PARTICIPANT_RECOVERY_REASON,
-                        recoveryOwnerAgentId: participantAgentId,
                     });
                     if (updated) {
                         result.escalated += 1;
@@ -3251,6 +3663,22 @@ export function recoveryService(db, deps) {
                 result.skipped += 1;
                 continue;
             }
+            if (readDispositionRepairAttempt(latestRun)) {
+                const outcome = await reconcileDispositionRepair(issue, latestRun);
+                if (outcome === "queued") {
+                    result.continuationRequeued += 1;
+                    result.dispositionRepairRequeued += 1;
+                    result.issueIds.push(issue.id);
+                }
+                else if (outcome === "escalated") {
+                    result.escalated += 1;
+                    result.issueIds.push(issue.id);
+                }
+                else {
+                    result.skipped += 1;
+                }
+                continue;
+            }
             const handoffEvidence = isExhaustedSuccessfulRunHandoff(latestRun);
             if (handoffEvidence) {
                 if (isPluginManagedIssueLifecycle(issue)) {
@@ -3339,6 +3767,20 @@ export function recoveryService(db, deps) {
                         result.issueIds.push(issue.id);
                         continue;
                     }
+                    const outcome = await reconcileDispositionRepair(issue, latestRun);
+                    if (outcome === "queued") {
+                        result.continuationRequeued += 1;
+                        result.dispositionRepairRequeued += 1;
+                        result.issueIds.push(issue.id);
+                    }
+                    else if (outcome === "escalated") {
+                        result.escalated += 1;
+                        result.issueIds.push(issue.id);
+                    }
+                    else {
+                        result.skipped += 1;
+                    }
+                    continue;
                 }
                 if (classification.kind === "non_retryable") {
                     const updated = await escalateStrandedAssignedIssue({
@@ -3422,6 +3864,12 @@ export function recoveryService(db, deps) {
         result.orphanBlockersAssigned = orphanBlockerRecovery.assigned;
         result.skipped += orphanBlockerRecovery.skipped;
         result.issueIds.push(...orphanBlockerRecovery.issueIds);
+        const activeRecovery = await reconcileActiveRecoveryActions();
+        result.continuationRequeued += activeRecovery.requeued;
+        result.escalated += activeRecovery.escalated;
+        result.skipped += activeRecovery.skipped;
+        result.issueIds.push(...activeRecovery.issueIds);
+        result.issueIds = [...new Set(result.issueIds)];
         return result;
     }
     async function collectIssueGraphLivenessFindings() {
@@ -3531,9 +3979,13 @@ export function recoveryService(db, deps) {
                     ? []
                     : db
                         .select({
+                        id: issueRecoveryActions.id,
                         companyId: issueRecoveryActions.companyId,
                         issueId: issueRecoveryActions.sourceIssueId,
                         status: issueRecoveryActions.status,
+                        ownerType: issueRecoveryActions.ownerType,
+                        ownerAgentId: issueRecoveryActions.ownerAgentId,
+                        ownerUserId: issueRecoveryActions.ownerUserId,
                     })
                         .from(issueRecoveryActions)
                         .where(and(inArray(issueRecoveryActions.status, ["active", "escalated"]), inArray(issueRecoveryActions.sourceIssueId, issueIdsUnderAnalysis)));
@@ -3566,6 +4018,20 @@ export function recoveryService(db, deps) {
                     status: row.status,
                 }];
         });
+        const liveRecoveryActionIds = new Set();
+        for (const row of activeRunRows) {
+            const recoveryActionId = readNonEmptyString(parseObject(row.contextSnapshot).recoveryActionId);
+            if (recoveryActionId)
+                liveRecoveryActionIds.add(recoveryActionId);
+        }
+        for (const row of wakeRows) {
+            const recoveryActionId = readNonEmptyString(parseObject(row.payload).recoveryActionId);
+            if (recoveryActionId)
+                liveRecoveryActionIds.add(recoveryActionId);
+        }
+        const healthyRecoveryActions = recoveryActionRows.filter((row) => (row.status === "escalated" && row.ownerType === "board") ||
+            Boolean(row.ownerUserId) ||
+            (Boolean(row.ownerAgentId) && liveRecoveryActionIds.has(row.id)));
         return classifyIssueGraphLiveness({
             issues: issueRows,
             relations: relationRows,
@@ -3589,7 +4055,7 @@ export function recoveryService(db, deps) {
             })),
             pendingInteractions: interactionRows,
             pendingApprovals: approvalRows,
-            openRecoveryIssues: openRecoveryIssues.concat(recoveryActionRows),
+            openRecoveryIssues: openRecoveryIssues.concat(healthyRecoveryActions),
             now: new Date(),
         });
     }
@@ -4096,6 +4562,7 @@ export function recoveryService(db, deps) {
                     companyId: issues.companyId,
                     identifier: issues.identifier,
                     assigneeAgentId: issues.assigneeAgentId,
+                    blockedTransitionAt: issues.blockedTransitionAt,
                     totalCount: sql `count(*) over()::int`,
                 })
                     .from(issueRelations)
@@ -4110,6 +4577,7 @@ export function recoveryService(db, deps) {
                 companyId: issues.companyId,
                 identifier: issues.identifier,
                 assigneeAgentId: issues.assigneeAgentId,
+                blockedTransitionAt: issues.blockedTransitionAt,
                 totalCount: sql `count(*) over()::int`,
             })
                 .from(issues)
@@ -4162,17 +4630,21 @@ export function recoveryService(db, deps) {
                     result.notReadySkipped += 1;
                     continue;
                 }
-                const idempotencyKeys = readiness.blockerIssueIds.map((blockerIssueId) => buildIssueBlockersResolvedWakeIdempotencyKey({
-                    dependentIssueId: candidate.id,
-                    resolvedBlockerIssueId: blockerIssueId,
-                }));
-                const idempotencyKey = buildIssueBlockersResolvedWakeIdempotencyKey({
+                // Level-triggered dedup: key on the full blocker set (the current ready
+                // state), not on any single resolved edge. An older completed per-edge
+                // wake for an earlier partial resolution has a different key, so it does
+                // not suppress this wake. The shared helper still suppresses a duplicate
+                // wake for the SAME ready state, which bounds reconciliation.
+                const idempotencyKey = buildIssueBlockersResolvedWakeStateKey({
                     dependentIssueId: candidate.id,
-                    resolvedBlockerIssueId,
+                    blockerIssueIds: readiness.blockerIssueIds,
+                    blockedTransitionAt: candidate.blockedTransitionAt,
                 });
-                const existingWake = await findExistingIssueBlockersResolvedWakeForAnyKey(db, {
+                const existingWake = await findExistingIssueBlockersResolvedWakeForReadyState(db, {
                     companyId,
-                    idempotencyKeys,
+                    dependentIssueId: candidate.id,
+                    blockerIssueIds: readiness.blockerIssueIds,
+                    blockedTransitionAt: candidate.blockedTransitionAt,
                 });
                 if (existingWake) {
                     result.existingWakeSkipped += 1;