@rudderhq/server 0.7.14 → 0.7.16

package/dist/services/runtime-kernel/heartbeat.d.ts

@@ -7,6 +7,7 @@ import type { WakeupOptions } from "./heartbeat.core.js";
 export declare function heartbeatService(db: Db, testHooks?: {
     afterIssuePromotionCommitted?: (outcome: unknown) => Promise<void> | void;
     beforeRunClaim?: (run: typeof heartbeatRuns.$inferSelect) => Promise<void> | void;
+    beforeAssignmentRecoveryEnqueue?: (run: typeof heartbeatRuns.$inferSelect) => Promise<void> | void;
     /** Server-owned runners (currently Chat) may reattach a claimed wait run. */
     onNetworkWaitingRun?: (run: typeof heartbeatRuns.$inferSelect & {
         networkRecoveryExhausted?: boolean;
@@ -56,6 +57,7 @@ export declare function heartbeatService(db: Db, testHooks?: {
         finishedAt: Date | null;
         error: string | null;
         wakeupRequestId: string | null;
+        sourceRunId: string | null;
         exitCode: number | null;
         signal: string | null;
         usageJson: Record<string, unknown> | null;
@@ -657,6 +659,7 @@ export declare function heartbeatService(db: Db, testHooks?: {
         finishedAt: Date | null;
         error: string | null;
         wakeupRequestId: string | null;
+        sourceRunId: string | null;
         exitCode: number | null;
         signal: string | null;
         usageJson: Record<string, unknown> | null;
@@ -721,6 +724,11 @@ export declare function heartbeatService(db: Db, testHooks?: {
         timedOut: number;
         runIds: string[];
     }>;
+    warnInactiveRuns: (opts?: {
+        minInactivityMs?: number;
+        now?: Date;
+        recoveryCutoff?: Date;
+    }) => Promise<any>;
     reapTimedOutRuns: (opts?: {
         maxRuntimeMs?: number;
         now?: Date;
@@ -743,6 +751,7 @@ export declare function heartbeatService(db: Db, testHooks?: {
         startedAt: Date | null;
         updatedAt: Date;
         wakeupRequestId: string | null;
+        sourceRunId: string | null;
         goalId: string | null;
         contextSnapshot: Record<string, unknown> | null;
         orgId: string;
@@ -825,6 +834,7 @@ export declare function heartbeatService(db: Db, testHooks?: {
         finishedAt: Date | null;
         error: string | null;
         wakeupRequestId: string | null;
+        sourceRunId: string | null;
         exitCode: number | null;
         signal: string | null;
         usageJson: Record<string, unknown> | null;

package/dist/services/runtime-kernel/heartbeat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heartbeat.d.ts","sourceRoot":"","sources":["../../../src/services/runtime-kernel/heartbeat.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"heartbeat.d.ts","sourceRoot":"","sources":["../../../src/services/runtime-kernel/heartbeat.ts"],"names":[],"mappings":"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"}

package/dist/services/runtime-kernel/heartbeat.execute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heartbeat.execute.d.ts","sourceRoot":"","sources":["../../../src/services/runtime-kernel/heartbeat.execute.ts"],"names":[],"mappings":"AA6EA,OAAO,EAAE,0CAA0C,EAAE,KAAK,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAsCnH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,GAAG;wBA2CxB,MAAM,SAAS;QAAE,iBAAiB,CAAC,EAAE,OAAO,CAAA;KAAE;EAypDhF"}
+{"version":3,"file":"heartbeat.execute.d.ts","sourceRoot":"","sources":["../../../src/services/runtime-kernel/heartbeat.execute.ts"],"names":[],"mappings":"AA0EA,OAAO,EAAE,0CAA0C,EAAE,KAAK,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAsCnH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,GAAG;wBA2CxB,MAAM,SAAS;QAAE,iBAAiB,CAAC,EAAE,OAAO,CAAA;KAAE;EAynDhF"}

package/dist/services/runtime-kernel/heartbeat.execute.js

@@ -21,9 +21,8 @@ import { buildExecutionWorkspaceAdapterConfig, issueExecutionWorkspaceModeForPer
 import { summarizeHeartbeatRunResultJson } from "../heartbeat-run-summary.js";
 import { publishLiveEvent } from "../live-events.js";
 import { isManagedWorkspaceConfigurationError, isWorkspacePermissionPreflightError, preflightManagedAgentWorkspace, } from "../managed-workspace-preflight.js";
-import { listProjectResourceAttachments } from "../resource-catalog.js";
 import { buildWorkspaceReadyComment, cleanupExecutionWorkspaceArtifacts, ensureRuntimeServicesForRun, persistAdapterManagedRuntimeServices, realizeExecutionWorkspace, releaseRuntimeServicesForRun } from "../workspace-runtime.js";
-import { AssignmentDependencyPreflightError, createAssignmentRunFailureBudget, inspectAssignmentRunWorkspace, repairAssignmentRunWorkspace, resolveProjectWorkingSetCwd, } from "./assignment-run-guardrail.js";
+import { ASSIGNMENT_RUN_RECOVERY_BACKOFF_MS, createAssignmentRunFailureBudget, formatAssignmentRunGuardrailError, } from "./assignment-run-guardrail.js";
 import { beginHeartbeatRunAttempt, finishHeartbeatRunAttempt, markHeartbeatRunAttemptWaiting, } from "./heartbeat-attempt-ledger.js";
 import { executeAdapterWithModelFallbacks } from "./model-fallback.js";
 export { prioritizeProjectWorkspaceCandidatesForRun } from "../agent-run-context.js";
@@ -60,7 +59,7 @@ function resolveRuntimeSceneForRun(run) {
     });
 }
 export function createHeartbeatExecuteHandlers(context) {
-    const { db, approvalsSvc, instanceSettings, getCurrentUserRedactionOptions, runLogStore, runContextSvc, issuesSvc, executionWorkspacesSvc, workspaceOperationsSvc, activeRunExecutions, runAbortControllers, budgetHooks, budgets, getAgent, getRun, getRuntimeState, getTaskSession, getLatestRunForSession, getOldestRunForSession, resolveNormalizedUsageForSession, evaluateSessionCompaction, resolveSessionBeforeForWakeup, resolveExplicitResumeSessionOverride, upsertTaskSession, clearTaskSessions, ensureRuntimeState, setRunStatus, transitionRunToTerminal, reconcileRunEvidence, reconcileTerminalEffectsIntent, setWakeupStatus, updateWakeupRequestRecord, insertWakeupRequestRecord, appendRunEvent, persistRunProcessMetadata, clearDetachedRunWarning, acknowledgeRunProcessExit, abortRunExecution, renewRunExecutionLease, enqueueRecoveryRun, enqueueProcessLossRetry, parseHeartbeatPolicy, markAgentHeartbeatChecked, evaluateTimerPreflight, runHasIssueClosureComment, runHasIssueReviewDecision, issueHasDeferredWake, passiveFollowupAlreadyRecorded, reviewerCloseoutAlreadyRecorded, issueHasRecordedBlockedReviewerDecision, evaluatePassiveIssueClosureForLockedIssue, countRunningRunsForAgent, claimQueuedRun, finalizeAgentStatus, completeTerminalControlEffects, reapOrphanedRuns, resumeQueuedRuns, updateRuntimeState, startNextQueuedRunForAgent, releaseIssueExecutionAndPromote, enqueueWakeup, resumeDeferredWakeupsForAgent, listProjectScopedRunIds, listProjectScopedWakeupIds, cancelPendingWakeupsForBudgetScope, cancelRunInternal, cancelActiveForAgentInternal, cancelBudgetScopeWork, retryRunInternal, buildSkillAnalytics } = context;
+    const { db, approvalsSvc, instanceSettings, getCurrentUserRedactionOptions, runLogStore, runContextSvc, issuesSvc, executionWorkspacesSvc, workspaceOperationsSvc, activeRunExecutions, runAbortControllers, budgetHooks, budgets, getAgent, getRun, getRuntimeState, getTaskSession, getLatestRunForSession, getOldestRunForSession, resolveNormalizedUsageForSession, evaluateSessionCompaction, resolveSessionBeforeForWakeup, resolveExplicitResumeSessionOverride, upsertTaskSession, clearTaskSessions, ensureRuntimeState, setRunStatus, transitionRunToTerminal, reconcileRunEvidence, reconcileTerminalEffectsIntent, setWakeupStatus, updateWakeupRequestRecord, insertWakeupRequestRecord, appendRunEvent, persistRunProcessMetadata, clearDetachedRunWarning, acknowledgeRunProcessExit, abortRunExecution, renewRunExecutionLease, enqueueRecoveryRun, enqueueProcessLossRetry, parseHeartbeatPolicy, markAgentHeartbeatChecked, evaluateTimerPreflight, runHasIssueClosureComment, runHasIssueReviewDecision, issueHasDeferredWake, passiveFollowupAlreadyRecorded, reviewerCloseoutAlreadyRecorded, issueHasRecordedBlockedReviewerDecision, evaluatePassiveIssueClosureForLockedIssue, countRunningRunsForAgent, claimQueuedRun, finalizeAgentStatus, completeTerminalControlEffects, reapOrphanedRuns, resumeQueuedRuns, updateRuntimeState, startNextQueuedRunForAgent, releaseIssueExecutionAndPromote, enqueueWakeup, resumeDeferredWakeupsForAgent, listProjectScopedRunIds, listProjectScopedWakeupIds, cancelPendingWakeupsForBudgetScope, cancelRunInternal, cancelActiveForAgentInternal, cancelBudgetScopeWork, retryRunInternal, buildSkillAnalytics, beforeAssignmentRecoveryEnqueue } = context;
     async function persistRunningExecutionContext(runId, desiredContext, patch = {}) {
         return db.transaction(async (tx) => {
             await tx.execute(sql `select id from heartbeat_runs where id = ${runId} for update`);
@@ -148,6 +147,7 @@ export function createHeartbeatExecuteHandlers(context) {
                 logger.warn({ err: error, runId: runId, attemptIndex: ref.attemptIndex }, "failed to persist heartbeat attempt terminal state");
             }
         };
+        let assignmentContinuationAttempt = Math.max(0, Math.floor(Number(parseObject(run.contextSnapshot).assignmentGuardrailContinuationAttempt) || 0));
         try {
             if (run.status === "queued") {
                 const claimed = await claimQueuedRun(run);
@@ -203,6 +203,8 @@ export function createHeartbeatExecuteHandlers(context) {
             let finalRunOutput = null;
             let ownsTerminalState = false;
             let shouldCompleteTerminalEffects = false;
+            let assignmentRecoveryEligible = false;
+            let assignmentRecoveryRequestedAt = null;
             let activeAttemptSpec = null;
             const finalizeExecutionTranscript = () => {
                 stdoutTranscriptBuffer = appendTranscriptEntriesFromChunk({
@@ -224,9 +226,10 @@ export function createHeartbeatExecuteHandlers(context) {
             await ensureRuntimeState(agent);
             const context = parseObject(run.contextSnapshot);
             delete context.rudderGitIdentity;
-            const assignmentContinuationAttempt = Math.max(0, Math.floor(Number(context.assignmentGuardrailContinuationAttempt) || 0));
+            assignmentContinuationAttempt = Math.max(0, Math.floor(Number(context.assignmentGuardrailContinuationAttempt) || 0));
             const assignmentGuardrailEnabled = run.invocationSource === "assignment"
                 || context.wakeSource === "assignment"
+                || run.invocationSource === "automation"
                 || assignmentContinuationAttempt > 0;
             const assignmentFailureBudget = assignmentGuardrailEnabled ? createAssignmentRunFailureBudget() : null;
             let assignmentGuardrailCheckpoint = null;
@@ -315,6 +318,7 @@ export function createHeartbeatExecuteHandlers(context) {
                     sessionDisplayId: run.sessionReuseScope === "none" ? null : frozenSessionDisplayId,
                 };
             const previousSessionParams = sessionSelection.sessionParams;
+            const runtimeScene = resolveRuntimeSceneForRun(run);
             const config = await runContextSvc.materializeManagedInstructionsForRun({
                 ...agent,
                 agentRuntimeConfig: parseObject(agent.agentRuntimeConfig),
@@ -324,27 +328,7 @@ export function createHeartbeatExecuteHandlers(context) {
                 issueSettings: issueExecutionWorkspaceSettings,
                 legacyUseProjectWorkspace: runtimeOverrides?.useProjectWorkspace ?? null,
             });
-            let resolvedWorkspace = await runContextSvc.resolveWorkspaceForRun(agent, context, previousSessionParams, { useProjectWorkspace: executionWorkspaceMode !== "agent_default" });
-            let configuredProjectWorkingSetCwd = null;
-            if (assignmentGuardrailEnabled && executionProjectId) {
-                const projectResources = await listProjectResourceAttachments(db, agent.orgId, executionProjectId);
-                const projectWorkingSetCwd = resolveProjectWorkingSetCwd(projectResources);
-                configuredProjectWorkingSetCwd = projectWorkingSetCwd;
-                if (projectWorkingSetCwd) {
-                    const workingSetAvailable = await inspectAssignmentRunWorkspace({
-                        actualCwd: projectWorkingSetCwd,
-                        projectWorkingSetCwd,
-                    }).then((result) => result.cwdPresent);
-                    if (workingSetAvailable) {
-                        resolvedWorkspace = {
-                            ...resolvedWorkspace,
-                            cwd: projectWorkingSetCwd,
-                            source: "project_primary",
-                            projectId: executionProjectId,
-                        };
-                    }
-                }
-            }
+            const resolvedWorkspace = await runContextSvc.resolveWorkspaceForRun(agent, context, previousSessionParams, { useProjectWorkspace: executionWorkspaceMode !== "agent_default" });
             const workspaceManagedConfig = buildExecutionWorkspaceAdapterConfig({
                 agentConfig: config,
                 projectPolicy: projectExecutionWorkspacePolicy,
@@ -356,7 +340,7 @@ export function createHeartbeatExecuteHandlers(context) {
                 ? { ...workspaceManagedConfig, ...runtimeOverrides.agentRuntimeConfig }
                 : workspaceManagedConfig;
             const { resolvedConfig, runtimeConfig, runtimeSkillEntries, secretKeys } = await runContextSvc.prepareRuntimeConfig({
-                scene: "heartbeat",
+                scene: runtimeScene,
                 agent,
                 baseConfig: mergedConfig,
             });
@@ -551,7 +535,6 @@ export function createHeartbeatExecuteHandlers(context) {
                     ]
                     : []),
             ];
-            const runtimeScene = resolveRuntimeSceneForRun(run);
             const runtimeSceneContext = await runContextSvc.buildSceneContext({
                 scene: runtimeScene,
                 agent,
@@ -692,88 +675,6 @@ export function createHeartbeatExecuteHandlers(context) {
                     level: "info",
                     message: "run started",
                 });
-                if (assignmentGuardrailEnabled) {
-                    const initialWorkspacePreflight = await inspectAssignmentRunWorkspace({
-                        actualCwd: executionWorkspace.cwd,
-                        projectWorkingSetCwd: configuredProjectWorkingSetCwd ?? resolvedWorkspace.cwd,
-                    });
-                    const dependencyRepair = initialWorkspacePreflight.ready
-                        ? null
-                        : await repairAssignmentRunWorkspace({ preflight: initialWorkspacePreflight });
-                    const workspacePreflight = dependencyRepair?.final ?? initialWorkspacePreflight;
-                    if (dependencyRepair && !dependencyRepair.succeeded) {
-                        await appendRunEvent(currentRun, {
-                            eventType: "runtime.assignment_dependency_repair",
-                            stream: "system",
-                            level: "warn",
-                            message: dependencyRepair.skippedReason
-                                ? `assignment dependency repair skipped: ${dependencyRepair.skippedReason}`
-                                : "assignment dependency repair did not make the workspace ready",
-                            payload: {
-                                command: dependencyRepair.command,
-                                attempted: dependencyRepair.attempted,
-                                coalesced: dependencyRepair.coalesced,
-                                rechecked: dependencyRepair.rechecked,
-                                succeeded: dependencyRepair.succeeded,
-                                output: dependencyRepair.output,
-                                skippedReason: dependencyRepair.skippedReason,
-                                workspaceFingerprint: dependencyRepair.workspaceFingerprint,
-                                readinessFingerprint: dependencyRepair.readinessFingerprint,
-                                initialReady: dependencyRepair.initial.ready,
-                                finalReady: dependencyRepair.final.ready,
-                            },
-                        });
-                    }
-                    else if (dependencyRepair?.attempted) {
-                        await appendRunEvent(currentRun, {
-                            eventType: "runtime.assignment_dependency_repair",
-                            stream: "system",
-                            level: "info",
-                            message: "assignment dependency repair completed",
-                            payload: {
-                                command: dependencyRepair.command,
-                                attempted: dependencyRepair.attempted,
-                                coalesced: dependencyRepair.coalesced,
-                                rechecked: dependencyRepair.rechecked,
-                                succeeded: dependencyRepair.succeeded,
-                                output: dependencyRepair.output,
-                                skippedReason: dependencyRepair.skippedReason,
-                                workspaceFingerprint: dependencyRepair.workspaceFingerprint,
-                                readinessFingerprint: dependencyRepair.readinessFingerprint,
-                                initialReady: dependencyRepair.initial.ready,
-                                finalReady: dependencyRepair.final.ready,
-                            },
-                        });
-                    }
-                    await appendRunEvent(currentRun, {
-                        eventType: "runtime.assignment_preflight",
-                        stream: "system",
-                        level: workspacePreflight.ready ? "info" : "error",
-                        message: workspacePreflight.ready
-                            ? dependencyRepair?.attempted
-                                ? "assignment run workspace preflight passed after dependency repair"
-                                : "assignment run workspace preflight passed"
-                            : "assignment run workspace preflight failed",
-                        payload: {
-                            ...workspacePreflight,
-                            initialReady: dependencyRepair?.initial.ready ?? workspacePreflight.ready,
-                            dependencyRepair: dependencyRepair
-                                ? {
-                                    command: dependencyRepair.command,
-                                    attempted: dependencyRepair.attempted,
-                                    coalesced: dependencyRepair.coalesced,
-                                    rechecked: dependencyRepair.rechecked,
-                                    succeeded: dependencyRepair.succeeded,
-                                    output: dependencyRepair.output,
-                                    skippedReason: dependencyRepair.skippedReason,
-                                }
-                                : null,
-                        },
-                    });
-                    if (!workspacePreflight.ready) {
-                        throw new AssignmentDependencyPreflightError(workspacePreflight, dependencyRepair);
-                    }
-                }
                 handle = await runLogStore.begin({
                     orgId: run.orgId,
                     agentId: run.agentId,
@@ -845,7 +746,8 @@ export function createHeartbeatExecuteHandlers(context) {
                                 .slice(0, 2_000)
                                 ?? "No reliable completed-work summary was emitted before the guardrail stopped this run.";
                             assignmentGuardrailCheckpoint = { ...checkpoint, completedWorkSummary };
-                            const continuationRequired = assignmentContinuationAttempt < 1;
+                            const continuationRequired = assignmentContinuationAttempt < 1
+                                && assignmentGuardrailCheckpoint.automaticContinuationAllowed;
                             await appendRunEvent(currentRun, {
                                 eventType: "runtime.assignment_guardrail",
                                 stream: "system",
@@ -1034,7 +936,9 @@ export function createHeartbeatExecuteHandlers(context) {
                     },
                 });
                 if (assignmentGuardrailCheckpoint) {
-                    adapterResult.errorMessage = "Assignment run stopped after reaching its tool failure budget";
+                    assignmentRecoveryEligible = assignmentContinuationAttempt < 1
+                        && assignmentGuardrailCheckpoint.automaticContinuationAllowed;
+                    adapterResult.errorMessage = formatAssignmentRunGuardrailError(assignmentGuardrailCheckpoint, assignmentRecoveryEligible);
                     adapterResult.errorCode = "assignment_run_failure_budget";
                     adapterResult.exitCode = adapterResult.exitCode ?? 1;
                     adapterResult.resultJson = {
@@ -1318,12 +1222,13 @@ export function createHeartbeatExecuteHandlers(context) {
                     logSha256: logSummary?.sha256,
                     logCompressed: logSummary?.compressed ?? false,
                 };
+                const automationTerminalEffect = {
+                    output: transcriptFallbackResult?.output ?? terminalEvidence.error,
+                    transcript: executionTranscript,
+                };
                 const terminalEffectsIntent = {
                     version: 1,
-                    automation: {
-                        output: transcriptFallbackResult?.output ?? terminalEvidence.error,
-                        transcript: executionTranscript,
-                    },
+                    automation: automationTerminalEffect,
                     runtime: {
                         adapterResult: adapterResult,
                         legacySessionId: nextSessionState.legacySessionId,
@@ -1437,7 +1342,8 @@ export function createHeartbeatExecuteHandlers(context) {
                         shouldCompleteTerminalEffects = true;
                     }
                     if (ownsTerminalState && assignmentGuardrailCheckpoint) {
-                        const continuationRequired = assignmentContinuationAttempt < 1;
+                        const continuationRequired = assignmentContinuationAttempt < 1
+                            && assignmentGuardrailCheckpoint.automaticContinuationAllowed;
                         await appendRunEvent(finalizedRun, {
                             eventType: "runtime.assignment_checkpoint",
                             stream: "system",
@@ -1449,32 +1355,83 @@ export function createHeartbeatExecuteHandlers(context) {
                                 nextRecoveryCommand: assignmentGuardrailCheckpoint.nextRecoveryCommand,
                                 continuationRequired,
                                 failureCount: assignmentGuardrailCheckpoint.failureCount,
+                                unresolvedFailureCount: assignmentGuardrailCheckpoint.unresolvedFailureCount,
+                                failureClass: assignmentGuardrailCheckpoint.failureClass,
+                                continuationBlockReason: assignmentGuardrailCheckpoint.continuationBlockReason,
                                 fingerprint: assignmentGuardrailCheckpoint.fingerprint,
                             },
                         });
                         if (continuationRequired) {
-                            await enqueueRecoveryRun(finalizedRun, agent, {
-                                recoveryTrigger: "automatic",
-                                source: "automation",
-                                triggerDetail: "system",
-                                wakeReason: "assignment_failure_budget_continuation",
-                                requestedByActorType: "system",
-                                requestedByActorId: null,
-                                contextPatch: {
-                                    assignmentGuardrailContinuationAttempt: assignmentContinuationAttempt + 1,
-                                    assignmentGuardrailCheckpoint,
-                                },
-                                startImmediately: false,
-                                now: new Date(),
-                            });
+                            const recoveryRequestedAt = new Date(Date.now() + ASSIGNMENT_RUN_RECOVERY_BACKOFF_MS);
+                            let recoveryRun = null;
+                            try {
+                                await beforeAssignmentRecoveryEnqueue?.(finalizedRun);
+                                recoveryRun = await enqueueRecoveryRun(finalizedRun, agent, {
+                                    recoveryTrigger: "automatic",
+                                    source: "automation",
+                                    triggerDetail: "system",
+                                    wakeReason: "assignment_failure_budget_continuation",
+                                    requestedByActorType: "system",
+                                    requestedByActorId: null,
+                                    contextPatch: {
+                                        assignmentGuardrailContinuationAttempt: assignmentContinuationAttempt + 1,
+                                        assignmentGuardrailCheckpoint,
+                                        assignmentGuardrailRecovery: {
+                                            attempt: assignmentContinuationAttempt + 1,
+                                            maxAttempts: 1,
+                                            backoffMs: ASSIGNMENT_RUN_RECOVERY_BACKOFF_MS,
+                                            requestedAt: recoveryRequestedAt.toISOString(),
+                                        },
+                                    },
+                                    startImmediately: false,
+                                    notBefore: recoveryRequestedAt,
+                                    suppressSourceAutomationOutput: true,
+                                    now: new Date(),
+                                });
+                            }
+                            catch (recoveryError) {
+                                const recoveryErrorMessage = recoveryError instanceof Error
+                                    ? recoveryError.message
+                                    : "Unknown recovery enqueue failure";
+                                await appendRunEvent(finalizedRun, {
+                                    eventType: "runtime.assignment_recovery_request_failed",
+                                    stream: "system",
+                                    level: "error",
+                                    message: "bounded assignment recovery request failed",
+                                    payload: {
+                                        attempt: assignmentContinuationAttempt + 1,
+                                        maxAttempts: 1,
+                                        failureClass: assignmentGuardrailCheckpoint.failureClass,
+                                        error: recoveryErrorMessage,
+                                    },
+                                });
+                                logger.error({ err: recoveryError, runId: finalizedRun.id }, "failed to enqueue bounded assignment recovery");
+                            }
+                            if (recoveryRun) {
+                                assignmentRecoveryRequestedAt = recoveryRequestedAt;
+                                await appendRunEvent(finalizedRun, {
+                                    eventType: "runtime.assignment_recovery_requested",
+                                    stream: "system",
+                                    level: "warn",
+                                    message: "bounded assignment recovery requested",
+                                    payload: {
+                                        recoveryRunId: recoveryRun.id,
+                                        attempt: assignmentContinuationAttempt + 1,
+                                        maxAttempts: 1,
+                                        backoffMs: ASSIGNMENT_RUN_RECOVERY_BACKOFF_MS,
+                                        requestedAt: recoveryRequestedAt.toISOString(),
+                                        failureClass: assignmentGuardrailCheckpoint.failureClass,
+                                    },
+                                }).catch((eventError) => {
+                                    logger.error({ err: eventError, runId: finalizedRun.id }, "failed to record bounded assignment recovery request");
+                                });
+                            }
                         }
                     }
                 }
             }
             catch (err) {
-                const isAssignmentDependencyPreflightFailure = err instanceof AssignmentDependencyPreflightError;
-                const isWorkspacePreflightFailure = isAssignmentDependencyPreflightFailure ||
-                    isWorkspacePermissionPreflightError(err) ||
+                const isWorkspacePreflightFailure = isWorkspacePermissionPreflightError(err) ||
                     isManagedWorkspaceConfigurationError(err);
                 const message = redactCurrentUserText(err instanceof Error ? err.message : "Unknown adapter failure", await getCurrentUserRedactionOptions());
                 transcriptFallbackResult = {
@@ -1593,11 +1550,9 @@ export function createHeartbeatExecuteHandlers(context) {
                     if (ownsTerminalState) {
                         await appendForbiddenMarkerEvent(failedRun, buildForbiddenMarkerScan(null));
                         await appendRunEvent(failedRun, {
-                            eventType: isAssignmentDependencyPreflightFailure
-                                ? "runtime.assignment_preflight_failed"
-                                : isWorkspacePreflightFailure
-                                    ? "runtime.workspace_preflight_failed"
-                                    : "error",
+                            eventType: isWorkspacePreflightFailure
+                                ? "runtime.workspace_preflight_failed"
+                                : "error",
                             stream: "system",
                             level: "error",
                             message,
@@ -1605,9 +1560,7 @@ export function createHeartbeatExecuteHandlers(context) {
                                 ? {
                                     payload: {
                                         errorCode: err.errorCode,
-                                        ...(isAssignmentDependencyPreflightFailure
-                                            ? err.failure
-                                            : { failure: err.failure }),
+                                        failure: err.failure,
                                     },
                                 }
                                 : {}),
@@ -1633,6 +1586,15 @@ export function createHeartbeatExecuteHandlers(context) {
                             : undefined);
                     }
                 }
+                if (assignmentRecoveryRequestedAt) {
+                    const delayMs = Math.max(0, assignmentRecoveryRequestedAt.getTime() - Date.now());
+                    const recoveryTimer = setTimeout(() => {
+                        void startNextQueuedRunForAgent(agent.id).catch((error) => {
+                            logger.error({ err: error, runId }, "failed to start bounded assignment recovery");
+                        });
+                    }, delayMs);
+                    recoveryTimer.unref?.();
+                }
             }
         }
         catch (outerErr) {