@penclipai/server 2026.426.0 → 2026.505.0

package/dist/services/heartbeat.js

@@ -3,14 +3,14 @@ import path from "node:path";
 import { execFile as execFileCallback } from "node:child_process";
 import { promisify } from "node:util";
 import { randomUUID } from "node:crypto";
-import { and, asc, desc, eq, getTableColumns, gt, inArray, isNull, lte, notInArray, or, sql } from "drizzle-orm";
-import { AGENT_DEFAULT_MAX_CONCURRENT_RUNS, ISSUE_CONTINUATION_SUMMARY_DOCUMENT_KEY, } from "@penclipai/shared";
+import { and, asc, desc, eq, getTableColumns, gt, inArray, isNull, lt, lte, notInArray, or, sql } from "drizzle-orm";
+import { AGENT_DEFAULT_MAX_CONCURRENT_RUNS, ISSUE_CONTINUATION_SUMMARY_DOCUMENT_KEY, MODEL_PROFILE_KEYS, } from "@penclipai/shared";
 import { agents, agentRuntimeState, agentTaskSessions, agentWakeupRequests, activityLog, companySkills as companySkillsTable, documentRevisions, issueDocuments, heartbeatRunEvents, heartbeatRuns, issueComments, issueRelations, issues, issueWorkProducts, projects, projectWorkspaces, workspaceOperations, } from "@penclipai/db";
 import { conflict, HttpError, notFound } from "../errors.js";
 import { logger } from "../middleware/logger.js";
 import { publishLiveEvent } from "./live-events.js";
 import { getRunLogStore } from "./run-log-store.js";
-import { getServerAdapter, runningProcesses } from "../adapters/index.js";
+import { getServerAdapter, listAdapterModelProfiles, runningProcesses } from "../adapters/index.js";
 import { createLocalAgentJwt } from "../agent-auth-jwt.js";
 import { parseObject, asBoolean, asNumber, appendWithByteCap, MAX_EXCERPT_BYTES } from "../adapters/utils.js";
 import { costService } from "./costs.js";
@@ -21,11 +21,12 @@ import { budgetService } from "./budgets.js";
 import { secretService } from "./secrets.js";
 import { resolveDefaultAgentWorkspaceDir, resolveManagedProjectWorkspaceDir } from "../home-paths.js";
 import { buildHeartbeatRunIssueComment, HEARTBEAT_RUN_RESULT_OUTPUT_MAX_CHARS, HEARTBEAT_RUN_RESULT_SUMMARY_MAX_CHARS, HEARTBEAT_RUN_SAFE_RESULT_JSON_MAX_BYTES, mergeHeartbeatRunResultJson, } from "./heartbeat-run-summary.js";
-import { buildHeartbeatRunStopMetadata, mergeHeartbeatRunStopMetadata, } from "./heartbeat-stop-metadata.js";
+import { buildHeartbeatRunStopMetadata, mergeHeartbeatRunStopMetadata, normalizeMaxTurnStopReason, } from "./heartbeat-stop-metadata.js";
 import { classifyRunLiveness, } from "./run-liveness.js";
 import { logActivity, publishPluginDomainEvent } from "./activity-log.js";
 import { buildWorkspaceReadyComment, cleanupExecutionWorkspaceArtifacts, ensureRuntimeServicesForRun, persistAdapterManagedRuntimeServices, realizeExecutionWorkspace, releaseRuntimeServicesForRun, sanitizeRuntimeServiceBaseEnv, } from "./workspace-runtime.js";
 import { issueService } from "./issues.js";
+import { buildIssueMonitorClearedPatch, buildIssueMonitorTriggeredPatch, normalizeIssueExecutionPolicy, parseIssueExecutionState, } from "./issue-execution-policy.js";
 import { ISSUE_TREE_CONTROL_INTERACTION_WAKE_REASONS, isVerifiedIssueTreeControlInteractionWake, issueTreeControlService, } from "./issue-tree-control.js";
 import { getIssueContinuationSummaryDocument, refreshIssueContinuationSummary, } from "./issue-continuation-summary.js";
 import { executionWorkspaceService, mergeExecutionWorkspaceConfig } from "./execution-workspaces.js";
@@ -35,11 +36,13 @@ import { resolveRuntimeLocalizationPrompt, } from "./agent-runtime-localization.
 import { canCoalesceWithRunLocale, materializeRuntimeUiLocaleContextSnapshot, resolveContextRuntimeUiLocale, } from "./heartbeat-runtime-locale.js";
 import { buildExecutionWorkspaceAdapterConfig, gateProjectExecutionWorkspacePolicy, issueExecutionWorkspaceModeForPersistedWorkspace, parseIssueExecutionWorkspaceSettings, parseProjectExecutionWorkspacePolicy, resolveExecutionWorkspaceEnvironmentId, resolveExecutionWorkspaceMode, } from "./execution-workspace-policy.js";
 import { instanceSettingsService } from "./instance-settings.js";
-import { RUN_LIVENESS_CONTINUATION_REASON, buildRunLivenessContinuationIdempotencyKey, decideRunLivenessContinuation, findExistingRunLivenessContinuationWake, readContinuationAttempt, } from "./recovery/index.js";
+import { RECOVERY_ORIGIN_KINDS, RUN_LIVENESS_CONTINUATION_REASON, buildRunLivenessContinuationIdempotencyKey, decideRunLivenessContinuation, findExistingRunLivenessContinuationWake, readContinuationAttempt, } from "./recovery/index.js";
 import { isAutomaticRecoverySuppressedByPauseHold } from "./recovery/pause-hold-guard.js";
 import { recoveryService } from "./recovery/service.js";
+import { productivityReviewService } from "./productivity-review.js";
 import { withAgentStartLock } from "./agent-start-lock.js";
 import { redactCurrentUserText, redactCurrentUserValue } from "../log-redaction.js";
+import { redactEventPayload } from "../redaction.js";
 import { hasSessionCompactionThresholds, resolveSessionCompactionPolicy, } from "@penclipai/adapter-utils";
 import { readPaperclipSkillSyncPreference, writePaperclipSkillSyncPreference, } from "@penclipai/adapter-utils/server-utils";
 import { extractSkillMentionIds } from "@penclipai/shared";
@@ -53,7 +56,8 @@ const MAX_RUN_EVENT_PAYLOAD_ARRAY_ITEMS = 50;
 const MAX_RUN_EVENT_PAYLOAD_OBJECT_KEYS = 100;
 const MAX_RUN_EVENT_PAYLOAD_DEPTH = 6;
 const HEARTBEAT_MAX_CONCURRENT_RUNS_DEFAULT = AGENT_DEFAULT_MAX_CONCURRENT_RUNS;
-const HEARTBEAT_MAX_CONCURRENT_RUNS_MAX = 10;
+const HEARTBEAT_MAX_CONCURRENT_RUNS_MIN = 1;
+const HEARTBEAT_MAX_CONCURRENT_RUNS_MAX = 50;
 const LIVENESS_BOOKKEEPING_ACTIVITY_ACTIONS = [
     "environment.lease_acquired",
     "environment.lease_released",
@@ -85,6 +89,13 @@ const BOUNDED_TRANSIENT_HEARTBEAT_RETRY_JITTER_RATIO = 0.25;
 const BOUNDED_TRANSIENT_HEARTBEAT_RETRY_REASON = "transient_failure";
 const BOUNDED_TRANSIENT_HEARTBEAT_RETRY_WAKE_REASON = "transient_failure_retry";
 const BOUNDED_TRANSIENT_HEARTBEAT_RETRY_MAX_ATTEMPTS = BOUNDED_TRANSIENT_HEARTBEAT_RETRY_DELAYS_MS.length;
+export const MAX_TURN_CONTINUATION_RETRY_REASON = "max_turns_continuation";
+export const MAX_TURN_CONTINUATION_WAKE_REASON = "max_turns_continuation_retry";
+const MAX_TURN_CONTINUATION_DEFAULT_MAX_ATTEMPTS = 2;
+const MAX_TURN_CONTINUATION_MAX_ATTEMPTS_CAP = 10;
+const MAX_TURN_CONTINUATION_DEFAULT_DELAY_MS = 1_000;
+const MAX_TURN_CONTINUATION_MAX_DELAY_MS = 5 * 60 * 1000;
+const MAX_TURN_CONTINUATION_LIVE_RUN_STATUSES = ["scheduled_retry", "queued", "running"];
 function resolveCodexTransientFallbackMode(attempt) {
     if (attempt <= 1)
         return "same_session";
@@ -104,6 +115,11 @@ function readHeartbeatRunErrorFamily(run) {
     }
     return null;
 }
+function isMaxTurnExhaustionRun(run) {
+    const resultJson = parseObject(run.resultJson);
+    return Boolean(normalizeMaxTurnStopReason(resultJson.stopReason) ??
+        normalizeMaxTurnStopReason(run.errorCode));
+}
 function readTransientRetryNotBeforeFromRun(run) {
     const resultJson = parseObject(run.resultJson);
     const value = resultJson.retryNotBefore ?? resultJson.transientRetryNotBefore;
@@ -547,6 +563,8 @@ const heartbeatRunIssueSummaryColumns = {
     status: heartbeatRuns.status,
     invocationSource: heartbeatRuns.invocationSource,
     triggerDetail: heartbeatRuns.triggerDetail,
+    contextCommentId: sql `${heartbeatRuns.contextSnapshot} ->> 'commentId'`.as("contextCommentId"),
+    contextWakeCommentId: sql `${heartbeatRuns.contextSnapshot} ->> 'wakeCommentId'`.as("contextWakeCommentId"),
     startedAt: heartbeatRuns.startedAt,
     finishedAt: heartbeatRuns.finishedAt,
     createdAt: heartbeatRuns.createdAt,
@@ -653,7 +671,7 @@ function normalizeMaxConcurrentRuns(value) {
     const parsed = Math.floor(asNumber(value, HEARTBEAT_MAX_CONCURRENT_RUNS_DEFAULT));
     if (!Number.isFinite(parsed))
         return HEARTBEAT_MAX_CONCURRENT_RUNS_DEFAULT;
-    return Math.max(HEARTBEAT_MAX_CONCURRENT_RUNS_DEFAULT, Math.min(HEARTBEAT_MAX_CONCURRENT_RUNS_MAX, parsed));
+    return Math.max(HEARTBEAT_MAX_CONCURRENT_RUNS_MIN, Math.min(HEARTBEAT_MAX_CONCURRENT_RUNS_MAX, parsed));
 }
 export function prioritizeProjectWorkspaceCandidatesForRun(rows, preferredWorkspaceId) {
     if (!preferredWorkspaceId)
@@ -666,6 +684,113 @@ export function prioritizeProjectWorkspaceCandidatesForRun(rows, preferredWorksp
 function readNonEmptyString(value) {
     return typeof value === "string" && value.trim().length > 0 ? value : null;
 }
+function readModelProfileKey(value) {
+    return MODEL_PROFILE_KEYS.includes(value)
+        ? value
+        : null;
+}
+function readContextModelProfile(contextSnapshot) {
+    return readModelProfileKey(contextSnapshot?.modelProfile);
+}
+export function normalizeModelProfileWakeContext(input) {
+    const modelProfileFromPayload = readModelProfileKey(input.payload?.modelProfile);
+    if (!readContextModelProfile(input.contextSnapshot) && modelProfileFromPayload) {
+        input.contextSnapshot.modelProfile = modelProfileFromPayload;
+    }
+    return input.contextSnapshot;
+}
+function readAgentRuntimeModelProfile(runtimeConfig, key) {
+    const modelProfiles = parseObject(parseObject(runtimeConfig).modelProfiles);
+    const profile = parseObject(modelProfiles[key]);
+    if (Object.keys(profile).length === 0) {
+        return { enabled: true, adapterConfig: {}, configured: false };
+    }
+    return {
+        enabled: profile.enabled !== false,
+        adapterConfig: parseObject(profile.adapterConfig),
+        configured: true,
+    };
+}
+export function resolveModelProfileApplication(input) {
+    const issueModelProfile = input.issueModelProfile ?? null;
+    const contextModelProfile = readContextModelProfile(input.contextSnapshot);
+    const requested = issueModelProfile ?? contextModelProfile;
+    const requestedBy = issueModelProfile
+        ? "issue_override"
+        : contextModelProfile
+            ? "wake_context"
+            : null;
+    if (!requested) {
+        return {
+            requested: null,
+            requestedBy: null,
+            applied: null,
+            configSource: null,
+            fallbackReason: null,
+            adapterConfig: null,
+        };
+    }
+    const adapterProfile = input.adapterModelProfiles.find((profile) => profile.key === requested) ?? null;
+    if (!adapterProfile) {
+        return {
+            requested,
+            requestedBy,
+            applied: null,
+            configSource: null,
+            fallbackReason: input.profileResolutionFallbackReason ?? "adapter_profile_not_supported",
+            adapterConfig: null,
+        };
+    }
+    const runtimeProfile = readAgentRuntimeModelProfile(input.agentRuntimeConfig, requested);
+    if (!runtimeProfile.enabled) {
+        return {
+            requested,
+            requestedBy,
+            applied: null,
+            configSource: null,
+            fallbackReason: "agent_runtime_profile_disabled",
+            adapterConfig: null,
+        };
+    }
+    return {
+        requested,
+        requestedBy,
+        applied: requested,
+        configSource: runtimeProfile.configured ? "agent_runtime" : "adapter_default",
+        fallbackReason: null,
+        adapterConfig: {
+            ...parseObject(adapterProfile.adapterConfig),
+            ...runtimeProfile.adapterConfig,
+        },
+    };
+}
+export function mergeModelProfileAdapterConfig(input) {
+    return {
+        ...input.baseConfig,
+        ...(input.modelProfile.adapterConfig ?? {}),
+        ...(input.issueAdapterConfig ?? {}),
+    };
+}
+function modelProfileRunMetadata(modelProfile) {
+    if (!modelProfile.requested)
+        return null;
+    return {
+        requested: modelProfile.requested,
+        requestedBy: modelProfile.requestedBy,
+        applied: modelProfile.applied,
+        configSource: modelProfile.configSource,
+        fallbackReason: modelProfile.fallbackReason,
+    };
+}
+function mergeModelProfileRunMetadata(resultJson, modelProfile) {
+    const metadata = modelProfileRunMetadata(modelProfile);
+    if (!metadata)
+        return resultJson;
+    return {
+        ...(resultJson ?? {}),
+        modelProfile: metadata,
+    };
+}
 export function summarizeHeartbeatRunContextSnapshot(contextSnapshot) {
     const summary = {};
     const allowedKeys = [
@@ -677,6 +802,7 @@ export function summarizeHeartbeatRunContextSnapshot(contextSnapshot) {
         "wakeReason",
         "wakeSource",
         "wakeTriggerDetail",
+        "modelProfile",
     ];
     for (const key of allowedKeys) {
         const value = readNonEmptyString(contextSnapshot?.[key]);
@@ -931,14 +1057,18 @@ export function resolveRuntimeSessionParamsForWorkspace(input) {
 }
 function parseIssueAssigneeAdapterOverrides(raw) {
     const parsed = parseObject(raw);
+    const modelProfile = MODEL_PROFILE_KEYS.includes(parsed.modelProfile)
+        ? parsed.modelProfile
+        : null;
     const parsedAdapterConfig = parseObject(parsed.adapterConfig);
     const adapterConfig = Object.keys(parsedAdapterConfig).length > 0 ? parsedAdapterConfig : null;
     const useProjectWorkspace = typeof parsed.useProjectWorkspace === "boolean"
         ? parsed.useProjectWorkspace
         : null;
-    if (!adapterConfig && useProjectWorkspace === null)
+    if (!modelProfile && !adapterConfig && useProjectWorkspace === null)
         return null;
     return {
+        modelProfile,
         adapterConfig,
         useProjectWorkspace,
     };
@@ -1162,6 +1292,7 @@ function enrichWakeContextSnapshot(input) {
     if (!readNonEmptyString(contextSnapshot["wakeTriggerDetail"]) && triggerDetail) {
         contextSnapshot.wakeTriggerDetail = triggerDetail;
     }
+    normalizeModelProfileWakeContext({ contextSnapshot, payload });
     return {
         contextSnapshot,
         issueIdFromPayload,
@@ -1514,7 +1645,23 @@ export function heartbeatService(db, options = {}) {
     };
     const budgets = budgetService(db, budgetHooks);
     const recovery = recoveryService(db, { enqueueWakeup });
+    const productivityReviews = productivityReviewService(db, { enqueueWakeup });
     let unsafeTextProjectionPromise = null;
+    async function releaseEnvironmentLeasesForRun(input) {
+        const releaseResult = await envOrchestrator.releaseForRun({
+            heartbeatRunId: input.runId,
+            companyId: input.companyId,
+            agentId: input.agentId,
+            status: leaseReleaseStatusForRunStatus(input.status),
+            failureReason: input.failureReason ?? undefined,
+        }).catch((err) => {
+            logger.warn({ err, runId: input.runId }, "failed to release environment leases for heartbeat run");
+            return null;
+        });
+        for (const releaseError of releaseResult?.errors ?? []) {
+            logger.warn({ err: releaseError.error, leaseId: releaseError.leaseId, runId: input.runId }, "failed to release environment lease for heartbeat run");
+        }
+    }
     async function hasUnsafeTextProjectionDatabase() {
         if (!unsafeTextProjectionPromise) {
             unsafeTextProjectionPromise = db
@@ -1613,6 +1760,522 @@ export function heartbeatService(db, options = {}) {
             .limit(1)
             .then((rows) => rows[0] ?? null);
     }
+    const issueMonitorDispatchColumns = {
+        id: issues.id,
+        companyId: issues.companyId,
+        projectId: issues.projectId,
+        goalId: issues.goalId,
+        identifier: issues.identifier,
+        title: issues.title,
+        status: issues.status,
+        priority: issues.priority,
+        assigneeAgentId: issues.assigneeAgentId,
+        assigneeUserId: issues.assigneeUserId,
+        billingCode: issues.billingCode,
+        executionPolicy: issues.executionPolicy,
+        executionState: issues.executionState,
+        monitorNextCheckAt: issues.monitorNextCheckAt,
+        monitorWakeRequestedAt: issues.monitorWakeRequestedAt,
+        monitorLastTriggeredAt: issues.monitorLastTriggeredAt,
+        monitorAttemptCount: issues.monitorAttemptCount,
+        monitorNotes: issues.monitorNotes,
+        monitorScheduledBy: issues.monitorScheduledBy,
+    };
+    function parseMonitorDate(value) {
+        if (!value)
+            return null;
+        const date = new Date(value);
+        return Number.isNaN(date.getTime()) ? null : date;
+    }
+    function issueMonitorLimitClearReason(input) {
+        const timeoutAt = parseMonitorDate(input.monitor?.timeoutAt ?? null);
+        if (timeoutAt && input.now.getTime() >= timeoutAt.getTime()) {
+            return "timeout_exceeded";
+        }
+        const maxAttempts = input.monitor?.maxAttempts ?? null;
+        if (maxAttempts !== null && input.nextAttemptCount > maxAttempts) {
+            return "max_attempts_exhausted";
+        }
+        return null;
+    }
+    function monitorRecoveryPolicy(monitor) {
+        return monitor?.recoveryPolicy ?? "wake_owner";
+    }
+    function monitorRecoveryDetails(input) {
+        return {
+            identifier: input.claimed.identifier,
+            nextCheckAt: input.scheduledAtIso,
+            attemptedAttemptCount: input.nextAttemptCount,
+            notes: input.claimed.monitorNotes ?? null,
+            serviceName: input.monitor?.serviceName ?? null,
+            timeoutAt: input.monitor?.timeoutAt ?? null,
+            maxAttempts: input.monitor?.maxAttempts ?? null,
+            clearReason: input.clearReason,
+            recoveryPolicy: input.recoveryPolicy,
+            source: input.source,
+        };
+    }
+    function formatIssueIdentifierLink(identifier, fallback) {
+        if (!identifier)
+            return fallback;
+        const prefix = identifier.split("-")[0];
+        if (!prefix || !/^[A-Z][A-Z0-9]*-\d+$/.test(identifier))
+            return identifier;
+        return `[${identifier}](/${prefix}/issues/${identifier})`;
+    }
+    function monitorRecoveryComment(input) {
+        const label = formatIssueIdentifierLink(input.issue.identifier, input.issue.id);
+        const reason = input.clearReason === "timeout_exceeded"
+            ? "its timeout was reached"
+            : "its maximum attempt count was reached";
+        return [
+            `Paperclip cleared the scheduled external-service monitor for ${label} because ${reason}.`,
+            "",
+            `- Attempt count: ${input.nextAttemptCount}`,
+            `- Recovery policy: ${input.recoveryPolicy}`,
+            "",
+            "Next action: inspect the external service state, record the result on this issue, and restore an explicit execution or waiting path if more work remains.",
+        ].join("\n");
+    }
+    async function findOpenIssueMonitorRecoveryIssue(claimed) {
+        return db
+            .select()
+            .from(issues)
+            .where(and(eq(issues.companyId, claimed.companyId), eq(issues.originKind, RECOVERY_ORIGIN_KINDS.strandedIssueRecovery), eq(issues.originId, claimed.id), isNull(issues.hiddenAt), notInArray(issues.status, ["done", "cancelled"])))
+            .orderBy(desc(issues.createdAt))
+            .limit(1)
+            .then((rows) => rows[0] ?? null);
+    }
+    async function performIssueMonitorRecovery(input) {
+        const details = monitorRecoveryDetails({
+            claimed: input.claimed,
+            scheduledAtIso: input.scheduledAtIso,
+            nextAttemptCount: input.nextAttemptCount,
+            clearReason: input.clearReason,
+            recoveryPolicy: input.recoveryPolicy,
+            monitor: input.monitor,
+            source: input.activitySource,
+        });
+        if (input.recoveryPolicy === "create_recovery_issue") {
+            let recoveryIssue = await findOpenIssueMonitorRecoveryIssue(input.claimed);
+            if (!recoveryIssue) {
+                recoveryIssue = await issuesSvc.create(input.claimed.companyId, {
+                    title: `Recover external-service monitor for ${input.claimed.identifier ?? input.claimed.title}`,
+                    description: monitorRecoveryComment({
+                        issue: input.claimed,
+                        clearReason: input.clearReason,
+                        recoveryPolicy: input.recoveryPolicy,
+                        nextAttemptCount: input.nextAttemptCount,
+                    }),
+                    status: "todo",
+                    priority: "high",
+                    parentId: input.claimed.id,
+                    projectId: input.claimed.projectId,
+                    goalId: input.claimed.goalId,
+                    assigneeAgentId: input.claimed.assigneeAgentId,
+                    originKind: RECOVERY_ORIGIN_KINDS.strandedIssueRecovery,
+                    originId: input.claimed.id,
+                    originFingerprint: `issue_monitor:${input.clearReason}`,
+                    billingCode: input.claimed.billingCode,
+                });
+            }
+            if (recoveryIssue.assigneeAgentId) {
+                await enqueueWakeup(recoveryIssue.assigneeAgentId, {
+                    source: "automation",
+                    triggerDetail: "system",
+                    reason: "issue_monitor_recovery_issue",
+                    idempotencyKey: `issue-monitor-recovery-issue:${input.claimed.id}:${input.clearReason}:${input.scheduledAtIso}`,
+                    payload: { issueId: recoveryIssue.id, sourceIssueId: input.claimed.id },
+                    requestedByActorType: input.actorType,
+                    requestedByActorId: input.actorId,
+                    contextSnapshot: {
+                        issueId: recoveryIssue.id,
+                        sourceIssueId: input.claimed.id,
+                        source: "issue.monitor.recovery_issue",
+                        wakeReason: "issue_monitor_recovery_issue",
+                    },
+                });
+            }
+            await logActivity(db, {
+                companyId: input.claimed.companyId,
+                actorType: input.actorType,
+                actorId: input.actorId,
+                agentId: input.agentId,
+                runId: input.runId,
+                action: "issue.monitor_recovery_issue_created",
+                entityType: "issue",
+                entityId: input.claimed.id,
+                details: {
+                    ...details,
+                    recoveryIssueId: recoveryIssue.id,
+                    recoveryIdentifier: recoveryIssue.identifier,
+                },
+            });
+            return;
+        }
+        if (input.recoveryPolicy === "escalate_to_board") {
+            await db.insert(issueComments).values({
+                companyId: input.claimed.companyId,
+                issueId: input.claimed.id,
+                body: monitorRecoveryComment({
+                    issue: input.claimed,
+                    clearReason: input.clearReason,
+                    recoveryPolicy: input.recoveryPolicy,
+                    nextAttemptCount: input.nextAttemptCount,
+                }),
+            });
+            await logActivity(db, {
+                companyId: input.claimed.companyId,
+                actorType: input.actorType,
+                actorId: input.actorId,
+                agentId: input.agentId,
+                runId: input.runId,
+                action: "issue.monitor_escalated_to_board",
+                entityType: "issue",
+                entityId: input.claimed.id,
+                details,
+            });
+            return;
+        }
+        await enqueueWakeup(input.claimed.assigneeAgentId, {
+            source: "automation",
+            triggerDetail: "system",
+            reason: "issue_monitor_recovery",
+            idempotencyKey: `issue-monitor-recovery:${input.claimed.id}:${input.clearReason}:${input.scheduledAtIso}`,
+            payload: {
+                issueId: input.claimed.id,
+                monitorAttemptCount: input.nextAttemptCount,
+                monitorNotes: input.claimed.monitorNotes ?? null,
+                clearReason: input.clearReason,
+                serviceName: input.monitor?.serviceName ?? null,
+                timeoutAt: input.monitor?.timeoutAt ?? null,
+                maxAttempts: input.monitor?.maxAttempts ?? null,
+            },
+            requestedByActorType: input.actorType,
+            requestedByActorId: input.actorId,
+            contextSnapshot: {
+                issueId: input.claimed.id,
+                source: "issue.monitor.recovery",
+                wakeReason: "issue_monitor_recovery",
+                monitorAttemptCount: input.nextAttemptCount,
+                monitorNotes: input.claimed.monitorNotes ?? null,
+                clearReason: input.clearReason,
+                serviceName: input.monitor?.serviceName ?? null,
+                timeoutAt: input.monitor?.timeoutAt ?? null,
+                maxAttempts: input.monitor?.maxAttempts ?? null,
+            },
+        });
+        await logActivity(db, {
+            companyId: input.claimed.companyId,
+            actorType: input.actorType,
+            actorId: input.actorId,
+            agentId: input.agentId,
+            runId: input.runId,
+            action: "issue.monitor_recovery_wake_queued",
+            entityType: "issue",
+            entityId: input.claimed.id,
+            details,
+        });
+    }
+    async function clearIssueMonitorAndRecover(input) {
+        await db
+            .update(issues)
+            .set({
+            ...buildIssueMonitorClearedPatch({
+                issue: input.claimed,
+                policy: input.policy,
+                clearReason: input.clearReason,
+                clearedAt: input.now,
+            }),
+            updatedAt: input.now,
+        })
+            .where(eq(issues.id, input.claimed.id));
+        await logActivity(db, {
+            companyId: input.claimed.companyId,
+            actorType: input.actorType,
+            actorId: input.actorId,
+            agentId: input.agentId,
+            runId: input.runId,
+            action: "issue.monitor_exhausted",
+            entityType: "issue",
+            entityId: input.claimed.id,
+            details: monitorRecoveryDetails({
+                claimed: input.claimed,
+                scheduledAtIso: input.scheduledAtIso,
+                nextAttemptCount: input.nextAttemptCount,
+                clearReason: input.clearReason,
+                recoveryPolicy: input.recoveryPolicy,
+                monitor: input.monitor,
+                source: input.activitySource,
+            }),
+        });
+        await performIssueMonitorRecovery({
+            claimed: input.claimed,
+            scheduledAtIso: input.scheduledAtIso,
+            nextAttemptCount: input.nextAttemptCount,
+            clearReason: input.clearReason,
+            recoveryPolicy: input.recoveryPolicy,
+            monitor: input.monitor,
+            actorType: input.actorType,
+            actorId: input.actorId,
+            agentId: input.agentId,
+            runId: input.runId,
+            activitySource: input.activitySource,
+        });
+        return { outcome: "skipped", reason: input.clearReason };
+    }
+    async function dispatchClaimedIssueMonitor(claimed, input) {
+        if (!claimed.assigneeAgentId || !claimed.monitorNextCheckAt) {
+            throw conflict("Issue monitor is not ready to dispatch");
+        }
+        const scheduledAtIso = claimed.monitorNextCheckAt.toISOString();
+        const nextAttemptCount = (claimed.monitorAttemptCount ?? 0) + 1;
+        const policy = normalizeIssueExecutionPolicy(claimed.executionPolicy ?? null);
+        const monitor = policy?.monitor ?? null;
+        const clearReason = issueMonitorLimitClearReason({ monitor, nextAttemptCount, now: input.now });
+        const recoveryPolicy = monitorRecoveryPolicy(monitor);
+        const monitorMetadata = {
+            serviceName: monitor?.serviceName ?? null,
+            timeoutAt: monitor?.timeoutAt ?? null,
+            maxAttempts: monitor?.maxAttempts ?? null,
+            recoveryPolicy: monitor?.recoveryPolicy ?? null,
+        };
+        if (clearReason) {
+            return clearIssueMonitorAndRecover({
+                claimed,
+                policy,
+                scheduledAtIso,
+                nextAttemptCount,
+                clearReason,
+                recoveryPolicy,
+                monitor,
+                now: input.now,
+                actorType: input.actorType,
+                actorId: input.actorId,
+                agentId: input.agentId,
+                runId: input.runId,
+                activitySource: input.activitySource,
+            });
+        }
+        try {
+            await enqueueWakeup(claimed.assigneeAgentId, {
+                source: input.source,
+                triggerDetail: input.triggerDetail,
+                reason: input.wakeReason,
+                idempotencyKey: `issue-monitor:${claimed.id}:${scheduledAtIso}`,
+                payload: {
+                    issueId: claimed.id,
+                    nextCheckAt: scheduledAtIso,
+                    monitorAttemptCount: nextAttemptCount,
+                    monitorNotes: claimed.monitorNotes ?? null,
+                    ...monitorMetadata,
+                    source: input.activitySource,
+                },
+                requestedByActorType: input.actorType,
+                requestedByActorId: input.actorId,
+                contextSnapshot: {
+                    issueId: claimed.id,
+                    source: "issue.monitor",
+                    wakeReason: input.wakeReason,
+                    nextCheckAt: scheduledAtIso,
+                    monitorAttemptCount: nextAttemptCount,
+                    monitorNotes: claimed.monitorNotes ?? null,
+                    ...monitorMetadata,
+                    manualTrigger: input.activitySource === "manual",
+                },
+            });
+            await db
+                .update(issues)
+                .set({
+                ...buildIssueMonitorTriggeredPatch({
+                    issue: claimed,
+                    policy,
+                    triggeredAt: input.now,
+                }),
+                updatedAt: new Date(),
+            })
+                .where(eq(issues.id, claimed.id));
+            await logActivity(db, {
+                companyId: claimed.companyId,
+                actorType: input.actorType,
+                actorId: input.actorId,
+                agentId: input.agentId,
+                runId: input.runId,
+                action: "issue.monitor_triggered",
+                entityType: "issue",
+                entityId: claimed.id,
+                details: {
+                    identifier: claimed.identifier,
+                    nextCheckAt: scheduledAtIso,
+                    lastTriggeredAt: input.now.toISOString(),
+                    attemptCount: nextAttemptCount,
+                    notes: claimed.monitorNotes ?? null,
+                    ...monitorMetadata,
+                    source: input.activitySource,
+                },
+            });
+            return { outcome: "triggered" };
+        }
+        catch (err) {
+            if (err instanceof HttpError && err.status >= 400 && err.status < 500) {
+                if (input.clearOnClientError) {
+                    await db
+                        .update(issues)
+                        .set({
+                        ...buildIssueMonitorClearedPatch({
+                            issue: claimed,
+                            policy,
+                            clearReason: "dispatch_skipped",
+                            clearedAt: input.now,
+                        }),
+                        updatedAt: new Date(),
+                    })
+                        .where(eq(issues.id, claimed.id));
+                    await logActivity(db, {
+                        companyId: claimed.companyId,
+                        actorType: input.actorType,
+                        actorId: input.actorId,
+                        agentId: input.agentId,
+                        runId: input.runId,
+                        action: "issue.monitor_skipped",
+                        entityType: "issue",
+                        entityId: claimed.id,
+                        details: {
+                            identifier: claimed.identifier,
+                            nextCheckAt: scheduledAtIso,
+                            attemptCount: nextAttemptCount,
+                            notes: claimed.monitorNotes ?? null,
+                            reason: err.message,
+                            source: input.activitySource,
+                        },
+                    });
+                    return { outcome: "skipped", reason: err.message };
+                }
+                await db
+                    .update(issues)
+                    .set({
+                    monitorWakeRequestedAt: null,
+                    updatedAt: new Date(),
+                })
+                    .where(eq(issues.id, claimed.id));
+            }
+            else {
+                await db
+                    .update(issues)
+                    .set({
+                    monitorWakeRequestedAt: null,
+                    updatedAt: new Date(),
+                })
+                    .where(eq(issues.id, claimed.id));
+            }
+            throw err;
+        }
+    }
+    async function triggerIssueMonitor(issueId, input) {
+        const now = input?.now ?? new Date();
+        const actorType = input?.actorType ?? "system";
+        const actorId = input?.actorId ?? (actorType === "system" ? "heartbeat_scheduler" : null);
+        if (!actorId) {
+            throw conflict("Issue monitor trigger requires an actor");
+        }
+        const issue = await db
+            .select(issueMonitorDispatchColumns)
+            .from(issues)
+            .where(eq(issues.id, issueId))
+            .limit(1)
+            .then((rows) => rows[0] ?? null);
+        if (!issue) {
+            throw notFound("Issue not found");
+        }
+        if (!issue.monitorNextCheckAt) {
+            throw conflict("Issue has no scheduled monitor");
+        }
+        if (!issue.assigneeAgentId || issue.assigneeUserId) {
+            throw conflict("Issue monitor requires an agent assignee");
+        }
+        if (!["in_progress", "in_review"].includes(issue.status)) {
+            throw conflict("Issue monitor can only run while the issue is in progress or in review");
+        }
+        const staleClaimThreshold = new Date(now.getTime() - 5 * 60 * 1000);
+        const claimed = await db.transaction(async (tx) => {
+            const [updated] = await tx
+                .update(issues)
+                .set({
+                monitorWakeRequestedAt: now,
+                updatedAt: now,
+            })
+                .where(and(eq(issues.id, issueId), sql `${issues.monitorNextCheckAt} is not null`, isNull(issues.assigneeUserId), sql `${issues.assigneeAgentId} is not null`, inArray(issues.status, ["in_progress", "in_review"]), or(isNull(issues.monitorWakeRequestedAt), lt(issues.monitorWakeRequestedAt, staleClaimThreshold))))
+                .returning();
+            return (updated ?? null);
+        });
+        if (!claimed) {
+            throw conflict("Issue monitor check is already in progress");
+        }
+        return dispatchClaimedIssueMonitor(claimed, {
+            now,
+            source: "on_demand",
+            triggerDetail: "manual",
+            wakeReason: input?.wakeReason ?? "issue_monitor_due",
+            actorType,
+            actorId,
+            agentId: input?.agentId ?? null,
+            runId: input?.runId ?? null,
+            clearOnClientError: false,
+            activitySource: "manual",
+        });
+    }
+    async function tickDueIssueMonitors(now = new Date()) {
+        const staleClaimThreshold = new Date(now.getTime() - 5 * 60 * 1000);
+        const dueMonitors = await db
+            .select(issueMonitorDispatchColumns)
+            .from(issues)
+            .where(and(sql `${issues.monitorNextCheckAt} is not null`, lte(issues.monitorNextCheckAt, now), isNull(issues.assigneeUserId), sql `${issues.assigneeAgentId} is not null`, inArray(issues.status, ["in_progress", "in_review"]), or(isNull(issues.monitorWakeRequestedAt), lt(issues.monitorWakeRequestedAt, staleClaimThreshold))))
+            .orderBy(asc(issues.monitorNextCheckAt), asc(issues.updatedAt))
+            .limit(50);
+        let triggered = 0;
+        let skipped = 0;
+        for (const due of dueMonitors) {
+            const claimed = await db.transaction(async (tx) => {
+                const [updated] = await tx
+                    .update(issues)
+                    .set({
+                    monitorWakeRequestedAt: now,
+                    updatedAt: now,
+                })
+                    .where(and(eq(issues.id, due.id), sql `${issues.monitorNextCheckAt} is not null`, lte(issues.monitorNextCheckAt, now), isNull(issues.assigneeUserId), sql `${issues.assigneeAgentId} is not null`, inArray(issues.status, ["in_progress", "in_review"]), or(isNull(issues.monitorWakeRequestedAt), lt(issues.monitorWakeRequestedAt, staleClaimThreshold))))
+                    .returning();
+                return (updated ?? null);
+            });
+            if (!claimed)
+                continue;
+            try {
+                const result = await dispatchClaimedIssueMonitor(claimed, {
+                    now,
+                    source: "automation",
+                    triggerDetail: "system",
+                    wakeReason: "issue_monitor_due",
+                    actorType: "system",
+                    actorId: "heartbeat_scheduler",
+                    agentId: null,
+                    runId: null,
+                    clearOnClientError: true,
+                    activitySource: "scheduled",
+                });
+                if (result.outcome === "triggered")
+                    triggered += 1;
+                if (result.outcome === "skipped")
+                    skipped += 1;
+            }
+            catch (err) {
+                logger.error({ err, issueId: claimed.id }, "issue monitor tick failed");
+            }
+        }
+        return {
+            checked: dueMonitors.length,
+            triggered,
+            skipped,
+        };
+    }
     async function getOldestRunForSession(agentId, sessionId) {
         return db
             .select({
@@ -2022,16 +2685,26 @@ export function heartbeatService(db, options = {}) {
         const existing = await getRuntimeState(agent.id);
         if (existing)
             return existing;
-        return db
+        const inserted = await db
             .insert(agentRuntimeState)
             .values({
             agentId: agent.id,
             companyId: agent.companyId,
             adapterType: agent.adapterType,
             stateJson: {},
+        })
+            .onConflictDoNothing({
+            target: agentRuntimeState.agentId,
         })
             .returning()
-            .then((rows) => rows[0]);
+            .then((rows) => rows[0] ?? null);
+        if (inserted)
+            return inserted;
+        const ensured = await getRuntimeState(agent.id);
+        if (!ensured) {
+            throw new Error(`Failed to ensure runtime state for agent ${agent.id}`);
+        }
+        return ensured;
     }
     async function setRunStatus(runId, status, patch) {
         const updated = await db
@@ -2158,6 +2831,28 @@ export function heartbeatService(db, options = {}) {
                 projectId: issue.projectId,
             })
             : null;
+        if (issue) {
+            const productivityHold = await productivityReviews.isProductivityReviewContinuationHoldActive({
+                companyId: issue.companyId,
+                issueId: issue.id,
+                agentId: run.agentId,
+            });
+            if (productivityHold.held) {
+                await setRunStatus(run.id, run.status, {
+                    livenessReason: `${run.livenessReason ?? "Run ended without concrete progress"}; continuation held by productivity review ${productivityHold.reviewIdentifier ?? productivityHold.reviewIssueId}`,
+                });
+                await productivityReviews.recordContinuationHold({
+                    companyId: issue.companyId,
+                    issueId: issue.id,
+                    runId: run.id,
+                    agentId: run.agentId,
+                    reviewIssueId: productivityHold.reviewIssueId,
+                    trigger: productivityHold.trigger,
+                    reason: productivityHold.reason,
+                });
+                return;
+            }
+        }
         const nextAttempt = readContinuationAttempt(run.continuationAttempt) + 1;
         const idempotencyKey = issue
             ? buildRunLivenessContinuationIdempotencyKey({
@@ -2224,9 +2919,10 @@ export function heartbeatService(db, options = {}) {
         const boundedPayload = event.payload
             ? boundHeartbeatRunEventPayloadForStorage(event.payload)
             : event.payload;
-        const sanitizedPayload = boundedPayload
-            ? redactCurrentUserValue(boundedPayload, currentUserRedactionOptions)
-            : boundedPayload;
+        const secretSanitizedPayload = boundedPayload ? redactEventPayload(boundedPayload) : boundedPayload;
+        const sanitizedPayload = secretSanitizedPayload
+            ? redactCurrentUserValue(secretSanitizedPayload, currentUserRedactionOptions)
+            : secretSanitizedPayload;
         await db.insert(heartbeatRunEvents).values({
             companyId: run.companyId,
             runId: run.id,
@@ -2621,19 +3317,235 @@ export function heartbeatService(db, options = {}) {
             eventType: "lifecycle",
             stream: "system",
             level: "warn",
-            message: "Queued automatic retry after orphaned child process was confirmed dead",
+            message: "Queued automatic retry after orphaned child process was confirmed dead",
+            payload: {
+                retryOfRunId: run.id,
+            },
+        });
+        return queued;
+    }
+    async function evaluateScheduledRetryGate(input) {
+        const { run, agent, contextSnapshot } = input;
+        const retryReason = input.retryReason ?? readNonEmptyString(contextSnapshot.retryReason) ?? run.scheduledRetryReason ?? null;
+        const issueId = readNonEmptyString(contextSnapshot.issueId);
+        const projectId = readNonEmptyString(contextSnapshot.projectId);
+        const budgetBlock = await budgets.getInvocationBlock(run.companyId, run.agentId, {
+            issueId,
+            projectId,
+        });
+        if (budgetBlock) {
+            return {
+                allowed: false,
+                reason: budgetBlock.reason,
+                errorCode: "budget_blocked",
+                issueId,
+                details: {
+                    scopeType: budgetBlock.scopeType,
+                    scopeId: budgetBlock.scopeId,
+                },
+            };
+        }
+        if (agent.status === "paused" || agent.status === "terminated" || agent.status === "pending_approval") {
+            return {
+                allowed: false,
+                reason: "Scheduled retry suppressed because the agent is not invokable",
+                errorCode: "agent_not_invokable",
+                issueId,
+                details: {
+                    agentId: agent.id,
+                    agentStatus: agent.status,
+                },
+            };
+        }
+        if (!issueId)
+            return { allowed: true };
+        const issue = await db
+            .select({
+            id: issues.id,
+            status: issues.status,
+            assigneeAgentId: issues.assigneeAgentId,
+            executionRunId: issues.executionRunId,
+            executionState: issues.executionState,
+        })
+            .from(issues)
+            .where(and(eq(issues.id, issueId), eq(issues.companyId, run.companyId)))
+            .then((rows) => rows[0] ?? null);
+        if (!issue) {
+            return {
+                allowed: false,
+                reason: "Scheduled retry suppressed because the target issue no longer exists",
+                errorCode: "issue_not_found",
+                issueId,
+                details: { issueId },
+            };
+        }
+        if (issue.assigneeAgentId !== run.agentId) {
+            return {
+                allowed: false,
+                reason: "Scheduled retry suppressed because issue ownership changed",
+                errorCode: "issue_reassigned",
+                issueId,
+                details: {
+                    issueId,
+                    previousAssigneeAgentId: run.agentId,
+                    currentAssigneeAgentId: issue.assigneeAgentId,
+                },
+            };
+        }
+        if (issue.status === "cancelled" || issue.status === "done") {
+            return {
+                allowed: false,
+                reason: `Scheduled retry suppressed because issue reached terminal status (${issue.status})`,
+                errorCode: issue.status === "cancelled" ? "issue_cancelled" : "issue_terminal_status",
+                issueId,
+                details: { issueId, currentStatus: issue.status },
+            };
+        }
+        if (retryReason === MAX_TURN_CONTINUATION_RETRY_REASON && issue.status !== "in_progress") {
+            return {
+                allowed: false,
+                reason: `Scheduled max-turn continuation suppressed because issue is no longer in_progress (current status: ${issue.status})`,
+                errorCode: "issue_not_in_progress",
+                issueId,
+                details: { issueId, currentStatus: issue.status, requiredStatus: "in_progress" },
+            };
+        }
+        if (retryReason === MAX_TURN_CONTINUATION_RETRY_REASON &&
+            input.enforceIssueExecutionLock &&
+            issue.executionRunId !== run.id) {
+            return {
+                allowed: false,
+                reason: "Scheduled max-turn continuation suppressed because the issue execution lock belongs to a different run",
+                errorCode: "issue_execution_lock_changed",
+                issueId,
+                details: {
+                    issueId,
+                    expectedExecutionRunId: run.id,
+                    currentExecutionRunId: issue.executionRunId,
+                },
+            };
+        }
+        if (issue.status === "in_review") {
+            const executionState = parseIssueExecutionState(issue.executionState);
+            const currentParticipant = executionState?.currentParticipant ?? null;
+            if (currentParticipant) {
+                const participantMatches = currentParticipant.type === "agent" && currentParticipant.agentId === run.agentId;
+                if (!participantMatches) {
+                    return {
+                        allowed: false,
+                        reason: "Scheduled retry suppressed because the issue is waiting on another review participant",
+                        errorCode: "issue_review_participant_changed",
+                        issueId,
+                        details: {
+                            issueId,
+                            currentStageType: executionState?.currentStageType ?? null,
+                            currentParticipant,
+                        },
+                    };
+                }
+            }
+        }
+        const activePauseHold = await treeControlSvc.getActivePauseHoldGate(run.companyId, issueId);
+        if (activePauseHold) {
+            return {
+                allowed: false,
+                reason: "Scheduled retry suppressed because the issue is held by an active subtree pause hold",
+                errorCode: "issue_paused",
+                issueId,
+                details: {
+                    issueId,
+                    holdId: activePauseHold.holdId,
+                    rootIssueId: activePauseHold.rootIssueId,
+                },
+            };
+        }
+        const dependencyReadiness = await issuesSvc.listDependencyReadiness(run.companyId, [issueId]);
+        const readiness = dependencyReadiness.get(issueId);
+        if (readiness && !readiness.isDependencyReady) {
+            return {
+                allowed: false,
+                reason: "Scheduled retry suppressed because issue dependencies are still blocked",
+                errorCode: "issue_dependencies_blocked",
+                issueId,
+                details: {
+                    issueId,
+                    unresolvedBlockerIssueIds: readiness.unresolvedBlockerIssueIds,
+                    unresolvedBlockerCount: readiness.unresolvedBlockerCount,
+                },
+            };
+        }
+        return { allowed: true };
+    }
+    async function cancelScheduledRetryForGate(run, gate, now) {
+        const cancelled = await db
+            .update(heartbeatRuns)
+            .set({
+            status: "cancelled",
+            finishedAt: now,
+            error: gate.reason,
+            errorCode: gate.errorCode,
+            updatedAt: now,
+        })
+            .where(and(eq(heartbeatRuns.id, run.id), eq(heartbeatRuns.status, "scheduled_retry"), lte(heartbeatRuns.scheduledRetryAt, now)))
+            .returning()
+            .then((rows) => rows[0] ?? null);
+        if (!cancelled)
+            return null;
+        if (cancelled.wakeupRequestId) {
+            await db
+                .update(agentWakeupRequests)
+                .set({
+                status: "cancelled",
+                finishedAt: now,
+                error: gate.reason,
+                updatedAt: now,
+            })
+                .where(eq(agentWakeupRequests.id, cancelled.wakeupRequestId));
+        }
+        if (gate.issueId) {
+            await db
+                .update(issues)
+                .set({
+                executionRunId: null,
+                executionAgentNameKey: null,
+                executionLockedAt: null,
+                updatedAt: now,
+            })
+                .where(and(eq(issues.companyId, cancelled.companyId), eq(issues.id, gate.issueId), eq(issues.executionRunId, cancelled.id)));
+        }
+        await appendRunEvent(cancelled, await nextRunEventSeq(cancelled.id), {
+            eventType: "lifecycle",
+            stream: "system",
+            level: "warn",
+            message: gate.reason,
             payload: {
-                retryOfRunId: run.id,
+                ...gate.details,
+                scheduledRetryAttempt: cancelled.scheduledRetryAttempt,
+                scheduledRetryAt: cancelled.scheduledRetryAt ? new Date(cancelled.scheduledRetryAt).toISOString() : null,
+                scheduledRetryReason: cancelled.scheduledRetryReason,
             },
         });
-        return queued;
+        return cancelled;
     }
     async function scheduleBoundedRetryForRun(run, agent, opts) {
         const now = opts?.now ?? new Date();
         const retryReason = opts?.retryReason ?? BOUNDED_TRANSIENT_HEARTBEAT_RETRY_REASON;
         const wakeReason = opts?.wakeReason ?? BOUNDED_TRANSIENT_HEARTBEAT_RETRY_WAKE_REASON;
+        const maxAttempts = Math.max(0, Math.floor(opts?.maxAttempts ?? BOUNDED_TRANSIENT_HEARTBEAT_RETRY_MAX_ATTEMPTS));
         const nextAttempt = (run.scheduledRetryAttempt ?? 0) + 1;
-        const baseSchedule = computeBoundedTransientHeartbeatRetrySchedule(nextAttempt, now, opts?.random);
+        const baseSchedule = opts?.delayMs != null
+            ? nextAttempt <= maxAttempts
+                ? {
+                    attempt: nextAttempt,
+                    baseDelayMs: Math.max(0, Math.floor(opts.delayMs)),
+                    delayMs: Math.max(0, Math.floor(opts.delayMs)),
+                    dueAt: new Date(now.getTime() + Math.max(0, Math.floor(opts.delayMs))),
+                    maxAttempts,
+                }
+                : null
+            : nextAttempt <= maxAttempts
+                ? computeBoundedTransientHeartbeatRetrySchedule(nextAttempt, now, opts?.random)
+                : null;
         const transientRecovery = retryReason === BOUNDED_TRANSIENT_HEARTBEAT_RETRY_REASON
             ? readTransientRecoveryContractFromRun(run)
             : null;
@@ -2650,13 +3562,13 @@ export function heartbeatService(db, options = {}) {
                 payload: {
                     retryReason,
                     scheduledRetryAttempt: run.scheduledRetryAttempt ?? 0,
-                    maxAttempts: BOUNDED_TRANSIENT_HEARTBEAT_RETRY_MAX_ATTEMPTS,
+                    maxAttempts,
                 },
             });
             return {
                 outcome: "retry_exhausted",
                 attempt: nextAttempt,
-                maxAttempts: BOUNDED_TRANSIENT_HEARTBEAT_RETRY_MAX_ATTEMPTS,
+                maxAttempts,
             };
         }
         const schedule = transientRetryNotBefore && transientRetryNotBefore.getTime() > baseSchedule.dueAt.getTime()
@@ -2668,6 +3580,29 @@ export function heartbeatService(db, options = {}) {
             : baseSchedule;
         const contextSnapshot = parseObject(run.contextSnapshot);
         const issueId = readNonEmptyString(contextSnapshot.issueId);
+        if (retryReason === MAX_TURN_CONTINUATION_RETRY_REASON) {
+            const gate = await evaluateScheduledRetryGate({ run, agent, contextSnapshot, retryReason });
+            if (!gate.allowed) {
+                await appendRunEvent(run, await nextRunEventSeq(run.id), {
+                    eventType: "lifecycle",
+                    stream: "system",
+                    level: "warn",
+                    message: gate.reason,
+                    payload: {
+                        retryReason,
+                        scheduledRetryAttempt: nextAttempt,
+                        maxAttempts,
+                        ...gate.details,
+                    },
+                });
+                return {
+                    outcome: "not_scheduled",
+                    reason: gate.reason,
+                    errorCode: gate.errorCode,
+                    issueId: gate.issueId,
+                };
+            }
+        }
         const taskKey = deriveTaskKeyWithHeartbeatFallback(contextSnapshot, null);
         const sessionBefore = await resolveSessionBeforeForWakeup(agent, taskKey);
         const retryContextSnapshot = {
@@ -2681,7 +3616,113 @@ export function heartbeatService(db, options = {}) {
             ...(transientRetryNotBefore ? { transientRetryNotBefore: transientRetryNotBefore.toISOString() } : {}),
             ...(codexTransientFallbackMode ? { codexTransientFallbackMode } : {}),
         };
-        const retryRun = await db.transaction(async (tx) => {
+        const maxTurnContinuationIdempotencyKey = retryReason === MAX_TURN_CONTINUATION_RETRY_REASON
+            ? `max-turn-continuation:${run.companyId}:${issueId ?? "no-issue"}:${run.id}:${schedule.attempt}`
+            : null;
+        const scheduleResult = await db.transaction(async (tx) => {
+            if (retryReason === MAX_TURN_CONTINUATION_RETRY_REASON) {
+                if (issueId) {
+                    await tx.execute(sql `select id from issues where company_id = ${run.companyId} and id = ${issueId} for update`);
+                }
+                else {
+                    await tx.execute(sql `select id from heartbeat_runs where company_id = ${run.companyId} and id = ${run.id} for update`);
+                }
+                const existingContinuation = await tx
+                    .select()
+                    .from(heartbeatRuns)
+                    .where(and(eq(heartbeatRuns.companyId, run.companyId), eq(heartbeatRuns.retryOfRunId, run.id), eq(heartbeatRuns.scheduledRetryReason, retryReason), eq(heartbeatRuns.scheduledRetryAttempt, schedule.attempt), inArray(heartbeatRuns.status, [...MAX_TURN_CONTINUATION_LIVE_RUN_STATUSES]), issueId
+                    ? sql `${heartbeatRuns.contextSnapshot} ->> 'issueId' = ${issueId}`
+                    : sql `${heartbeatRuns.contextSnapshot} ->> 'issueId' is null`))
+                    .orderBy(asc(heartbeatRuns.createdAt), asc(heartbeatRuns.id))
+                    .limit(1)
+                    .then((rows) => rows[0] ?? null);
+                if (existingContinuation) {
+                    if (existingContinuation.wakeupRequestId) {
+                        const existingWakeup = await tx
+                            .select({ coalescedCount: agentWakeupRequests.coalescedCount })
+                            .from(agentWakeupRequests)
+                            .where(eq(agentWakeupRequests.id, existingContinuation.wakeupRequestId))
+                            .then((rows) => rows[0] ?? null);
+                        await tx
+                            .update(agentWakeupRequests)
+                            .set({
+                            coalescedCount: (existingWakeup?.coalescedCount ?? 0) + 1,
+                            updatedAt: now,
+                        })
+                            .where(eq(agentWakeupRequests.id, existingContinuation.wakeupRequestId));
+                    }
+                    return {
+                        outcome: "scheduled",
+                        run: existingContinuation,
+                        reusedExisting: true,
+                    };
+                }
+                if (issueId) {
+                    const lockedIssue = await tx
+                        .select({
+                        id: issues.id,
+                        status: issues.status,
+                        assigneeAgentId: issues.assigneeAgentId,
+                        executionRunId: issues.executionRunId,
+                    })
+                        .from(issues)
+                        .where(and(eq(issues.id, issueId), eq(issues.companyId, run.companyId)))
+                        .then((rows) => rows[0] ?? null);
+                    if (!lockedIssue) {
+                        return {
+                            outcome: "not_scheduled",
+                            reason: "Scheduled max-turn continuation suppressed because the target issue no longer exists",
+                            errorCode: "issue_not_found",
+                            issueId,
+                            details: { issueId },
+                        };
+                    }
+                    if (lockedIssue.assigneeAgentId !== run.agentId) {
+                        return {
+                            outcome: "not_scheduled",
+                            reason: "Scheduled max-turn continuation suppressed because issue ownership changed",
+                            errorCode: "issue_reassigned",
+                            issueId,
+                            details: {
+                                issueId,
+                                previousAssigneeAgentId: run.agentId,
+                                currentAssigneeAgentId: lockedIssue.assigneeAgentId,
+                            },
+                        };
+                    }
+                    if (lockedIssue.status === "cancelled" || lockedIssue.status === "done") {
+                        return {
+                            outcome: "not_scheduled",
+                            reason: `Scheduled max-turn continuation suppressed because issue reached terminal status (${lockedIssue.status})`,
+                            errorCode: lockedIssue.status === "cancelled" ? "issue_cancelled" : "issue_terminal_status",
+                            issueId,
+                            details: { issueId, currentStatus: lockedIssue.status },
+                        };
+                    }
+                    if (lockedIssue.status !== "in_progress") {
+                        return {
+                            outcome: "not_scheduled",
+                            reason: `Scheduled max-turn continuation suppressed because issue is no longer in_progress (current status: ${lockedIssue.status})`,
+                            errorCode: "issue_not_in_progress",
+                            issueId,
+                            details: { issueId, currentStatus: lockedIssue.status, requiredStatus: "in_progress" },
+                        };
+                    }
+                    if (lockedIssue.executionRunId !== run.id) {
+                        return {
+                            outcome: "not_scheduled",
+                            reason: "Scheduled max-turn continuation suppressed because the issue execution lock belongs to a different run",
+                            errorCode: "issue_execution_lock_changed",
+                            issueId,
+                            details: {
+                                issueId,
+                                expectedExecutionRunId: run.id,
+                                currentExecutionRunId: lockedIssue.executionRunId,
+                            },
+                        };
+                    }
+                }
+            }
             const wakeupRequest = await tx
                 .insert(agentWakeupRequests)
                 .values({
@@ -2703,6 +3744,7 @@ export function heartbeatService(db, options = {}) {
                 status: "queued",
                 requestedByActorType: "system",
                 requestedByActorId: null,
+                idempotencyKey: maxTurnContinuationIdempotencyKey,
                 updatedAt: now,
             })
                 .returning()
@@ -2745,8 +3787,57 @@ export function heartbeatService(db, options = {}) {
                 })
                     .where(and(eq(issues.id, issueId), eq(issues.companyId, run.companyId), eq(issues.executionRunId, run.id)));
             }
-            return scheduledRun;
+            return {
+                outcome: "scheduled",
+                run: scheduledRun,
+                reusedExisting: false,
+            };
         });
+        if (scheduleResult.outcome === "not_scheduled") {
+            await appendRunEvent(run, await nextRunEventSeq(run.id), {
+                eventType: "lifecycle",
+                stream: "system",
+                level: "warn",
+                message: scheduleResult.reason,
+                payload: {
+                    retryReason,
+                    scheduledRetryAttempt: nextAttempt,
+                    maxAttempts,
+                    ...scheduleResult.details,
+                },
+            });
+            return {
+                outcome: "not_scheduled",
+                reason: scheduleResult.reason,
+                errorCode: scheduleResult.errorCode,
+                issueId: scheduleResult.issueId,
+            };
+        }
+        const retryRun = scheduleResult.run;
+        const dueAt = retryRun.scheduledRetryAt ? new Date(retryRun.scheduledRetryAt) : schedule.dueAt;
+        if (scheduleResult.reusedExisting) {
+            await appendRunEvent(run, await nextRunEventSeq(run.id), {
+                eventType: "lifecycle",
+                stream: "system",
+                level: "info",
+                message: `Reused existing max-turn continuation ${retryRun.scheduledRetryAttempt}/${schedule.maxAttempts}`,
+                payload: {
+                    retryRunId: retryRun.id,
+                    retryReason,
+                    idempotencyKey: maxTurnContinuationIdempotencyKey,
+                    scheduledRetryAttempt: retryRun.scheduledRetryAttempt,
+                    scheduledRetryAt: dueAt.toISOString(),
+                },
+            });
+            return {
+                outcome: "scheduled",
+                run: retryRun,
+                dueAt,
+                attempt: retryRun.scheduledRetryAttempt,
+                maxAttempts: schedule.maxAttempts,
+                reusedExisting: true,
+            };
+        }
         await appendRunEvent(run, await nextRunEventSeq(run.id), {
             eventType: "lifecycle",
             stream: "system",
@@ -2767,7 +3858,7 @@ export function heartbeatService(db, options = {}) {
         return {
             outcome: "scheduled",
             run: retryRun,
-            dueAt: schedule.dueAt,
+            dueAt,
             attempt: schedule.attempt,
             maxAttempts: schedule.maxAttempts,
         };
@@ -2781,76 +3872,33 @@ export function heartbeatService(db, options = {}) {
             .limit(50);
         const promotedRunIds = [];
         for (const dueRun of dueRuns) {
-            const dueRunIssueId = readNonEmptyString(parseObject(dueRun.contextSnapshot).issueId);
-            if (dueRunIssueId) {
-                const issue = await db
-                    .select({
-                    id: issues.id,
-                    status: issues.status,
-                    assigneeAgentId: issues.assigneeAgentId,
-                    executionRunId: issues.executionRunId,
-                })
-                    .from(issues)
-                    .where(and(eq(issues.id, dueRunIssueId), eq(issues.companyId, dueRun.companyId)))
-                    .then((rows) => rows[0] ?? null);
-                if (issue && (issue.assigneeAgentId !== dueRun.agentId || issue.status === "cancelled")) {
-                    const issueCancelled = issue.status === "cancelled";
-                    const reason = issueCancelled
-                        ? "Cancelled because the issue was cancelled before the scheduled retry became due"
-                        : "Cancelled because the issue was reassigned before the scheduled retry became due";
-                    const cancelled = await db
-                        .update(heartbeatRuns)
-                        .set({
-                        status: "cancelled",
-                        finishedAt: now,
-                        error: reason,
-                        errorCode: issueCancelled ? "issue_cancelled" : "issue_reassigned",
-                        updatedAt: now,
-                    })
-                        .where(and(eq(heartbeatRuns.id, dueRun.id), eq(heartbeatRuns.status, "scheduled_retry"), lte(heartbeatRuns.scheduledRetryAt, now)))
-                        .returning()
-                        .then((rows) => rows[0] ?? null);
-                    if (!cancelled)
-                        continue;
-                    if (cancelled.wakeupRequestId) {
-                        await db
-                            .update(agentWakeupRequests)
-                            .set({
-                            status: "cancelled",
-                            finishedAt: now,
-                            error: reason,
-                            updatedAt: now,
-                        })
-                            .where(eq(agentWakeupRequests.id, cancelled.wakeupRequestId));
-                    }
-                    if (issue.executionRunId === cancelled.id) {
-                        await db
-                            .update(issues)
-                            .set({
-                            executionRunId: null,
-                            executionAgentNameKey: null,
-                            executionLockedAt: null,
-                            updatedAt: now,
-                        })
-                            .where(and(eq(issues.id, issue.id), eq(issues.executionRunId, cancelled.id)));
-                    }
-                    await appendRunEvent(cancelled, await nextRunEventSeq(cancelled.id), {
-                        eventType: "lifecycle",
-                        stream: "system",
-                        level: "warn",
-                        message: issueCancelled
-                            ? "Scheduled retry cancelled because issue was cancelled before it became due"
-                            : "Scheduled retry cancelled because issue ownership changed before it became due",
-                        payload: {
-                            issueId: issue.id,
-                            issueStatus: issue.status,
-                            scheduledRetryAttempt: cancelled.scheduledRetryAttempt,
-                            scheduledRetryAt: cancelled.scheduledRetryAt ? new Date(cancelled.scheduledRetryAt).toISOString() : null,
-                            scheduledRetryReason: cancelled.scheduledRetryReason,
-                            previousRetryAgentId: cancelled.agentId,
-                            currentAssigneeAgentId: issue.assigneeAgentId,
-                        },
-                    });
+            const agent = await getAgent(dueRun.agentId);
+            if (!agent) {
+                await cancelScheduledRetryForGate(dueRun, {
+                    allowed: false,
+                    reason: "Scheduled retry suppressed because the agent no longer exists",
+                    errorCode: "agent_not_invokable",
+                    issueId: readNonEmptyString(parseObject(dueRun.contextSnapshot).issueId),
+                    details: { agentId: dueRun.agentId },
+                }, now);
+                continue;
+            }
+            const contextSnapshot = parseObject(dueRun.contextSnapshot);
+            const gate = await evaluateScheduledRetryGate({
+                run: dueRun,
+                agent,
+                contextSnapshot,
+                retryReason: dueRun.scheduledRetryReason,
+                enforceIssueExecutionLock: dueRun.scheduledRetryReason === MAX_TURN_CONTINUATION_RETRY_REASON,
+            });
+            if (!gate.allowed) {
+                if (gate.errorCode === "issue_not_found" &&
+                    dueRun.scheduledRetryReason !== MAX_TURN_CONTINUATION_RETRY_REASON) {
+                    // Preserve legacy transient retry behavior for runs that only carry a
+                    // loose task context rather than a persisted issue row.
+                }
+                else {
+                    await cancelScheduledRetryForGate(dueRun, gate, now);
                     continue;
                 }
             }
@@ -2904,6 +3952,18 @@ export function heartbeatService(db, options = {}) {
             maxConcurrentRuns: normalizeMaxConcurrentRuns(heartbeat.maxConcurrentRuns),
         };
     }
+    function parseMaxTurnContinuationPolicy(agent) {
+        const runtimeConfig = parseObject(agent.runtimeConfig);
+        const heartbeat = parseObject(runtimeConfig.heartbeat);
+        const configured = parseObject(heartbeat.maxTurnContinuation);
+        const rawMaxAttempts = Math.floor(asNumber(configured.maxAttempts, MAX_TURN_CONTINUATION_DEFAULT_MAX_ATTEMPTS));
+        const rawDelayMs = Math.floor(asNumber(configured.delayMs, MAX_TURN_CONTINUATION_DEFAULT_DELAY_MS));
+        return {
+            enabled: asBoolean(configured.enabled, true),
+            maxAttempts: Math.max(0, Math.min(MAX_TURN_CONTINUATION_MAX_ATTEMPTS_CAP, rawMaxAttempts)),
+            delayMs: Math.max(0, Math.min(MAX_TURN_CONTINUATION_MAX_DELAY_MS, rawDelayMs)),
+        };
+    }
     function issueRunPriorityRank(priority) {
         switch (priority) {
             case "critical":
@@ -2995,6 +4055,12 @@ export function heartbeatService(db, options = {}) {
                 logger.info({ runId: run.id, issueId, unresolvedBlockerCount }, "claimQueuedRun: cancelled blocked queued run");
                 return null;
             }
+            const staleness = await evaluateQueuedRunStaleness(run, issueId, context);
+            if (staleness.stale) {
+                await cancelQueuedRunForStaleIssue(run, issueId, staleness);
+                logger.info({ runId: run.id, issueId, errorCode: staleness.errorCode }, "claimQueuedRun: cancelled stale queued run");
+                return null;
+            }
         }
         const claimedAt = new Date();
         const claimed = await db
@@ -3089,6 +4155,132 @@ export function heartbeatService(db, options = {}) {
         });
         return cancelled;
     }
+    async function evaluateQueuedRunStaleness(run, issueId, context) {
+        const issue = await db
+            .select({
+            id: issues.id,
+            status: issues.status,
+            assigneeAgentId: issues.assigneeAgentId,
+            executionRunId: issues.executionRunId,
+            executionState: issues.executionState,
+        })
+            .from(issues)
+            .where(and(eq(issues.id, issueId), eq(issues.companyId, run.companyId)))
+            .then((rows) => rows[0] ?? null);
+        if (!issue) {
+            return {
+                stale: true,
+                errorCode: "issue_not_found",
+                reason: "Cancelled because the target issue no longer exists",
+                details: { issueId },
+            };
+        }
+        const wakeCommentId = deriveCommentId(context, null);
+        const isInteractionWake = allowsIssueInteractionWake(context);
+        const resumeIntent = context.resumeIntent === true || context.followUpRequested === true;
+        const retryReason = readNonEmptyString(context.retryReason) ?? run.scheduledRetryReason ?? null;
+        if (issue.assigneeAgentId !== run.agentId && !isInteractionWake) {
+            return {
+                stale: true,
+                errorCode: "issue_assignee_changed",
+                reason: "Cancelled because issue assignee changed before the queued run could start; the new owner will be woken instead",
+                details: {
+                    issueId,
+                    previousAssigneeAgentId: run.agentId,
+                    currentAssigneeAgentId: issue.assigneeAgentId,
+                },
+            };
+        }
+        if (issue.status === "done" || issue.status === "cancelled") {
+            if (!resumeIntent && !wakeCommentId) {
+                return {
+                    stale: true,
+                    errorCode: "issue_terminal_status",
+                    reason: `Cancelled because issue reached terminal status (${issue.status}) before the queued run could start`,
+                    details: { issueId, currentStatus: issue.status },
+                };
+            }
+        }
+        if (retryReason === MAX_TURN_CONTINUATION_RETRY_REASON && issue.status !== "in_progress") {
+            return {
+                stale: true,
+                errorCode: "issue_not_in_progress",
+                reason: `Cancelled because max-turn continuation issue is no longer in_progress (current status: ${issue.status}) before the queued run could start`,
+                details: { issueId, currentStatus: issue.status, requiredStatus: "in_progress" },
+            };
+        }
+        if (retryReason === MAX_TURN_CONTINUATION_RETRY_REASON && issue.executionRunId !== run.id) {
+            return {
+                stale: true,
+                errorCode: "issue_execution_lock_changed",
+                reason: "Cancelled because max-turn continuation no longer owns the issue execution lock before the queued run could start",
+                details: {
+                    issueId,
+                    expectedExecutionRunId: run.id,
+                    currentExecutionRunId: issue.executionRunId,
+                },
+            };
+        }
+        if (issue.status === "in_review") {
+            const executionState = parseIssueExecutionState(issue.executionState);
+            const currentParticipant = executionState?.currentParticipant ?? null;
+            if (currentParticipant) {
+                const participantMatches = currentParticipant.type === "agent" && currentParticipant.agentId === run.agentId;
+                if (!participantMatches && !wakeCommentId) {
+                    return {
+                        stale: true,
+                        errorCode: "issue_review_participant_changed",
+                        reason: "Cancelled because the in-review participant changed before the queued run could start; the current participant will be woken instead",
+                        details: {
+                            issueId,
+                            currentStageType: executionState?.currentStageType ?? null,
+                            currentParticipant,
+                        },
+                    };
+                }
+            }
+        }
+        return { stale: false };
+    }
+    async function cancelQueuedRunForStaleIssue(run, issueId, staleness) {
+        const now = new Date();
+        const cancelled = await setRunStatus(run.id, "cancelled", {
+            finishedAt: now,
+            error: staleness.reason,
+            errorCode: staleness.errorCode,
+            resultJson: {
+                ...parseObject(run.resultJson),
+                stopReason: staleness.errorCode,
+                effectiveTimeoutSec: 0,
+                timeoutConfigured: false,
+                timeoutSource: "stale_queued_run_gate",
+                timeoutFired: false,
+            },
+        });
+        if (!cancelled)
+            return null;
+        await setWakeupStatus(run.wakeupRequestId, "skipped", {
+            finishedAt: now,
+            error: staleness.reason,
+        });
+        await db
+            .update(issues)
+            .set({
+            executionRunId: null,
+            executionAgentNameKey: null,
+            executionLockedAt: null,
+            updatedAt: now,
+        })
+            .where(and(eq(issues.companyId, run.companyId), eq(issues.id, issueId), eq(issues.executionRunId, run.id)));
+        await appendRunEvent(cancelled, await nextRunEventSeq(cancelled.id), {
+            eventType: "lifecycle",
+            stream: "system",
+            level: "warn",
+            message: staleness.reason,
+            payload: staleness.details,
+        });
+        return cancelled;
+    }
     async function finalizeAgentStatus(agentId, outcome) {
         const existing = await getAgent(agentId);
         if (!existing)
@@ -3359,6 +4551,13 @@ export function heartbeatService(db, options = {}) {
             if (!finalizedRun)
                 continue;
             finalizedRun = await classifyAndPersistRunLiveness(finalizedRun, parseObject(finalizedRun.resultJson)) ?? finalizedRun;
+            await releaseEnvironmentLeasesForRun({
+                runId: finalizedRun.id,
+                companyId: finalizedRun.companyId,
+                agentId: finalizedRun.agentId,
+                status: finalizedRun.status,
+                failureReason: finalizedRun.error ?? undefined,
+            });
             let retriedRun = null;
             if (shouldRetry) {
                 const agent = await getAgent(run.agentId);
@@ -3420,9 +4619,15 @@ export function heartbeatService(db, options = {}) {
     async function scanSilentActiveRuns(opts) {
         return recovery.scanSilentActiveRuns(opts);
     }
+    async function reconcileProductivityReviews(opts) {
+        return productivityReviews.reconcileProductivityReviews(opts);
+    }
     async function buildRunOutputSilence(run, now = new Date()) {
         return recovery.buildRunOutputSilence(run, now);
     }
+    async function buildIssueGraphLivenessAutoRecoveryPreview(opts) {
+        return recovery.buildIssueGraphLivenessAutoRecoveryPreview(opts);
+    }
     async function reconcileIssueGraphLiveness(opts) {
         return recovery.reconcileIssueGraphLiveness(opts);
     }
@@ -3743,6 +4948,9 @@ export function heartbeatService(db, options = {}) {
             const shouldReuseExisting = issueRef?.executionWorkspacePreference === "reuse_existing" &&
                 existingExecutionWorkspace !== null &&
                 existingExecutionWorkspace.status !== "archived";
+            const reusableExecutionWorkspaceConfig = shouldReuseExisting
+                ? existingExecutionWorkspace?.config ?? null
+                : null;
             const persistedExecutionWorkspaceMode = shouldReuseExisting && existingExecutionWorkspace
                 ? issueExecutionWorkspaceModeForPersistedWorkspace(existingExecutionWorkspace.mode)
                 : null;
@@ -3755,7 +4963,7 @@ export function heartbeatService(db, options = {}) {
             const selectedEnvironmentId = resolveExecutionWorkspaceEnvironmentId({
                 projectPolicy: projectExecutionWorkspacePolicy,
                 issueSettings: issueExecutionWorkspaceSettings,
-                workspaceConfig: existingExecutionWorkspace?.config ?? null,
+                workspaceConfig: reusableExecutionWorkspaceConfig,
                 agentDefaultEnvironmentId: agent.defaultEnvironmentId,
                 defaultEnvironmentId: defaultEnvironment.id,
             });
@@ -3770,12 +4978,45 @@ export function heartbeatService(db, options = {}) {
                 });
             const persistedWorkspaceManagedConfig = applyPersistedExecutionWorkspaceConfig({
                 config: workspaceManagedConfig,
-                workspaceConfig: existingExecutionWorkspace?.config ?? null,
+                workspaceConfig: reusableExecutionWorkspaceConfig,
                 mode: effectiveExecutionWorkspaceMode,
             });
-            const mergedConfig = issueAssigneeOverrides?.adapterConfig
-                ? { ...persistedWorkspaceManagedConfig, ...issueAssigneeOverrides.adapterConfig }
-                : persistedWorkspaceManagedConfig;
+            let adapterModelProfiles = [];
+            let profileResolutionFallbackReason = null;
+            try {
+                adapterModelProfiles = await listAdapterModelProfiles(agent.adapterType);
+            }
+            catch (error) {
+                profileResolutionFallbackReason = "adapter_profile_resolution_failed";
+                logger.warn({
+                    err: error,
+                    companyId: agent.companyId,
+                    agentId: agent.id,
+                    adapterType: agent.adapterType,
+                    runId: run.id,
+                }, "Failed to resolve adapter model profiles; falling back to primary adapter config");
+            }
+            const modelProfileApplication = resolveModelProfileApplication({
+                adapterModelProfiles,
+                agentRuntimeConfig: agent.runtimeConfig,
+                issueModelProfile: issueAssigneeOverrides?.modelProfile ?? null,
+                contextSnapshot: context,
+                profileResolutionFallbackReason,
+            });
+            const modelProfileMetadata = modelProfileRunMetadata(modelProfileApplication);
+            if (modelProfileMetadata) {
+                context.paperclipModelProfile = modelProfileMetadata;
+                if (modelProfileApplication.requested)
+                    context.modelProfile = modelProfileApplication.requested;
+            }
+            else {
+                delete context.paperclipModelProfile;
+            }
+            const mergedConfig = mergeModelProfileAdapterConfig({
+                baseConfig: persistedWorkspaceManagedConfig,
+                modelProfile: modelProfileApplication,
+                issueAdapterConfig: issueAssigneeOverrides?.adapterConfig ?? null,
+            });
             const configSnapshot = buildExecutionWorkspaceConfigSnapshot(mergedConfig, selectedEnvironmentId);
             const executionRunConfig = stripWorkspaceRuntimeFromExecutionRunConfig(mergedConfig);
             const { resolvedConfig, secretKeys } = await resolveExecutionRunAdapterConfig({
@@ -4298,12 +5539,16 @@ export function heartbeatService(db, options = {}) {
                                 meta.env[key] = "***REDACTED***";
                         }
                     }
+                    const modelProfileMetadata = modelProfileRunMetadata(modelProfileApplication);
                     await appendRunEvent(currentRun, seq++, {
                         eventType: "adapter.invoke",
                         stream: "system",
                         level: "info",
                         message: "adapter invocation",
-                        payload: meta,
+                        payload: {
+                            ...meta,
+                            ...(modelProfileMetadata ? { modelProfile: modelProfileMetadata } : {}),
+                        },
                     });
                 };
                 const adapter = getServerAdapter(agent.adapterType);
@@ -4324,6 +5569,7 @@ export function heartbeatService(db, options = {}) {
                     runtime: runtimeForAdapter,
                     config: runtimeConfig,
                     context,
+                    runtimeCommandSpec: adapter.getRuntimeCommandSpec?.(runtimeConfig) ?? null,
                     executionTarget,
                     executionTransport: remoteExecution
                         ? { remoteExecution: remoteExecution }
@@ -4465,11 +5711,11 @@ export function heartbeatService(db, options = {}) {
                     }
                     : null;
                 const persistedResultJson = mergeHeartbeatRunResultJson(mergeRunStopMetadataForAgent(agent, outcome, {
-                    resultJson: mergeAdapterRecoveryMetadata({
+                    resultJson: mergeModelProfileRunMetadata(mergeAdapterRecoveryMetadata({
                         resultJson: adapterResult.resultJson ?? null,
                         errorFamily: adapterResult.errorFamily ?? null,
                         retryNotBefore: adapterResult.retryNotBefore ?? null,
-                    }),
+                    }), modelProfileApplication),
                     errorCode: runErrorCode,
                     errorMessage: runErrorMessage,
                 }), adapterResult.summary ?? null);
@@ -4523,7 +5769,30 @@ export function heartbeatService(db, options = {}) {
                             await onLog("stderr", `[paperclip] Failed to post run summary comment: ${err instanceof Error ? err.message : String(err)}\n`);
                         }
                     }
-                    if (outcome === "failed" && readTransientRecoveryContractFromRun(livenessRun)) {
+                    if (outcome === "failed" && isMaxTurnExhaustionRun(livenessRun)) {
+                        const policy = parseMaxTurnContinuationPolicy(agent);
+                        if (policy.enabled && policy.maxAttempts > 0) {
+                            await scheduleBoundedRetryForRun(livenessRun, agent, {
+                                retryReason: MAX_TURN_CONTINUATION_RETRY_REASON,
+                                wakeReason: MAX_TURN_CONTINUATION_WAKE_REASON,
+                                maxAttempts: policy.maxAttempts,
+                                delayMs: policy.delayMs,
+                            });
+                        }
+                        else {
+                            await appendRunEvent(livenessRun, await nextRunEventSeq(livenessRun.id), {
+                                eventType: "lifecycle",
+                                stream: "system",
+                                level: "warn",
+                                message: "Max-turn continuation suppressed because the policy is disabled",
+                                payload: {
+                                    retryReason: MAX_TURN_CONTINUATION_RETRY_REASON,
+                                    policy,
+                                },
+                            });
+                        }
+                    }
+                    else if (outcome === "failed" && readTransientRecoveryContractFromRun(livenessRun)) {
                         await scheduleBoundedRetryForRun(livenessRun, agent);
                     }
                     await finalizeIssueCommentPolicy(livenessRun, agent);
@@ -4674,19 +5943,13 @@ export function heartbeatService(db, options = {}) {
         }
         finally {
             const latestRun = await getRun(run.id).catch(() => null);
-            const releaseResult = await envOrchestrator.releaseForRun({
-                heartbeatRunId: run.id,
+            await releaseEnvironmentLeasesForRun({
+                runId: run.id,
                 companyId: run.companyId,
                 agentId: run.agentId,
-                status: leaseReleaseStatusForRunStatus(latestRun?.status),
+                status: latestRun?.status,
                 failureReason: latestRun?.error ?? undefined,
-            }).catch((err) => {
-                logger.warn({ err, runId: run.id }, "failed to release environment leases for heartbeat run");
-                return null;
             });
-            for (const releaseError of releaseResult?.errors ?? []) {
-                logger.warn({ err: releaseError.error, leaseId: releaseError.leaseId, runId: run.id }, "failed to release environment lease for heartbeat run");
-            }
             await releaseRuntimeServicesForRun(run.id).catch(() => undefined);
             activeRunExecutions.delete(run.id);
             await startNextQueuedRunForAgent(run.agentId);
@@ -4933,7 +6196,8 @@ export function heartbeatService(db, options = {}) {
             if (await isAutomaticRecoverySuppressedByPauseHold(db, issue.companyId, issue.id, treeControlSvc)) {
                 return { kind: "released" };
             }
-            const shouldBlockImmediately = !recoveryAgentInvokable ||
+            const shouldBlockImmediately = issue.originKind === RECOVERY_ORIGIN_KINDS.strandedIssueRecovery ||
+                !recoveryAgentInvokable ||
                 !recoveryAgent ||
                 didAutomaticRecoveryFail(run, issue.status === "todo" ? "assignment_recovery" : "issue_continuation_needed");
             if (shouldBlockImmediately) {
@@ -5951,6 +7215,7 @@ export function heartbeatService(db, options = {}) {
             requestedByActorId: actor?.actorId ?? null,
         }),
         wakeup: enqueueWakeup,
+        triggerIssueMonitor,
         reportRunActivity: clearDetachedRunWarning,
         reapOrphanedRuns,
         promoteDueScheduledRetries,
@@ -5965,8 +7230,10 @@ export function heartbeatService(db, options = {}) {
             return scheduleBoundedRetryForRun(run, agent, opts);
         },
         reconcileStrandedAssignedIssues,
+        buildIssueGraphLivenessAutoRecoveryPreview,
         reconcileIssueGraphLiveness,
         scanSilentActiveRuns,
+        reconcileProductivityReviews,
         buildRunOutputSilence,
         tickTimers: async (now = new Date()) => {
             const allAgents = await db.select().from(agents);
@@ -6001,7 +7268,12 @@ export function heartbeatService(db, options = {}) {
                 else
                     skipped += 1;
             }
-            return { checked, enqueued, skipped };
+            const issueMonitors = await tickDueIssueMonitors(now);
+            return {
+                checked: checked + issueMonitors.checked,
+                enqueued: enqueued + issueMonitors.triggered,
+                skipped: skipped + issueMonitors.skipped,
+            };
         },
         cancelRun: (runId) => cancelRunInternal(runId),
         cancelActiveForAgent: (agentId) => cancelActiveForAgentInternal(agentId),