@penclipai/server 2026.704.0 → 2026.714.0

package/dist/services/heartbeat.js

@@ -5,10 +5,11 @@ import { promisify } from "node:util";
 import { createHash, randomUUID } from "node:crypto";
 import { and, asc, desc, eq, getTableColumns, gt, gte, inArray, isNull, lt, lte, notInArray, or, sql } from "drizzle-orm";
 import { AGENT_DEFAULT_MAX_CONCURRENT_RUNS, ISSUE_CONTINUATION_SUMMARY_DOCUMENT_KEY, MODEL_PROFILE_KEYS, envBindingSchema, } from "@penclipai/shared";
-import { agents, agentConfigRevisions, agentRuntimeState, agentTaskSessions, agentWakeupRequests, activityLog, approvals, companySkills as companySkillsTable, companies, costEvents, documentAnnotationComments, documentAnnotationThreads, documentRevisions, issueDocuments, heartbeatRunEvents, heartbeatRuns, issueApprovals, issueComments, issuePlanDecompositions, issueRelations, issueThreadInteractions, issues, issueWorkProducts, projects, projectWorkspaces, routineRevisions, routineRuns, routines, workspaceOperations, } from "@penclipai/db";
+import { agents, agentConfigRevisions, agentRuntimeState, agentTaskSessions, agentWakeupRequests, activityLog, approvals, companyMemberships, companySkillTestRuns, companySkillVersions, companySkills as companySkillsTable, companies, costEvents, documentAnnotationComments, documentAnnotationThreads, documentRevisions, issueDocuments, executionWorkspaces, heartbeatRunEvents, heartbeatRuns, issueApprovals, issueComments, issuePlanDecompositions, issueRecoveryActions, issueRelations, issueThreadInteractions, issues, issueWorkProducts, projects, projectWorkspaces, routineRevisions, routineRuns, routines, workspaceOperations, } from "@penclipai/db";
 import { conflict, HttpError, notFound } from "../errors.js";
 import { logger } from "../middleware/logger.js";
 import { publishLiveEvent } from "./live-events.js";
+import { normalizeResponsibleUserDenialCode } from "./responsible-user-denial-run-outcomes.js";
 import { getRunLogStore } from "./run-log-store.js";
 import { getServerAdapter, listAdapterModelProfiles, runningProcesses } from "../adapters/index.js";
 import { createLocalAgentJwt } from "../agent-auth-jwt.js";
@@ -23,10 +24,12 @@ import { resolveDefaultAgentWorkspaceDir, resolveManagedProjectWorkspaceDir } fr
 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, normalizeMaxTurnStopReason, } from "./heartbeat-stop-metadata.js";
 import { classifyRunLiveness, } from "./run-liveness.js";
+import { ISSUE_NEW_INPUT_ACTIVITY_ACTIONS, ISSUE_PROGRESS_ACTIVITY_ACTIONS, ISSUE_REWAKE_LOOKBACK_MS, ISSUE_REWAKE_RUN_SAMPLE_LIMIT, evaluateIssueRewakeThrottle, isThrottleCandidateIssueRewake, } from "./issue-rewake-throttle.js";
 import { logActivity, publishPluginDomainEvent } from "./activity-log.js";
 import { buildWorkspaceReadyComment, cleanupExecutionWorkspaceArtifacts, ensureGitWorktreeBranchCoherent, ensurePersistedExecutionWorkspaceAvailable, ensureRuntimeServicesForRun, formatManagedGitWorktreeBranchInspection, inspectManagedGitWorktreeBranch, persistAdapterManagedRuntimeServices, realizeExecutionWorkspace, releaseRuntimeServicesForRun, sanitizeRuntimeServiceBaseEnv, } from "./workspace-runtime.js";
 import { issueService } from "./issues.js";
-import { ISSUE_BLOCKERS_RESOLVED_WAKE_REASON, buildIssueBlockersResolvedWakeIdempotencyKey, findExistingIssueBlockersResolvedWake, } from "./issue-dependency-wakeups.js";
+import { visibleIssueCondition } from "./issue-visibility.js";
+import { ISSUE_BLOCKERS_RESOLVED_WAKE_REASON, } from "./issue-dependency-wakeups.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 { continuationSummaryParksExecutor, getIssueContinuationSummaryDocument, refreshIssueContinuationSummary, } from "./issue-continuation-summary.js";
@@ -34,8 +37,9 @@ import { buildPlanReviewContext } from "./plan-review-context.js";
 import { executionWorkspaceService, mergeExecutionWorkspaceConfig } from "./execution-workspaces.js";
 import { workspaceOperationService } from "./workspace-operations.js";
 import { isProcessGroupAlive, terminateLocalService } from "./local-service-supervisor.js";
-import { buildExecutionWorkspaceAdapterConfig, gateProjectExecutionWorkspacePolicy, issueExecutionWorkspaceModeForPersistedWorkspace, parseIssueExecutionWorkspaceSettings, parseProjectExecutionWorkspacePolicy, resolveExecutionWorkspaceEnvironmentId, resolveExecutionWorkspaceMode, } from "./execution-workspace-policy.js";
-import { instanceSettingsService } from "./instance-settings.js";
+import { HEARTBEAT_RUN_SCRATCH_MARKER, buildHeartbeatRunScratchEnv, cleanupHeartbeatRunScratch, prepareHeartbeatRunScratch, } from "./run-scratch.js";
+import { buildExecutionWorkspaceAdapterConfig, gateProjectExecutionWorkspacePolicy, issueExecutionWorkspaceModeForPersistedWorkspace, isUnrunnableWorktreeCombo, parseIssueExecutionWorkspaceSettings, parseProjectExecutionWorkspacePolicy, resolveEffectiveWorkspaceStrategyType, resolveExecutionWorkspaceEnvironmentId, resolveExecutionWorkspaceMode, WORKSPACE_WORKTREE_REQUIRES_PROJECT_CODE, WORKSPACE_WORKTREE_REQUIRES_PROJECT_MESSAGE, WORKSPACE_WORKTREE_REQUIRES_PROJECT_REMEDIATION, } from "./execution-workspace-policy.js";
+import { instanceSettingsService, resolveWorktreeRunExecutionActivation, } from "./instance-settings.js";
 import { evaluateExecutionAllowlist, isExecutionForcedToKubernetes, } from "./execution-allowlist.js";
 import { RECOVERY_ORIGIN_KINDS, FINISH_SUCCESSFUL_RUN_HANDOFF_REASON, SUCCESSFUL_RUN_MISSING_STATE_REASON, RUN_LIVENESS_CONTINUATION_REASON, buildRunLivenessContinuationIdempotencyKey, buildFinishSuccessfulRunHandoffIdempotencyKey, buildSuccessfulRunHandoffRequiredNotice, decideRunLivenessContinuation, decideSuccessfulRunHandoff, findExistingFinishSuccessfulRunHandoffWake, findExistingRunLivenessContinuationWake, SUCCESSFUL_RUN_HANDOFF_REQUIRED_NOTICE_BODY, readContinuationAttempt, } from "./recovery/index.js";
 import { isAutomaticRecoverySuppressedByPauseHold } from "./recovery/pause-hold-guard.js";
@@ -49,8 +53,9 @@ import { redactQuarantinedBodyForHigherTrust, sanitizeQuarantinedCommentForHighe
 import { redactCurrentUserText, redactCurrentUserValue, } from "../log-redaction.js";
 import { redactEventPayload, redactSensitiveText } from "../redaction.js";
 import { hasSessionCompactionThresholds, resolveSessionCompactionPolicy, } from "@penclipai/adapter-utils";
-import { readPaperclipSkillSyncPreference, writePaperclipSkillSyncPreference, } from "@penclipai/adapter-utils/server-utils";
+import { readPaperclipSkillSyncPreference, UNMANAGED_BACKGROUND_TASK_LIVENESS_REASON, UNMANAGED_BACKGROUND_TASK_STOP_REASON, writePaperclipSkillSyncPreference, } from "@penclipai/adapter-utils/server-utils";
 import { extractSkillMentionIds, isUuidLike } from "@penclipai/shared";
+import { evaluateCodexCredentialReadiness } from "@penclipai/adapter-codex-local/server";
 import { environmentService } from "./environments.js";
 import { parseExecutionPolicyBootstrapEnv } from "./execution-policy-bootstrap.js";
 import { environmentRuntimeService } from "./environment-runtime.js";
@@ -94,7 +99,7 @@ const MAX_INLINE_WAKE_COMMENT_BODY_TOTAL_CHARS = 12_000;
 const execFile = promisify(execFileCallback);
 const EXECUTION_PATH_HEARTBEAT_RUN_STATUSES = ["queued", "running", "scheduled_retry"];
 const CANCELLABLE_HEARTBEAT_RUN_STATUSES = ["queued", "running", "scheduled_retry"];
-const HEARTBEAT_RUN_TERMINAL_STATUSES = ["succeeded", "failed", "cancelled", "timed_out"];
+const HEARTBEAT_RUN_TERMINAL_STATUSES = ["succeeded", "interrupted", "failed", "cancelled", "timed_out"];
 const UNSUCCESSFUL_HEARTBEAT_RUN_TERMINAL_STATUSES = ["failed", "cancelled", "timed_out"];
 const TIMER_ACTIONABLE_ISSUE_STATUSES = ["todo", "in_progress"];
 export { ACTIVE_RUN_OUTPUT_CONTINUE_REARM_MS, ACTIVE_RUN_OUTPUT_CRITICAL_THRESHOLD_MS, ACTIVE_RUN_OUTPUT_SUSPICION_THRESHOLD_MS, } from "./recovery/service.js";
@@ -110,6 +115,10 @@ 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 INTERACTION_CONTINUATION_INFRA_RETRY_REASON = "interaction_continuation_infra_retry";
+export const INTERACTION_CONTINUATION_INFRA_WAKE_REASON = "interaction_continuation_infra_retry";
+const INTERACTION_CONTINUATION_INFRA_MAX_ATTEMPTS = 3;
+const RESOLVED_INTERACTION_CONTINUATION_STATUSES = new Set(["accepted", "answered", "rejected"]);
 const WORKSPACE_VALIDATION_FAILURE_CODE = "workspace_validation_failed";
 const WORKSPACE_VALIDATION_RECOVERY_CAUSE = "workspace_validation_failed";
 const CONFIGURATION_INCOMPLETE_FAILURE_CODE = "configuration_incomplete";
@@ -122,7 +131,6 @@ const GITHUB_PR_WORKFLOW_SKILL_SLUG = "github-pr-workflow";
 const PUSH_CAPABILITY_ENV_KEYS = ["GH_TOKEN", "GITHUB_TOKEN"];
 // Keep this in sync with local adapters that require a git workspace before launch.
 const GIT_SENSITIVE_LOCAL_ADAPTER_TYPES = new Set([
-    "acpx_local",
     "claude_local",
     "codex_local",
     "cursor",
@@ -174,6 +182,9 @@ function readHeartbeatRunErrorFamily(run) {
     const persistedFamily = readNonEmptyString(resultJson.errorFamily);
     if (persistedFamily)
         return persistedFamily;
+    if (run.errorCode === "provider_quota") {
+        return "provider_quota";
+    }
     if (run.errorCode === "codex_transient_upstream" || run.errorCode === "claude_transient_upstream") {
         return "transient_upstream";
     }
@@ -194,13 +205,45 @@ function readTransientRetryNotBeforeFromRun(run) {
     return Number.isNaN(parsed.getTime()) ? null : parsed;
 }
 function readTransientRecoveryContractFromRun(run) {
-    return readHeartbeatRunErrorFamily(run) === "transient_upstream"
+    const errorFamily = readHeartbeatRunErrorFamily(run);
+    return errorFamily === "transient_upstream" || errorFamily === "provider_quota"
         ? {
-            errorFamily: "transient_upstream",
+            errorFamily,
             retryNotBefore: readTransientRetryNotBeforeFromRun(run),
         }
         : null;
 }
+function isResolvedInteractionContinuationWakeContext(contextSnapshot) {
+    const context = parseObject(contextSnapshot);
+    const interactionId = readNonEmptyString(context.interactionId);
+    const interactionStatus = readNonEmptyString(context.interactionStatus);
+    if (!interactionId || !interactionStatus)
+        return false;
+    if (!RESOLVED_INTERACTION_CONTINUATION_STATUSES.has(interactionStatus))
+        return false;
+    const mutation = readNonEmptyString(context.mutation);
+    const wakeReason = readNonEmptyString(context.wakeReason);
+    const retryReason = readNonEmptyString(context.retryReason);
+    return ((mutation === "interaction" && wakeReason === "issue_commented") ||
+        wakeReason === INTERACTION_CONTINUATION_INFRA_WAKE_REASON ||
+        retryReason === INTERACTION_CONTINUATION_INFRA_RETRY_REASON);
+}
+function isSpawnLikeFailureMessage(value) {
+    if (typeof value !== "string")
+        return false;
+    return /failed to start command|spawn\b|\bENOENT\b/i.test(value);
+}
+function isRetryableInteractionContinuationInfrastructureFailure(run) {
+    if (run.errorCode === WORKSPACE_VALIDATION_FAILURE_CODE || run.errorCode === "process_lost") {
+        return true;
+    }
+    if (run.errorCode !== "adapter_failed" && run.errorCode !== "setup_failed")
+        return false;
+    const resultJson = parseObject(run.resultJson);
+    return (isSpawnLikeFailureMessage(run.error) ||
+        isSpawnLikeFailureMessage(resultJson.errorMessage) ||
+        isSpawnLikeFailureMessage(resultJson.message));
+}
 function mergeAdapterRecoveryMetadata(input) {
     const errorFamily = readNonEmptyString(input.errorFamily);
     const retryNotBefore = readNonEmptyString(input.retryNotBefore);
@@ -213,6 +256,7 @@ function mergeAdapterRecoveryMetadata(input) {
             ? {
                 retryNotBefore,
                 transientRetryNotBefore: retryNotBefore,
+                ...(errorFamily === "provider_quota" ? { providerQuotaRetryNotBefore: retryNotBefore } : {}),
             }
             : {}),
     };
@@ -221,6 +265,22 @@ const RUNNING_ISSUE_WAKE_REASONS_REQUIRING_FOLLOWUP = new Set([
     "approval_approved",
     ISSUE_BLOCKERS_RESOLVED_WAKE_REASON,
 ]);
+const ISSUE_RESPONSIBLE_USER_WAKE_REASONS = new Set([
+    "issue_assigned",
+    "issue_checked_out",
+    "issue_commented",
+    "issue_comment_mentioned",
+    "issue_reopened_via_comment",
+    "issue_blockers_resolved",
+    "issue_children_completed",
+    "issue_status_changed",
+    "issue_tree_restored",
+    "issue_recovery_action_restored",
+    "execution_review_requested",
+    "execution_approval_requested",
+    "execution_changes_requested",
+    "approval_approved",
+]);
 const SESSIONED_LOCAL_ADAPTERS = new Set([
     "claude_local",
     "codex_local",
@@ -235,9 +295,18 @@ const SESSIONED_LOCAL_ADAPTERS = new Set([
 const activeRunExecutions = new Set();
 const INLINE_BASE64_IMAGE_DATA_RE = /("type":"image","source":\{"type":"base64","data":")([A-Za-z0-9+/=]{1024,})(")/g;
 function formatMissingBindingForOperator(missing) {
+    if (missing.bindingType === "user_secret_ref") {
+        const definitionLabel = missing.userSecretDefinitionName
+            ? `"${missing.userSecretDefinitionName}"`
+            : missing.userSecretDefinitionKey
+                ? `"${missing.userSecretDefinitionKey}"`
+                : "declared user secret";
+        const ownerLabel = missing.responsibleUserId ? ` for responsible user ${missing.responsibleUserId}` : "";
+        return `user secret ${definitionLabel}${ownerLabel} not available at ${missing.consumerType} ${missing.configPath}`;
+    }
     const secretLabel = missing.secretName
         ? `"${missing.secretName}"`
-        : missing.secretId;
+        : missing.secretId ?? "unknown";
     return `secret ${secretLabel} not bound at ${missing.consumerType} ${missing.configPath}`;
 }
 function isConfiguredEnvBindingValue(binding) {
@@ -342,19 +411,39 @@ export async function resolveExecutionRunAdapterConfig(input) {
     if (typeof input.secretsSvc.collectMissingRuntimeBindings === "function") {
         const missingBindings = [];
         if (environmentEnv && input.environmentId) {
-            missingBindings.push(...(await input.secretsSvc.collectMissingRuntimeBindings(input.companyId, environmentEnv, { consumerType: "environment", consumerId: input.environmentId })));
+            missingBindings.push(...(await input.secretsSvc.collectMissingRuntimeBindings(input.companyId, environmentEnv, {
+                consumerType: "environment",
+                consumerId: input.environmentId,
+                responsibleUserId: input.responsibleUserId ?? null,
+            })));
         }
         if (input.agentId) {
-            missingBindings.push(...(await input.secretsSvc.collectMissingRuntimeBindings(input.companyId, parseObject(executionRunConfig.env), { consumerType: "agent", consumerId: input.agentId })));
+            missingBindings.push(...(await input.secretsSvc.collectMissingRuntimeBindings(input.companyId, parseObject(executionRunConfig.env), {
+                consumerType: "agent",
+                consumerId: input.agentId,
+                responsibleUserId: input.responsibleUserId ?? null,
+            })));
             if (typeof input.secretsSvc.collectMissingAdapterConfigRuntimeBindings === "function") {
-                missingBindings.push(...(await input.secretsSvc.collectMissingAdapterConfigRuntimeBindings(input.companyId, executionRunConfig, input.adapterType ?? null, { consumerType: "agent", consumerId: input.agentId })));
+                missingBindings.push(...(await input.secretsSvc.collectMissingAdapterConfigRuntimeBindings(input.companyId, executionRunConfig, input.adapterType ?? null, {
+                    consumerType: "agent",
+                    consumerId: input.agentId,
+                    responsibleUserId: input.responsibleUserId ?? null,
+                })));
             }
         }
         if (projectEnv && input.projectId) {
-            missingBindings.push(...(await input.secretsSvc.collectMissingRuntimeBindings(input.companyId, projectEnv, { consumerType: "project", consumerId: input.projectId })));
+            missingBindings.push(...(await input.secretsSvc.collectMissingRuntimeBindings(input.companyId, projectEnv, {
+                consumerType: "project",
+                consumerId: input.projectId,
+                responsibleUserId: input.responsibleUserId ?? null,
+            })));
         }
         if (routineEnv && input.routineId) {
-            missingBindings.push(...(await input.secretsSvc.collectMissingRuntimeBindings(input.companyId, routineEnv, { consumerType: "routine", consumerId: input.routineId })));
+            missingBindings.push(...(await input.secretsSvc.collectMissingRuntimeBindings(input.companyId, routineEnv, {
+                consumerType: "routine",
+                consumerId: input.routineId,
+                responsibleUserId: input.responsibleUserId ?? null,
+            })));
         }
         if (requiredScopedEnvBinding) {
             const requiredEnvKeys = new Set(requiredScopedEnvBinding.keys);
@@ -400,6 +489,7 @@ export async function resolveExecutionRunAdapterConfig(input) {
                 consumerId: input.environmentId,
                 actorType: "agent",
                 actorId: input.agentId ?? null,
+                responsibleUserId: input.responsibleUserId ?? null,
                 issueId: input.issueId ?? null,
                 heartbeatRunId: input.heartbeatRunId ?? null,
                 ...(lowTrustAllowedBindingIds !== undefined ? { allowedBindingIds: lowTrustAllowedBindingIds } : {}),
@@ -412,6 +502,7 @@ export async function resolveExecutionRunAdapterConfig(input) {
             consumerId: input.agentId,
             actorType: "agent",
             actorId: input.agentId,
+            responsibleUserId: input.responsibleUserId ?? null,
             issueId: input.issueId ?? null,
             heartbeatRunId: input.heartbeatRunId ?? null,
             ...(lowTrustAllowedBindingIds !== undefined ? { allowedBindingIds: lowTrustAllowedBindingIds } : {}),
@@ -433,6 +524,7 @@ export async function resolveExecutionRunAdapterConfig(input) {
                 consumerId: input.projectId,
                 actorType: "agent",
                 actorId: input.agentId ?? null,
+                responsibleUserId: input.responsibleUserId ?? null,
                 issueId: input.issueId ?? null,
                 heartbeatRunId: input.heartbeatRunId ?? null,
                 ...(lowTrustAllowedBindingIds !== undefined ? { allowedBindingIds: lowTrustAllowedBindingIds } : {}),
@@ -455,6 +547,7 @@ export async function resolveExecutionRunAdapterConfig(input) {
                 consumerId: input.routineId,
                 actorType: "agent",
                 actorId: input.agentId ?? null,
+                responsibleUserId: input.responsibleUserId ?? null,
                 issueId: input.issueId ?? null,
                 heartbeatRunId: input.heartbeatRunId ?? null,
                 ...(lowTrustAllowedBindingIds !== undefined ? { allowedBindingIds: lowTrustAllowedBindingIds } : {}),
@@ -470,6 +563,42 @@ export async function resolveExecutionRunAdapterConfig(input) {
             secretKeys.add(key);
         }
     }
+    // Pre-dispatch credential gate for codex_local: a managed Codex home with no
+    // usable auth.json and an empty OPENAI_API_KEY would dispatch a run that
+    // immediately fails with "no Codex credentials provisioned" (adapter_failed),
+    // making a configuration problem look like a runtime failure. Surface it as a
+    // configuration-incomplete blocker instead, naming the missing credential
+    // action and owner without leaking any secret value. This runs after secret
+    // resolution so a per-agent OPENAI_API_KEY (plain or resolved secret) counts
+    // as satisfying the credential. It shares the exact readiness predicate the
+    // adapter uses at execute time, so the two cannot drift.
+    if ((input.adapterType ?? null) === "codex_local") {
+        const resolvedEnv = parseObject(resolvedConfig.env);
+        const readiness = await evaluateCodexCredentialReadiness({
+            env: process.env,
+            companyId: input.companyId,
+            configuredCodexHome: readNonEmptyString(resolvedEnv.CODEX_HOME),
+            configuredApiKey: readNonEmptyString(resolvedEnv.OPENAI_API_KEY),
+        });
+        if (readiness.managed && !readiness.ready) {
+            throw new ConfigurationIncompleteFailure(`configuration incomplete: no Codex credentials available for managed home "${readiness.effectiveHome}". ` +
+                `Sign in to Codex on the host with a ChatGPT subscription, or bind a per-agent OPENAI_API_KEY secret for this agent.`, {
+                configurationIncomplete: {
+                    reason: "codex_credentials_missing",
+                    companyId: input.companyId,
+                    agentId: input.agentId ?? null,
+                    issueId: input.issueId ?? null,
+                    projectId: input.projectId ?? null,
+                    routineId: input.routineId ?? null,
+                    responsibleUserId: input.responsibleUserId ?? null,
+                    adapterType: "codex_local",
+                    requiredEnvKeys: ["OPENAI_API_KEY"],
+                    effectiveCodexHome: readiness.effectiveHome,
+                    missingBindings: [],
+                },
+            });
+        }
+    }
     return {
         resolvedConfig,
         secretKeys,
@@ -787,6 +916,9 @@ function isWorkspaceValidationFailure(error) {
 function isWorkspaceValidationFailedRun(run) {
     return run?.errorCode === WORKSPACE_VALIDATION_FAILURE_CODE;
 }
+function readWorkspaceValidationPayloadFromRun(run) {
+    return parseObject(parseObject(run?.resultJson).workspaceValidation);
+}
 function stableStringifyForFingerprint(value) {
     if (Array.isArray(value)) {
         return `[${value.map((entry) => stableStringifyForFingerprint(entry)).join(",")}]`;
@@ -828,6 +960,14 @@ async function hasGitMetadata(cwd) {
         .then((entry) => entry.isDirectory() || entry.isFile())
         .catch(() => false);
 }
+async function isGitCheckout(cwd) {
+    const normalized = readNonEmptyString(cwd);
+    if (!normalized)
+        return false;
+    return execFile("git", ["rev-parse", "--show-toplevel"], { cwd: normalized })
+        .then((result) => Boolean(readNonEmptyString(result.stdout)))
+        .catch(() => false);
+}
 function sameResolvedPath(left, right) {
     const leftPath = readNonEmptyString(left);
     const rightPath = readNonEmptyString(right);
@@ -854,6 +994,45 @@ async function hasGitPushRemote(cwd) {
     }
     return false;
 }
+export async function assertGitWorktreeBaseWorkspaceReady(input) {
+    if (!input.issue)
+        return;
+    if (input.requestedExecutionWorkspaceMode !== "isolated_workspace" &&
+        input.requestedExecutionWorkspaceMode !== "operator_branch") {
+        return;
+    }
+    const strategyType = resolveEffectiveWorkspaceStrategyType(input.requestedExecutionWorkspaceMode, input.config);
+    if (strategyType !== "git_worktree")
+        return;
+    const issueLabel = input.issue.identifier ?? input.issue.id;
+    const remediation = "This task needs a project / project workspace or a reusable execution workspace before it can run.";
+    const fail = (reason, message, extra = {}) => {
+        throw new WorkspaceValidationFailure(message, {
+            workspaceValidation: {
+                reason,
+                issueId: input.issue.id,
+                issueIdentifier: input.issue.identifier,
+                issueProjectId: input.issue.projectId,
+                issueProjectWorkspaceId: input.issue.projectWorkspaceId,
+                issueExecutionWorkspaceId: input.issue.executionWorkspaceId ?? null,
+                issueExecutionWorkspacePreference: input.issue.executionWorkspacePreference ?? null,
+                requestedExecutionWorkspaceMode: input.requestedExecutionWorkspaceMode,
+                workspaceStrategyType: strategyType,
+                resolvedWorkspaceSource: input.base.source,
+                resolvedProjectId: input.base.projectId,
+                resolvedProjectWorkspaceId: input.base.workspaceId,
+                resolvedWorkspaceCwd: input.base.baseCwd,
+                ...extra,
+            },
+        });
+    };
+    if (input.base.source === "agent_home") {
+        fail("git_worktree_base_agent_home", `Issue ${issueLabel} requested ${input.requestedExecutionWorkspaceMode} with git_worktree, but no project or reusable execution workspace was resolved; refusing to create a git worktree from agent fallback cwd "${input.base.baseCwd}". ${remediation}`);
+    }
+    if (!await isGitCheckout(input.base.baseCwd)) {
+        fail("git_worktree_base_not_git_checkout", `Issue ${issueLabel} requested ${input.requestedExecutionWorkspaceMode} with git_worktree, but base workspace "${input.base.baseCwd}" is not a git checkout. ${remediation}`);
+    }
+}
 export async function assertPushCapabilityCheckoutValid(input) {
     if (!input.enabled || !input.issue)
         return;
@@ -959,8 +1138,8 @@ export async function assertGitSensitiveAdapterWorkspaceValid(input) {
     if (workspaceExpectation && effectiveCwd && !await hasGitMetadata(effectiveCwd)) {
         fail("missing_git_metadata", `Issue ${issue.identifier ?? issue.id} expected a git workspace for ${input.adapterType}, but "${effectiveCwd}" has no .git metadata.`);
     }
-    const expectedManagedBranchName = readNonEmptyString(input.persistedExecutionWorkspace?.branchName) ??
-        readNonEmptyString(input.executionWorkspace.branchName);
+    const expectedManagedBranchName = readNonEmptyString(input.executionWorkspace.branchName) ??
+        readNonEmptyString(input.persistedExecutionWorkspace?.branchName);
     if (input.persistedExecutionWorkspace?.strategyType === "git_worktree" &&
         effectiveCwd &&
         expectedManagedBranchName) {
@@ -1468,6 +1647,10 @@ function normalizeBilledCostCents(costUsd, billingType) {
         return 0;
     return Math.max(0, Math.round(costUsd * 100));
 }
+export function resolveLedgerCostStatus(input) {
+    const hasTokenUsage = input.inputTokens > 0 || input.cachedInputTokens > 0 || input.outputTokens > 0;
+    return input.costUsd == null && hasTokenUsage ? "unpriced" : "reported";
+}
 async function resolveLedgerScopeForRun(db, companyId, run) {
     const context = parseObject(run.contextSnapshot);
     const contextIssueId = readNonEmptyString(context.issueId);
@@ -1727,6 +1910,8 @@ export function shouldResetTaskSessionForWake(contextSnapshot) {
     return false;
 }
 function shouldRequireIssueCommentForWake(contextSnapshot) {
+    if (contextSnapshot?.skipIssueComment === true)
+        return false;
     const wakeReason = readNonEmptyString(contextSnapshot?.wakeReason);
     return (wakeReason === "issue_assigned" ||
         wakeReason === "execution_review_requested" ||
@@ -1854,6 +2039,96 @@ const EFFECTIVE_RUN_WORKSPACE_CONFIG_CATEGORIES = [
     "environment",
     "realization",
 ];
+export function resolveExecutionWorkspaceReuseRequestForIssue(input) {
+    const requestedExecutionWorkspaceId = readNonEmptyString(input.issueExecutionWorkspaceId);
+    const requestedShouldReuseExisting = input.issueExecutionWorkspacePreference === "reuse_existing" && requestedExecutionWorkspaceId !== null;
+    return {
+        requestedExecutionWorkspaceId,
+        requestedShouldReuseExisting,
+        existingExecutionWorkspaceAvailable: requestedShouldReuseExisting &&
+            input.existingExecutionWorkspaceStatus !== null &&
+            input.existingExecutionWorkspaceStatus !== undefined &&
+            input.existingExecutionWorkspaceStatus !== "archived",
+    };
+}
+export function resolveExecutionWorkspaceReuseProvisioningPolicy(input) {
+    const shouldRestoreExistingWorkspace = input.requestedShouldReuseExisting;
+    const replacementClassDrift = input.requestedShouldReuseExisting && input.workspaceConfigFreshness.action === "replace";
+    return {
+        shouldRestoreExistingWorkspace,
+        shouldRefreshWorkspaceConfigSnapshot: shouldRestoreExistingWorkspace &&
+            !replacementClassDrift &&
+            input.workspaceConfigFreshness.shouldRefreshConfigSnapshot,
+        shouldPersistLatestWorkspaceConfigMetadata: !replacementClassDrift,
+    };
+}
+function formatInheritedExecutionWorkspaceReuseFailure(input) {
+    const issueLabel = input.issueRef?.identifier ?? input.issueRef?.id ?? input.runId;
+    const workspaceLabel = input.executionWorkspaceId ?? "unknown workspace";
+    const causeMessage = input.cause instanceof Error
+        ? input.cause.message
+        : input.cause != null
+            ? String(input.cause)
+            : null;
+    const remediation = input.reason === "inherited_workspace_reuse_failed"
+        ? "Inspect the referenced execution workspace restore/provision logs, repair or unarchive the workspace, or intentionally clear the issue's reuse_existing workspace binding before retrying."
+        : "Repair or unarchive the referenced execution workspace, or intentionally clear the issue's reuse_existing workspace binding before retrying.";
+    const message = causeMessage
+        ? `Issue ${issueLabel} requested inherited execution workspace reuse for ${workspaceLabel}, but the workspace could not be restored because ${causeMessage}.`
+        : `Issue ${issueLabel} requested inherited execution workspace reuse for ${workspaceLabel}, but the workspace could not be restored.`;
+    return `${message} ${remediation}`;
+}
+export async function provisionExecutionWorkspaceForFreshnessDecision(input) {
+    const policy = resolveExecutionWorkspaceReuseProvisioningPolicy({
+        requestedShouldReuseExisting: input.requestedShouldReuseExisting,
+        workspaceConfigFreshness: input.workspaceConfigFreshness,
+    });
+    if (!policy.shouldRestoreExistingWorkspace) {
+        const executionWorkspace = await input.realizeWorkspace();
+        return {
+            executionWorkspace,
+            reusedExecutionWorkspace: null,
+            policy,
+        };
+    }
+    let restored = null;
+    let reuseFailure = null;
+    try {
+        restored = (await input.restoreExistingWorkspace?.()) ?? null;
+    }
+    catch (error) {
+        if (isWorkspaceValidationFailure(error)) {
+            throw error;
+        }
+        reuseFailure = formatInheritedExecutionWorkspaceReuseFailure({
+            reason: "inherited_workspace_reuse_failed",
+            issueRef: input.issueRef,
+            runId: input.runId,
+            executionWorkspaceId: input.existingExecutionWorkspaceId,
+            workspaceConfigFreshness: input.workspaceConfigFreshness,
+            cause: error,
+        });
+    }
+    if (!restored) {
+        reuseFailure = reuseFailure ?? formatInheritedExecutionWorkspaceReuseFailure({
+            reason: "inherited_workspace_reuse_unavailable",
+            issueRef: input.issueRef,
+            runId: input.runId,
+            executionWorkspaceId: input.existingExecutionWorkspaceId,
+            workspaceConfigFreshness: input.workspaceConfigFreshness,
+        });
+    }
+    if (reuseFailure)
+        throw new Error(reuseFailure);
+    if (!restored) {
+        throw new Error("Expected restored execution workspace after reuse fallback handling");
+    }
+    return {
+        executionWorkspace: restored,
+        reusedExecutionWorkspace: restored,
+        policy,
+    };
+}
 const EFFECTIVE_RUN_SESSION_CONFIG_CATEGORY_LABELS = {
     adapter: "adapter",
     adapterConfig: "adapter config",
@@ -2421,11 +2696,14 @@ export function resolveTaskSessionConfigFreshness(input) {
         nextFingerprint: input.configMetadata?.fingerprint ?? null,
     };
 }
-function shouldAutoCheckoutIssueForWake(input) {
+export function shouldAutoCheckoutIssueForWake(input) {
     if (input.issueAssigneeAgentId !== input.agentId)
         return false;
     if (!input.isDependencyReady)
         return false;
+    const executionState = parseIssueExecutionState(input.issueExecutionState);
+    if (executionState?.status === "pending")
+        return false;
     const issueStatus = readNonEmptyString(input.issueStatus);
     if (issueStatus !== "todo" &&
         issueStatus !== "backlog" &&
@@ -2560,6 +2838,8 @@ const INTERACTION_CONTINUATION_CONTEXT_KEYS = [
     "interactionStatus",
     "continuationPolicy",
     "checkboxSelection",
+    "itemVerdicts",
+    "newlyResolvedItemIds",
 ];
 function isInteractionResolutionWakePayload(payload) {
     return readNonEmptyString(payload?.mutation) === "interaction";
@@ -2839,6 +3119,7 @@ export async function buildPaperclipWakePayload(input) {
             : [],
         executionStage: Object.keys(executionStage).length > 0 ? executionStage : null,
         taskWatchdog: (input.contextSnapshot.taskWatchdog ?? null),
+        skillTest: (input.contextSnapshot.paperclipSkillTest ?? null),
         continuationSummary: safeContinuationSummary
             ? {
                 key: safeContinuationSummary.key,
@@ -3067,6 +3348,9 @@ export function buildPaperclipTaskMarkdown(input) {
             }
             lines.push(`- Work mode: ${quoteTaskScalar("planning")}`, "", "Planning mode directive:", directive);
         }
+        else if (issue.workMode === "skill_test") {
+            lines.push(`- Work mode: ${quoteTaskScalar("skill_test")}`, "", "Skill test mode directive:", "You are testing a pinned skill revision. Make no durable changes outside this issue. Do not push, publish, send external messages, or mutate other issues. Write your final output as issue document `output`, then finish by marking this issue done.");
+        }
         else if (acceptedPlanContinuation) {
             lines.push("", "Accepted plan directive:", "Create child issues from the approved plan only. Do not write code or perform implementation work on the source issue.");
         }
@@ -3178,6 +3462,30 @@ export function normalizeSessionParams(params) {
         return null;
     return Object.keys(params).length > 0 ? params : null;
 }
+export function resolveSkillTestRunCompletionForHeartbeatOutcome(outcome, error) {
+    if (outcome === "cancelled") {
+        return {
+            outcome: "cancelled",
+            error: error ?? "Harness run was cancelled",
+            heartbeatOutcome: outcome,
+        };
+    }
+    if (outcome === "timed_out") {
+        return {
+            outcome: "failed",
+            error: error ?? "Timed out",
+            heartbeatOutcome: outcome,
+        };
+    }
+    if (outcome === "failed") {
+        return {
+            outcome: "failed",
+            error: error ?? "Adapter failed",
+            heartbeatOutcome: outcome,
+        };
+    }
+    return null;
+}
 const HERMES_ADAPTER_TYPE = "hermes_local";
 const HERMES_SESSION_ID_REGEX = /^(?:\d{8}_\d{6}_[A-Za-z0-9_-]{4,}|[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
 function requiresCanonicalSessionIds(adapterType) {
@@ -3289,11 +3597,70 @@ export function resolveNextSessionState(input) {
         legacySessionId,
     };
 }
+function isTruthyRuntimeEnvValue(value) {
+    return value === "true" || value === "1" || value === "yes" || value === "on";
+}
+export function resolveHeartbeatSchedulingSuppression(env = process.env, overrides = {}) {
+    if (isTruthyRuntimeEnvValue(env.PAPERCLIP_IN_WORKTREE) && !overrides.allowWorktreeRunExecution) {
+        return { suppressed: true, reason: "worktree_instance" };
+    }
+    if (isTruthyRuntimeEnvValue(env.PAPERCLIP_DATABASE_RESTORE_IN_PROGRESS) ||
+        isTruthyRuntimeEnvValue(env.PAPERCLIP_RESTORE_IN_PROGRESS)) {
+        return { suppressed: true, reason: "database_restore_in_progress" };
+    }
+    return { suppressed: false, reason: null };
+}
 export function heartbeatService(db, options = {}) {
     const instanceSettings = instanceSettingsService(db);
     const getCurrentUserRedactionOptions = async () => ({
         enabled: (await instanceSettings.getGeneral()).censorUsernameInLogs,
     });
+    const runtimeEnv = options.runtimeEnv ?? process.env;
+    const inWorktreeRuntime = isTruthyRuntimeEnvValue(runtimeEnv.PAPERCLIP_IN_WORKTREE);
+    // Preview worktree instances suppress the run engine by default. Users can lift
+    // that per-worktree via the `enableWorktreeRunExecution` experimental setting
+    // (worktree instances have their own isolated DB, so it can't affect the parent).
+    // Only worktree runtimes ever read the setting; a short TTL keeps the hot-path
+    // suppression checks off the DB, and a read failure falls back to prior/default
+    // (fail closed to suppression).
+    let cachedWorktreeRunExecutionOverride = {
+        allowed: false,
+        cutoff: null,
+        at: 0,
+    };
+    const WORKTREE_RUN_EXECUTION_OVERRIDE_TTL_MS = 3_000;
+    const resolveWorktreeRunExecutionOverride = async () => {
+        if (!inWorktreeRuntime)
+            return { allowed: false, cutoff: null };
+        const now = Date.now();
+        if (now - cachedWorktreeRunExecutionOverride.at < WORKTREE_RUN_EXECUTION_OVERRIDE_TTL_MS) {
+            return cachedWorktreeRunExecutionOverride;
+        }
+        try {
+            const activation = resolveWorktreeRunExecutionActivation(await instanceSettings.getExperimental(), runtimeEnv.PAPERCLIP_INSTANCE_ID?.trim() || null);
+            const cutoff = activation.armed ? new Date(activation.cutoff) : null;
+            cachedWorktreeRunExecutionOverride = {
+                allowed: Boolean(activation.armed && cutoff && !Number.isNaN(cutoff.getTime())),
+                cutoff: cutoff && !Number.isNaN(cutoff.getTime()) ? cutoff : null,
+                at: now,
+            };
+        }
+        catch {
+            // Keep the prior (default-false) value so a settings read failure fails
+            // closed to the safe suppressed state.
+        }
+        return cachedWorktreeRunExecutionOverride;
+    };
+    const getSchedulingSuppression = async () => {
+        const override = await resolveWorktreeRunExecutionOverride();
+        return resolveHeartbeatSchedulingSuppression(runtimeEnv, {
+            allowWorktreeRunExecution: override.allowed,
+        });
+    };
+    const getWorktreeExecutionCutoff = async () => {
+        const override = await resolveWorktreeRunExecutionOverride();
+        return override.allowed ? override.cutoff : null;
+    };
     const runLogStore = getRunLogStore();
     const secretsSvc = secretService(db);
     const companySkills = companySkillService(db);
@@ -3319,9 +3686,219 @@ export function heartbeatService(db, options = {}) {
     };
     const budgets = budgetService(db, budgetHooks);
     const recovery = recoveryService(db, { enqueueWakeup });
+    function isPlanApprovalConfirmationPayload(payload) {
+        const target = parseObject(parseObject(payload).target);
+        return readNonEmptyString(target.type) === "issue_document" &&
+            readNonEmptyString(target.key) === "plan";
+    }
+    async function getAcceptedPlanApprovalInteractionForRun(run, issueId) {
+        const context = parseObject(run.contextSnapshot);
+        const interactionId = readNonEmptyString(context.interactionId);
+        if (!issueId || !interactionId)
+            return null;
+        const interaction = await db
+            .select({
+            id: issueThreadInteractions.id,
+            kind: issueThreadInteractions.kind,
+            status: issueThreadInteractions.status,
+            payload: issueThreadInteractions.payload,
+            result: issueThreadInteractions.result,
+        })
+            .from(issueThreadInteractions)
+            .where(and(eq(issueThreadInteractions.companyId, run.companyId), eq(issueThreadInteractions.issueId, issueId), eq(issueThreadInteractions.id, interactionId)))
+            .then((rows) => rows[0] ?? null);
+        if (!interaction)
+            return null;
+        if (interaction.kind !== "request_confirmation" || interaction.status !== "accepted")
+            return null;
+        return isPlanApprovalConfirmationPayload(interaction.payload) ? interaction : null;
+    }
+    function planApprovalResumeFailureErrorCode(run) {
+        return readNonEmptyString(run.errorCode) ?? "unknown_error";
+    }
+    function buildPlanApprovalResumeFailureComment(input) {
+        const errorCode = planApprovalResumeFailureErrorCode(input.run);
+        if (input.status === "retrying") {
+            return `Agent failed to resume after approval: \`${errorCode}\` — retrying (attempt ${input.attempt}/${input.maxAttempts})`;
+        }
+        return `Agent failed to resume after approval: \`${errorCode}\` — needs attention`;
+    }
+    function buildPlanApprovalResumeFailureResult(input) {
+        return {
+            status: input.status,
+            errorCode: planApprovalResumeFailureErrorCode(input.run),
+            attempt: input.attempt,
+            maxAttempts: input.maxAttempts,
+            runId: input.run.id,
+            retryRunId: input.retryRunId ?? null,
+            recoveryActionId: input.recoveryActionId ?? null,
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    async function updatePlanApprovalInteractionResumeFailure(input) {
+        const result = parseObject(input.interaction.result);
+        const nextResult = {
+            ...result,
+            version: 1,
+            outcome: "accepted",
+            resumeFailure: input.failure,
+        };
+        await db
+            .update(issueThreadInteractions)
+            .set({
+            result: nextResult,
+            updatedAt: new Date(),
+        })
+            .where(eq(issueThreadInteractions.id, input.interaction.id));
+    }
+    async function addPlanApprovalResumeFailureCommentOnce(input) {
+        const existing = await db
+            .select({ id: issueComments.id })
+            .from(issueComments)
+            .where(and(eq(issueComments.companyId, input.run.companyId), eq(issueComments.issueId, input.issueId), or(eq(issueComments.body, input.body), sql `${issueComments.body} like ${`${input.body}\n%`}`)))
+            .limit(1)
+            .then((rows) => rows[0] ?? null);
+        if (existing)
+            return null;
+        return issuesSvc.addComment(input.issueId, input.body, { runId: input.run.id }, { authorType: "system" });
+    }
+    async function getActiveRecoveryActionId(companyId, sourceIssueId) {
+        return db
+            .select({ id: issueRecoveryActions.id })
+            .from(issueRecoveryActions)
+            .where(and(eq(issueRecoveryActions.companyId, companyId), eq(issueRecoveryActions.sourceIssueId, sourceIssueId), inArray(issueRecoveryActions.status, ["active", "escalated"])))
+            .orderBy(desc(issueRecoveryActions.updatedAt))
+            .limit(1)
+            .then((rows) => rows[0]?.id ?? null);
+    }
+    async function recordPlanApprovalResumeFailureRetry(input) {
+        const interaction = await getAcceptedPlanApprovalInteractionForRun(input.run, input.issueId);
+        if (!interaction || !input.issueId)
+            return null;
+        const body = buildPlanApprovalResumeFailureComment({
+            run: input.run,
+            status: "retrying",
+            attempt: input.attempt,
+            maxAttempts: input.maxAttempts,
+        });
+        await addPlanApprovalResumeFailureCommentOnce({
+            issueId: input.issueId,
+            run: input.run,
+            body,
+        });
+        await updatePlanApprovalInteractionResumeFailure({
+            interaction,
+            failure: buildPlanApprovalResumeFailureResult({
+                run: input.run,
+                status: "retrying",
+                attempt: input.attempt,
+                maxAttempts: input.maxAttempts,
+                retryRunId: input.retryRunId,
+            }),
+        });
+        return interaction.id;
+    }
+    async function escalatePlanApprovalResumeFailureNeedsAttention(input) {
+        const interaction = await getAcceptedPlanApprovalInteractionForRun(input.run, input.issueId);
+        if (!interaction || !input.issueId)
+            return null;
+        const issue = await db
+            .select()
+            .from(issues)
+            .where(and(eq(issues.companyId, input.run.companyId), eq(issues.id, input.issueId)))
+            .then((rows) => rows[0] ?? null);
+        if (!issue)
+            return null;
+        if (issue.status !== "todo" && issue.status !== "in_progress" && issue.status !== "in_review")
+            return null;
+        const body = buildPlanApprovalResumeFailureComment({
+            run: input.run,
+            status: "needs_attention",
+            attempt: input.attempt,
+            maxAttempts: input.maxAttempts,
+        });
+        await recovery.escalateStrandedAssignedIssue({
+            issue,
+            previousStatus: issue.status,
+            latestRun: input.run,
+            comment: body,
+        });
+        await addPlanApprovalResumeFailureCommentOnce({
+            issueId: issue.id,
+            run: input.run,
+            body,
+        });
+        const recoveryActionId = await getActiveRecoveryActionId(issue.companyId, issue.id);
+        await updatePlanApprovalInteractionResumeFailure({
+            interaction,
+            failure: buildPlanApprovalResumeFailureResult({
+                run: input.run,
+                status: "needs_attention",
+                attempt: input.attempt,
+                maxAttempts: input.maxAttempts,
+                recoveryActionId,
+            }),
+        });
+        return interaction.id;
+    }
     const productivityReviews = productivityReviewService(db, { enqueueWakeup });
     const taskWatchdogs = taskWatchdogService(db, { enqueueWakeup });
     let unsafeTextProjectionPromise = null;
+    async function completeSkillTestRunForHeartbeatOutcome(input) {
+        const completion = resolveSkillTestRunCompletionForHeartbeatOutcome(input.outcome, input.error);
+        if (!completion || !input.issueId)
+            return null;
+        let isSkillTestIssue = input.issueWorkMode === "skill_test";
+        if (!isSkillTestIssue && input.issueWorkMode === undefined) {
+            const issueRow = await db
+                .select({
+                workMode: issues.workMode,
+                harnessKind: issues.harnessKind,
+            })
+                .from(issues)
+                .where(and(eq(issues.companyId, input.run.companyId), eq(issues.id, input.issueId)))
+                .then((rows) => rows[0] ?? null);
+            isSkillTestIssue = issueRow?.workMode === "skill_test" || issueRow?.harnessKind === "skill_test";
+        }
+        if (!isSkillTestIssue)
+            return null;
+        const existingRun = await db
+            .select({
+            id: companySkillTestRuns.id,
+            status: companySkillTestRuns.status,
+        })
+            .from(companySkillTestRuns)
+            .where(and(eq(companySkillTestRuns.companyId, input.run.companyId), eq(companySkillTestRuns.issueId, input.issueId)))
+            .then((rows) => rows[0] ?? null);
+        if (!existingRun || ["succeeded", "failed", "cancelled"].includes(existingRun.status))
+            return null;
+        const completedRun = await companySkills.completeTestRunForIssue({
+            companyId: input.run.companyId,
+            issueId: input.issueId,
+            outcome: completion.outcome,
+            error: completion.error,
+        });
+        if (!completedRun)
+            return null;
+        await logActivity(db, {
+            companyId: input.run.companyId,
+            actorType: "system",
+            actorId: "heartbeat_finalize",
+            agentId: input.run.agentId,
+            runId: input.run.id,
+            action: "company.skill_test_run_completed",
+            entityType: "company_skill_test_run",
+            entityId: completedRun.id,
+            details: {
+                issueId: input.issueId,
+                status: completedRun.status,
+                outputDocumentKey: completedRun.outputDocumentKey,
+                heartbeatOutcome: completion.heartbeatOutcome,
+                source: "heartbeat.run_finalized",
+            },
+        });
+        return completedRun;
+    }
     async function releaseEnvironmentLeasesForRun(input) {
         const releaseResult = await envOrchestrator.releaseForRun({
             heartbeatRunId: input.runId,
@@ -3447,7 +4024,11 @@ export function heartbeatService(db, options = {}) {
             assigneeAgentId: issues.assigneeAgentId,
             assigneeAdapterOverrides: issues.assigneeAdapterOverrides,
             executionPolicy: issues.executionPolicy,
+            executionState: issues.executionState,
             executionWorkspaceSettings: issues.executionWorkspaceSettings,
+            parentId: issues.parentId,
+            createdByUserId: issues.createdByUserId,
+            responsibleUserId: issues.responsibleUserId,
             originKind: issues.originKind,
             originId: issues.originId,
             originRunId: issues.originRunId,
@@ -3457,14 +4038,59 @@ export function heartbeatService(db, options = {}) {
             .where(and(eq(issues.id, issueId), eq(issues.companyId, companyId)))
             .then((rows) => rows[0] ?? null);
     }
+    async function getPinnedSkillTestContext(companyId, issueId) {
+        const row = await db
+            .select({
+            testRunId: companySkillTestRuns.id,
+            skillId: companySkillTestRuns.skillId,
+            inputId: companySkillTestRuns.inputId,
+            skillVersionId: companySkillTestRuns.skillVersionId,
+            outputDocumentKey: companySkillTestRuns.outputDocumentKey,
+            fileInventory: companySkillVersions.fileInventory,
+            revisionNumber: companySkillVersions.revisionNumber,
+            label: companySkillVersions.label,
+        })
+            .from(companySkillTestRuns)
+            .innerJoin(companySkillVersions, and(eq(companySkillVersions.id, companySkillTestRuns.skillVersionId), eq(companySkillVersions.companyId, companySkillTestRuns.companyId)))
+            .where(and(eq(companySkillTestRuns.companyId, companyId), eq(companySkillTestRuns.issueId, issueId)))
+            .then((rows) => rows[0] ?? null);
+        if (!row)
+            return null;
+        const fileInventory = Array.isArray(row.fileInventory)
+            ? row.fileInventory.flatMap((entry) => {
+                if (!entry || typeof entry !== "object" || Array.isArray(entry))
+                    return [];
+                const record = entry;
+                const path = typeof record.path === "string" ? record.path : "";
+                if (!path)
+                    return [];
+                return [{
+                        path,
+                        kind: typeof record.kind === "string" ? record.kind : "other",
+                        content: typeof record.content === "string" ? record.content : "",
+                    }];
+            })
+            : [];
+        return {
+            testRunId: row.testRunId,
+            skillId: row.skillId,
+            inputId: row.inputId ?? null,
+            skillVersionId: row.skillVersionId,
+            revisionNumber: row.revisionNumber,
+            label: row.label ?? null,
+            outputDocumentKey: row.outputDocumentKey,
+            fileInventory,
+        };
+    }
     async function getRoutineEnvForExecutionIssue(companyId, issueContext) {
         if (!issueContext || issueContext.originKind !== "routine_execution" || !issueContext.originId) {
-            return { routineId: null, env: null };
+            return { routineId: null, env: null, responsibleUserId: null };
         }
         const routineRun = issueContext.originRunId
             ? await db
                 .select({
                 routineRevisionId: routineRuns.routineRevisionId,
+                responsibleUserId: routineRuns.responsibleUserId,
             })
                 .from(routineRuns)
                 .where(and(eq(routineRuns.id, issueContext.originRunId), eq(routineRuns.companyId, companyId), eq(routineRuns.routineId, issueContext.originId)))
@@ -3474,21 +4100,136 @@ export function heartbeatService(db, options = {}) {
             const revision = await db
                 .select({
                 snapshot: routineRevisions.snapshot,
+                responsibleUserId: routineRevisions.responsibleUserId,
             })
                 .from(routineRevisions)
                 .where(and(eq(routineRevisions.id, routineRun.routineRevisionId), eq(routineRevisions.companyId, companyId), eq(routineRevisions.routineId, issueContext.originId)))
                 .then((rows) => rows[0] ?? null);
             const snapshot = revision?.snapshot;
             if (snapshot?.version === 1) {
-                return { routineId: issueContext.originId, env: snapshot.routine.env ?? null };
+                return {
+                    routineId: issueContext.originId,
+                    env: snapshot.routine.env ?? null,
+                    responsibleUserId: revision?.responsibleUserId ?? snapshot.routine.responsibleUserId ?? null,
+                };
             }
         }
         const routine = await db
-            .select({ env: routines.env })
+            .select({ env: routines.env, responsibleUserId: routines.responsibleUserId })
             .from(routines)
             .where(and(eq(routines.id, issueContext.originId), eq(routines.companyId, companyId)))
             .then((rows) => rows[0] ?? null);
-        return { routineId: issueContext.originId, env: routine?.env ?? null };
+        return {
+            routineId: issueContext.originId,
+            env: routine?.env ?? null,
+            responsibleUserId: routineRun?.responsibleUserId ?? routine?.responsibleUserId ?? null,
+        };
+    }
+    async function resolveCompanyDefaultResponsibleUserId(companyId) {
+        const company = await db
+            .select({ defaultResponsibleUserId: companies.defaultResponsibleUserId })
+            .from(companies)
+            .where(eq(companies.id, companyId))
+            .then((rows) => rows[0] ?? null);
+        const explicitDefault = readNonEmptyString(company?.defaultResponsibleUserId);
+        if (explicitDefault)
+            return explicitDefault;
+        const owner = await db
+            .select({ userId: companyMemberships.principalId })
+            .from(companyMemberships)
+            .where(and(eq(companyMemberships.companyId, companyId), eq(companyMemberships.principalType, "user"), eq(companyMemberships.status, "active"), eq(companyMemberships.membershipRole, "owner")))
+            .orderBy(asc(companyMemberships.createdAt), asc(companyMemberships.id))
+            .limit(1)
+            .then((rows) => rows[0] ?? null);
+        if (owner?.userId)
+            return owner.userId;
+        const firstUser = await db
+            .select({ userId: companyMemberships.principalId })
+            .from(companyMemberships)
+            .where(and(eq(companyMemberships.companyId, companyId), eq(companyMemberships.principalType, "user"), eq(companyMemberships.status, "active")))
+            .orderBy(asc(companyMemberships.createdAt), asc(companyMemberships.id))
+            .limit(1)
+            .then((rows) => rows[0] ?? null);
+        return firstUser?.userId ?? null;
+    }
+    async function resolveParentIssueResponsibleUserId(companyId, parentId) {
+        if (!parentId)
+            return null;
+        const parent = await db
+            .select({
+            responsibleUserId: issues.responsibleUserId,
+            createdByUserId: issues.createdByUserId,
+        })
+            .from(issues)
+            .where(and(eq(issues.companyId, companyId), eq(issues.id, parentId)))
+            .then((rows) => rows[0] ?? null);
+        return parent?.responsibleUserId ?? null;
+    }
+    function isManualUserRun(input) {
+        if (input.requestedByActorType !== "user")
+            return false;
+        const wakeReason = readNonEmptyString(input.contextSnapshot.wakeReason);
+        if (wakeReason && ISSUE_RESPONSIBLE_USER_WAKE_REASONS.has(wakeReason))
+            return false;
+        return input.source === "on_demand" || input.triggerDetail === "manual";
+    }
+    async function resolveResponsibleUserIdForRunSeed(input) {
+        const contextResponsibleUserId = readNonEmptyString(input.contextSnapshot.responsibleUserId);
+        const requestedUserId = input.requestedByActorType === "user"
+            ? readNonEmptyString(input.requestedByActorId)
+            : null;
+        if (contextResponsibleUserId)
+            return contextResponsibleUserId;
+        if (input.existingRunResponsibleUserId)
+            return input.existingRunResponsibleUserId;
+        if (input.routineEnvContext.responsibleUserId)
+            return input.routineEnvContext.responsibleUserId;
+        if (isManualUserRun(input) && requestedUserId)
+            return requestedUserId;
+        if (input.issueContext?.responsibleUserId)
+            return input.issueContext.responsibleUserId;
+        const parentResponsibleUserId = await resolveParentIssueResponsibleUserId(input.companyId, input.issueContext?.parentId);
+        if (parentResponsibleUserId)
+            return parentResponsibleUserId;
+        if (input.issueContext)
+            return resolveCompanyDefaultResponsibleUserId(input.companyId);
+        if (requestedUserId)
+            return requestedUserId;
+        return resolveCompanyDefaultResponsibleUserId(input.companyId);
+    }
+    async function resolveResponsibleUserIdForRun(input) {
+        const responsibleUserId = await resolveResponsibleUserIdForRunSeed({
+            companyId: input.run.companyId,
+            contextSnapshot: input.contextSnapshot,
+            issueContext: input.issueContext,
+            routineEnvContext: input.routineEnvContext,
+            existingRunResponsibleUserId: input.run.responsibleUserId,
+            source: input.run.invocationSource,
+            triggerDetail: input.run.triggerDetail,
+        });
+        if (!responsibleUserId) {
+            throw new HttpError(422, "Unable to resolve responsible user for heartbeat run dispatch", {
+                code: "responsible_user_unresolved",
+                runId: input.run.id,
+                agentId: input.run.agentId,
+                companyId: input.run.companyId,
+                issueId: input.issueContext?.id ?? null,
+                invocationSource: input.run.invocationSource,
+                triggerDetail: input.run.triggerDetail,
+                wakeReason: readNonEmptyString(input.contextSnapshot.wakeReason),
+            });
+        }
+        return responsibleUserId;
+    }
+    async function resolveResponsibleUserIdForRunContext(run, contextSnapshot) {
+        const issueId = readNonEmptyString(contextSnapshot.issueId) ?? readNonEmptyString(contextSnapshot.taskId);
+        const issueContext = issueId ? await getIssueExecutionContext(run.companyId, issueId) : null;
+        return resolveResponsibleUserIdForRun({
+            run,
+            contextSnapshot,
+            issueContext,
+            routineEnvContext: await getRoutineEnvForExecutionIssue(run.companyId, issueContext),
+        });
     }
     async function getRuntimeState(agentId) {
         return db
@@ -3617,7 +4358,7 @@ export function heartbeatService(db, options = {}) {
         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"])))
+            .where(and(eq(issues.companyId, claimed.companyId), eq(issues.originKind, RECOVERY_ORIGIN_KINDS.strandedIssueRecovery), eq(issues.originId, claimed.id), visibleIssueCondition(), notInArray(issues.status, ["done", "cancelled"])))
             .orderBy(desc(issues.createdAt))
             .limit(1)
             .then((rows) => rows[0] ?? null);
@@ -4067,8 +4808,11 @@ export function heartbeatService(db, options = {}) {
             .then((rows) => rows[0] ?? null);
     }
     async function resolveNormalizedUsageForSession(input) {
-        const { agentId, runId, sessionId, rawUsage } = input;
-        if (!sessionId || !rawUsage) {
+        const { agentId, runId, sessionId, rawUsage, usageBasis } = input;
+        // Adapters that declare per-run usage (e.g. the ACPX lane reports each
+        // turn's tokens, not session totals) must not be session-delta'd, or
+        // consecutive runs would be undercounted.
+        if (!sessionId || !rawUsage || usageBasis === "per_run") {
             return {
                 normalizedUsage: rawUsage,
                 previousRawUsage: null,
@@ -4198,6 +4942,27 @@ export function heartbeatService(db, options = {}) {
         const runtimeForRun = await getRuntimeState(agent.id);
         return runtimeForRun?.sessionId ?? null;
     }
+    async function hasResolvableSessionWorkspaceCwd(sessionParams) {
+        const cwd = readNonEmptyString(sessionParams?.cwd);
+        if (!cwd || isUnsafeSessionWorkspaceCwd(cwd))
+            return false;
+        return fs
+            .stat(cwd)
+            .then((stats) => stats.isDirectory())
+            .catch(() => false);
+    }
+    async function hasResolvablePriorSessionWorkspaceForWake(input) {
+        if (await hasResolvableSessionWorkspaceCwd(input.explicitResumeSession?.sessionParams))
+            return true;
+        if (shouldResetTaskSessionForWake(input.contextSnapshot))
+            return false;
+        if (!input.taskKey)
+            return false;
+        const codec = getAdapterSessionCodec(input.agent.adapterType);
+        const taskSession = await getTaskSession(input.agent.companyId, input.agent.id, input.agent.adapterType, input.taskKey);
+        const taskSessionParams = normalizeResumeParamsForAdapter(input.agent.adapterType, codec.deserialize(taskSession?.sessionParamsJson ?? null));
+        return hasResolvableSessionWorkspaceCwd(taskSessionParams);
+    }
     async function resolveExplicitResumeSessionOverride(agent, payload, taskKey) {
         const resumeFromRunId = readNonEmptyString(payload?.resumeFromRunId);
         if (!resumeFromRunId)
@@ -4744,9 +5509,22 @@ export function heartbeatService(db, options = {}) {
         const prefix = issue.identifier?.split("-")[0] || "PAP";
         return `[${label}](/${prefix}/issues/${label})`;
     }
+    function hasUnmanagedBackgroundTaskEvidence(resultJson) {
+        const evidence = parseObject(resultJson?.unmanagedBackgroundTask);
+        return evidence.stopped === true &&
+            (evidence.stopReason === UNMANAGED_BACKGROUND_TASK_STOP_REASON ||
+                evidence.reason === UNMANAGED_BACKGROUND_TASK_LIVENESS_REASON);
+    }
+    function withUnmanagedBackgroundTaskStopReason(resultJson) {
+        return {
+            ...(resultJson ?? {}),
+            stopReason: UNMANAGED_BACKGROUND_TASK_STOP_REASON,
+        };
+    }
     async function buildDetectedSuccessfulRunProgressSummary(run) {
         const resultJson = parseObject(run.resultJson);
         const candidates = [
+            hasUnmanagedBackgroundTaskEvidence(resultJson) ? UNMANAGED_BACKGROUND_TASK_LIVENESS_REASON : null,
             readNonEmptyString(run.nextAction) ? `Next action noted: ${readNonEmptyString(run.nextAction)}` : null,
             readNonEmptyString(run.livenessReason),
             readNonEmptyString(resultJson.summary),
@@ -4791,6 +5569,7 @@ export function heartbeatService(db, options = {}) {
             assigneeAgentId: issues.assigneeAgentId,
             assigneeUserId: issues.assigneeUserId,
             executionState: issues.executionState,
+            monitorNextCheckAt: issues.monitorNextCheckAt,
             projectId: issues.projectId,
         })
             .from(issues)
@@ -4868,7 +5647,7 @@ export function heartbeatService(db, options = {}) {
                     .where(and(eq(issues.companyId, issue.companyId), inArray(issues.originKind, [
                     RECOVERY_ORIGIN_KINDS.strandedIssueRecovery,
                     RECOVERY_ORIGIN_KINDS.issueGraphLivenessEscalation,
-                ]), eq(issues.originId, issue.id), isNull(issues.hiddenAt), notInArray(issues.status, ["done", "cancelled"])))
+                ]), eq(issues.originId, issue.id), visibleIssueCondition(), notInArray(issues.status, ["done", "cancelled"])))
                     .limit(1)
                     .then((rows) => rows[0] ?? null)
                 : Promise.resolve(null),
@@ -4906,6 +5685,7 @@ export function heartbeatService(db, options = {}) {
             hasActiveExecutionPath: Boolean(activeExecutionPath),
             hasQueuedWake: Boolean(queuedWake),
             hasPendingInteractionOrApproval: Boolean(pendingInteraction || pendingApproval),
+            hasPersistedMonitor: Boolean(issue?.monitorNextCheckAt),
             hasExplicitBlockerPath: Boolean(explicitBlocker),
             hasOpenRecoveryIssue: Boolean(openRecoveryIssue),
             hasPauseHold: Boolean(pauseHold),
@@ -4915,6 +5695,16 @@ export function heartbeatService(db, options = {}) {
         });
         if (decision.kind !== "enqueue" || !issue)
             return;
+        if (hasUnmanagedBackgroundTaskEvidence(parseObject(run.resultJson))) {
+            await db
+                .update(heartbeatRuns)
+                .set({
+                livenessReason: UNMANAGED_BACKGROUND_TASK_LIVENESS_REASON,
+                resultJson: withUnmanagedBackgroundTaskStopReason(parseObject(run.resultJson)),
+                updatedAt: new Date(),
+            })
+                .where(eq(heartbeatRuns.id, run.id));
+        }
         const handoffRun = await enqueueWakeup(run.agentId, {
             source: "automation",
             triggerDetail: "system",
@@ -5144,6 +5934,7 @@ export function heartbeatService(db, options = {}) {
             retryReason: "missing_issue_comment",
             missingIssueCommentForRunId: run.id,
         }, "status_only");
+        const responsibleUserId = await resolveResponsibleUserIdForRunContext(run, retryContextSnapshot);
         const now = new Date();
         const retryRun = await db.transaction(async (tx) => {
             await tx.execute(sql `select id from issues where company_id = ${run.companyId} and execution_run_id = ${run.id} for update`);
@@ -5184,6 +5975,7 @@ export function heartbeatService(db, options = {}) {
                 status: "queued",
                 wakeupRequestId: wakeupRequest.id,
                 contextSnapshot: retryContextSnapshot,
+                responsibleUserId,
                 sessionIdBefore: sessionBefore,
                 retryOfRunId: run.id,
                 issueCommentStatus: "not_applicable",
@@ -5319,17 +6111,37 @@ export function heartbeatService(db, options = {}) {
         return { outcome: "retry_exhausted", queuedRun: null };
     }
     async function enqueueProcessLossRetry(run, agent, now) {
-        const invokability = await getAgentInvokability(agent);
-        if (!invokability.invokable) {
+        const existingRetry = await db
+            .select()
+            .from(heartbeatRuns)
+            .where(and(eq(heartbeatRuns.companyId, run.companyId), eq(heartbeatRuns.retryOfRunId, run.id)))
+            .orderBy(asc(heartbeatRuns.createdAt))
+            .limit(1)
+            .then((rows) => rows[0] ?? null);
+        if (existingRetry) {
             await appendRunEvent(run, await nextRunEventSeq(run.id), {
                 eventType: "lifecycle",
                 stream: "system",
                 level: "warn",
-                message: "Process-loss retry suppressed because the agent is not invokable",
+                message: "Process-loss retry already exists; skipping duplicate retry enqueue",
                 payload: {
-                    reason: invokability.reason,
-                    invalidOrgChain: invokability.invalidOrgChain,
-                    ...invokability.details,
+                    retryRunId: existingRetry.id,
+                    retryRunStatus: existingRetry.status,
+                },
+            });
+            return existingRetry;
+        }
+        const invokability = await getAgentInvokability(agent);
+        if (!invokability.invokable) {
+            await appendRunEvent(run, await nextRunEventSeq(run.id), {
+                eventType: "lifecycle",
+                stream: "system",
+                level: "warn",
+                message: "Process-loss retry suppressed because the agent is not invokable",
+                payload: {
+                    reason: invokability.reason,
+                    invalidOrgChain: invokability.invalidOrgChain,
+                    ...invokability.details,
                 },
             });
             await releaseIssueExecutionAndPromote(run);
@@ -5345,6 +6157,7 @@ export function heartbeatService(db, options = {}) {
             wakeReason: "process_lost_retry",
             retryReason: "process_lost",
         }, "normal_model");
+        const responsibleUserId = await resolveResponsibleUserIdForRunContext(run, retryContextSnapshot);
         const queued = await db.transaction(async (tx) => {
             const wakeupRequest = await tx
                 .insert(agentWakeupRequests)
@@ -5375,6 +6188,7 @@ export function heartbeatService(db, options = {}) {
                 status: "queued",
                 wakeupRequestId: wakeupRequest.id,
                 contextSnapshot: retryContextSnapshot,
+                responsibleUserId,
                 sessionIdBefore: sessionBefore,
                 retryOfRunId: run.id,
                 processLossRetryCount: (run.processLossRetryCount ?? 0) + 1,
@@ -5425,6 +6239,95 @@ export function heartbeatService(db, options = {}) {
         });
         return queued;
     }
+    async function drainRunningRunsForShutdown(signal, now = new Date()) {
+        const activeRuns = await db
+            .select({
+            run: heartbeatRuns,
+            agent: agents,
+        })
+            .from(heartbeatRuns)
+            .innerJoin(agents, eq(heartbeatRuns.agentId, agents.id))
+            .where(eq(heartbeatRuns.status, "running"));
+        const interruptedRunIds = [];
+        const retryRunIds = [];
+        for (const { run, agent } of activeRuns) {
+            const running = runningProcesses.get(run.id);
+            try {
+                if (running) {
+                    await terminateHeartbeatRunProcess({
+                        pid: running.child.pid ?? run.processPid,
+                        processGroupId: running.processGroupId ?? run.processGroupId,
+                        graceMs: Math.max(1, running.graceSec) * 1000,
+                    });
+                }
+                else if (run.processPid || run.processGroupId) {
+                    await terminateHeartbeatRunProcess({
+                        pid: run.processPid,
+                        processGroupId: run.processGroupId,
+                    });
+                }
+            }
+            finally {
+                runningProcesses.delete(run.id);
+            }
+            const message = `Interrupted by graceful server shutdown (${signal}); retry queued for restart recovery`;
+            const interruptedStatus = await setRunStatusIfRunning(run.id, "interrupted", {
+                finishedAt: now,
+                error: message,
+                errorCode: "server_shutdown_interrupted",
+                signal,
+                resultJson: mergeRunStopMetadataForAgent(agent, "interrupted", {
+                    resultJson: parseObject(run.resultJson),
+                    errorCode: "server_shutdown_interrupted",
+                    errorMessage: message,
+                }),
+            });
+            if (!interruptedStatus.updated || !interruptedStatus.run)
+                continue;
+            let interrupted = interruptedStatus.run;
+            await setWakeupStatus(run.wakeupRequestId, "cancelled", {
+                finishedAt: now,
+                error: null,
+            });
+            interrupted = await classifyAndPersistRunLiveness(interrupted, parseObject(interrupted.resultJson)) ?? interrupted;
+            await releaseEnvironmentLeasesForRun({
+                runId: interrupted.id,
+                companyId: interrupted.companyId,
+                agentId: interrupted.agentId,
+                status: interrupted.status,
+                failureReason: interrupted.error ?? undefined,
+            });
+            const retry = await enqueueProcessLossRetry(interrupted, agent, now);
+            if (!retry) {
+                await releaseIssueExecutionAndPromote(interrupted);
+            }
+            else {
+                retryRunIds.push(retry.id);
+            }
+            await appendRunEvent(interrupted, await nextRunEventSeq(interrupted.id), {
+                eventType: "lifecycle",
+                stream: "system",
+                level: "warn",
+                message,
+                payload: {
+                    signal,
+                    ...(run.processPid ? { processPid: run.processPid } : {}),
+                    ...(run.processGroupId ? { processGroupId: run.processGroupId } : {}),
+                    ...(retry ? { retryRunId: retry.id } : {}),
+                },
+            });
+            await finalizeAgentStatus(run.agentId, "interrupted", message);
+            interruptedRunIds.push(interrupted.id);
+        }
+        if (interruptedRunIds.length > 0) {
+            logger.warn({ signal, interrupted: interruptedRunIds.length, interruptedRunIds, retryRunIds }, "interrupted running heartbeat runs for graceful shutdown");
+        }
+        return {
+            interrupted: interruptedRunIds.length,
+            interruptedRunIds,
+            retryRunIds,
+        };
+    }
     async function evaluateScheduledRetryGate(input) {
         const { run, agent, contextSnapshot } = input;
         const retryReason = input.retryReason ?? readNonEmptyString(contextSnapshot.retryReason) ?? run.scheduledRetryReason ?? null;
@@ -5716,7 +6619,7 @@ export function heartbeatService(db, options = {}) {
         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 = opts?.delayMs != null
+        const computedBaseSchedule = opts?.delayMs != null
             ? nextAttempt <= maxAttempts
                 ? {
                     attempt: nextAttempt,
@@ -5729,13 +6632,16 @@ export function heartbeatService(db, options = {}) {
             : nextAttempt <= maxAttempts
                 ? computeBoundedTransientHeartbeatRetrySchedule(nextAttempt, now, opts?.random)
                 : null;
+        const baseSchedule = computedBaseSchedule ? { ...computedBaseSchedule, maxAttempts } : null;
         const transientRecovery = retryReason === BOUNDED_TRANSIENT_HEARTBEAT_RETRY_REASON
             ? readTransientRecoveryContractFromRun(run)
             : null;
-        const codexTransientFallbackMode = agent.adapterType === "codex_local" && transientRecovery
+        const codexTransientFallbackMode = agent.adapterType === "codex_local" && transientRecovery?.errorFamily === "transient_upstream"
             ? resolveCodexTransientFallbackMode(nextAttempt)
             : null;
         const transientRetryNotBefore = transientRecovery?.retryNotBefore ?? null;
+        const contextSnapshot = parseObject(run.contextSnapshot);
+        const issueId = readNonEmptyString(contextSnapshot.issueId);
         if (!baseSchedule) {
             await appendRunEvent(run, await nextRunEventSeq(run.id), {
                 eventType: "lifecycle",
@@ -5748,6 +6654,16 @@ export function heartbeatService(db, options = {}) {
                     maxAttempts,
                 },
             });
+            if (retryReason === INTERACTION_CONTINUATION_INFRA_RETRY_REASON) {
+                await escalatePlanApprovalResumeFailureNeedsAttention({
+                    run,
+                    issueId,
+                    attempt: Math.min(run.scheduledRetryAttempt ?? maxAttempts, maxAttempts),
+                    maxAttempts,
+                }).catch((error) => {
+                    logger.warn({ err: error, runId: run.id, issueId }, "failed to escalate exhausted plan-approval resume failure");
+                });
+            }
             return {
                 outcome: "retry_exhausted",
                 attempt: nextAttempt,
@@ -5757,8 +6673,6 @@ export function heartbeatService(db, options = {}) {
         if (retryReason !== MAX_TURN_CONTINUATION_RETRY_REASON) {
             const invokability = await getAgentInvokability(agent);
             if (!invokability.invokable) {
-                const contextSnapshot = parseObject(run.contextSnapshot);
-                const issueId = readNonEmptyString(contextSnapshot.issueId);
                 await appendRunEvent(run, await nextRunEventSeq(run.id), {
                     eventType: "lifecycle",
                     stream: "system",
@@ -5788,10 +6702,16 @@ export function heartbeatService(db, options = {}) {
                 delayMs: Math.max(0, transientRetryNotBefore.getTime() - now.getTime()),
             }
             : 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 });
+        const requiresIssueGate = retryReason === MAX_TURN_CONTINUATION_RETRY_REASON ||
+            retryReason === INTERACTION_CONTINUATION_INFRA_RETRY_REASON;
+        if (requiresIssueGate) {
+            const gate = await evaluateScheduledRetryGate({
+                run,
+                agent,
+                contextSnapshot,
+                retryReason,
+                enforceIssueExecutionLock: retryReason === MAX_TURN_CONTINUATION_RETRY_REASON,
+            });
             if (!gate.allowed) {
                 await appendRunEvent(run, await nextRunEventSeq(run.id), {
                     eventType: "lifecycle",
@@ -5815,21 +6735,90 @@ export function heartbeatService(db, options = {}) {
         }
         const taskKey = deriveTaskKeyWithHeartbeatFallback(contextSnapshot, null);
         const sessionBefore = await resolveSessionBeforeForWakeup(agent, taskKey);
+        const interactionContinuationPayload = retryReason === INTERACTION_CONTINUATION_INFRA_RETRY_REASON
+            ? {
+                mutation: "interaction",
+                interactionId: readNonEmptyString(contextSnapshot.interactionId),
+                interactionKind: readNonEmptyString(contextSnapshot.interactionKind),
+                interactionStatus: readNonEmptyString(contextSnapshot.interactionStatus),
+                continuationPolicy: readNonEmptyString(contextSnapshot.continuationPolicy),
+            }
+            : {};
+        const workspaceValidationRetryPayload = retryReason === INTERACTION_CONTINUATION_INFRA_RETRY_REASON && isWorkspaceValidationFailedRun(run)
+            ? readWorkspaceValidationPayloadFromRun(run)
+            : null;
+        const shouldQuarantineWorkspaceForRetry = workspaceValidationRetryPayload !== null &&
+            Object.keys(workspaceValidationRetryPayload).length > 0;
         const retryContextSnapshot = withRecoveryModelProfileHint({
             ...contextSnapshot,
             retryOfRunId: run.id,
             wakeReason,
             retryReason,
+            ...(shouldQuarantineWorkspaceForRetry
+                ? {
+                    workspaceValidationRecovery: {
+                        strategy: "quarantine_failed_workspace_and_retry_clean",
+                        sourceRunId: run.id,
+                        reason: readNonEmptyString(workspaceValidationRetryPayload?.reason) ?? WORKSPACE_VALIDATION_FAILURE_CODE,
+                        fingerprint: readNonEmptyString(workspaceValidationRetryPayload?.fingerprint),
+                        failedExecutionWorkspaceId: readNonEmptyString(workspaceValidationRetryPayload?.executionWorkspaceId),
+                    },
+                }
+                : {}),
             ...(transientRecovery ? { errorFamily: transientRecovery.errorFamily } : {}),
             scheduledRetryAttempt: schedule.attempt,
             scheduledRetryAt: schedule.dueAt.toISOString(),
             ...(transientRetryNotBefore ? { transientRetryNotBefore: transientRetryNotBefore.toISOString() } : {}),
+            ...(transientRecovery?.errorFamily === "provider_quota" && transientRetryNotBefore
+                ? { providerQuotaRetryNotBefore: transientRetryNotBefore.toISOString() }
+                : {}),
             ...(codexTransientFallbackMode ? { codexTransientFallbackMode } : {}),
         }, "normal_model");
-        const maxTurnContinuationIdempotencyKey = retryReason === MAX_TURN_CONTINUATION_RETRY_REASON
+        const responsibleUserId = await resolveResponsibleUserIdForRunContext(run, retryContextSnapshot);
+        const continuationRetryIdempotencyKey = retryReason === MAX_TURN_CONTINUATION_RETRY_REASON
             ? `max-turn-continuation:${run.companyId}:${issueId ?? "no-issue"}:${run.id}:${schedule.attempt}`
-            : null;
+            : retryReason === INTERACTION_CONTINUATION_INFRA_RETRY_REASON
+                ? `interaction-continuation:${run.companyId}:${issueId ?? "no-issue"}:${run.id}:${schedule.attempt}`
+                : null;
         const scheduleResult = await db.transaction(async (tx) => {
+            if (retryReason === INTERACTION_CONTINUATION_INFRA_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 (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`);
@@ -5944,17 +6933,21 @@ export function heartbeatService(db, options = {}) {
                 payload: withRecoveryModelProfileHint({
                     ...(issueId ? { issueId } : {}),
                     retryOfRunId: run.id,
+                    ...interactionContinuationPayload,
                     retryReason,
                     ...(transientRecovery ? { errorFamily: transientRecovery.errorFamily } : {}),
                     scheduledRetryAttempt: schedule.attempt,
                     scheduledRetryAt: schedule.dueAt.toISOString(),
                     ...(transientRetryNotBefore ? { transientRetryNotBefore: transientRetryNotBefore.toISOString() } : {}),
+                    ...(transientRecovery?.errorFamily === "provider_quota" && transientRetryNotBefore
+                        ? { providerQuotaRetryNotBefore: transientRetryNotBefore.toISOString() }
+                        : {}),
                     ...(codexTransientFallbackMode ? { codexTransientFallbackMode } : {}),
                 }, "normal_model"),
                 status: "queued",
                 requestedByActorType: "system",
                 requestedByActorId: null,
-                idempotencyKey: maxTurnContinuationIdempotencyKey,
+                idempotencyKey: continuationRetryIdempotencyKey,
                 updatedAt: now,
             })
                 .returning()
@@ -5969,6 +6962,7 @@ export function heartbeatService(db, options = {}) {
                 status: "scheduled_retry",
                 wakeupRequestId: wakeupRequest.id,
                 contextSnapshot: retryContextSnapshot,
+                responsibleUserId,
                 sessionIdBefore: sessionBefore,
                 retryOfRunId: run.id,
                 scheduledRetryAt: schedule.dueAt,
@@ -5986,6 +6980,79 @@ export function heartbeatService(db, options = {}) {
                 updatedAt: now,
             })
                 .where(eq(agentWakeupRequests.id, wakeupRequest.id));
+            let detachWorkspaceFromIssue = false;
+            if (issueId && shouldQuarantineWorkspaceForRetry) {
+                const issueWorkspace = await tx
+                    .select({
+                    id: issues.id,
+                    companyId: issues.companyId,
+                    executionWorkspaceId: issues.executionWorkspaceId,
+                })
+                    .from(issues)
+                    .where(and(eq(issues.id, issueId), eq(issues.companyId, run.companyId)))
+                    .for("update")
+                    .then((rows) => rows[0] ?? null);
+                const failedExecutionWorkspaceId = readNonEmptyString(workspaceValidationRetryPayload?.executionWorkspaceId) ??
+                    readNonEmptyString(issueWorkspace?.executionWorkspaceId);
+                if (issueWorkspace && failedExecutionWorkspaceId) {
+                    const failedWorkspace = await tx
+                        .select({
+                        id: executionWorkspaces.id,
+                        companyId: executionWorkspaces.companyId,
+                        sourceIssueId: executionWorkspaces.sourceIssueId,
+                        status: executionWorkspaces.status,
+                        metadata: executionWorkspaces.metadata,
+                    })
+                        .from(executionWorkspaces)
+                        .where(and(eq(executionWorkspaces.id, failedExecutionWorkspaceId), eq(executionWorkspaces.companyId, run.companyId)))
+                        .for("update")
+                        .then((rows) => rows[0] ?? null);
+                    const workspaceBelongsToIssue = failedWorkspace
+                        ? failedWorkspace.sourceIssueId === issueId
+                        : false;
+                    if (failedWorkspace &&
+                        workspaceBelongsToIssue &&
+                        issueWorkspace.executionWorkspaceId === failedExecutionWorkspaceId) {
+                        const existingMetadata = parseObject(failedWorkspace.metadata);
+                        const quarantine = {
+                            reason: WORKSPACE_VALIDATION_FAILURE_CODE,
+                            retryReason,
+                            sourceRunId: run.id,
+                            retryRunId: scheduledRun.id,
+                            issueId,
+                            sourceIssueId: failedWorkspace.sourceIssueId ?? null,
+                            quarantinedAt: now.toISOString(),
+                            workspaceValidation: workspaceValidationRetryPayload ?? {},
+                        };
+                        await tx
+                            .update(executionWorkspaces)
+                            .set({
+                            status: "archived",
+                            closedAt: now,
+                            cleanupEligibleAt: null,
+                            cleanupReason: WORKSPACE_VALIDATION_FAILURE_CODE,
+                            metadata: {
+                                ...existingMetadata,
+                                workspaceValidationQuarantine: quarantine,
+                            },
+                            updatedAt: now,
+                        })
+                            .where(and(eq(executionWorkspaces.id, failedWorkspace.id), eq(executionWorkspaces.companyId, run.companyId)));
+                        await logActivity(tx, {
+                            companyId: run.companyId,
+                            actorType: "system",
+                            actorId: "heartbeat",
+                            agentId: run.agentId,
+                            runId: run.id,
+                            action: "execution_workspace.workspace_validation_quarantined",
+                            entityType: "execution_workspace",
+                            entityId: failedWorkspace.id,
+                            details: quarantine,
+                        });
+                        detachWorkspaceFromIssue = issueWorkspace.executionWorkspaceId === failedExecutionWorkspaceId;
+                    }
+                }
+            }
             if (issueId) {
                 await tx
                     .update(issues)
@@ -5993,6 +7060,12 @@ export function heartbeatService(db, options = {}) {
                     executionRunId: scheduledRun.id,
                     executionAgentNameKey: normalizeAgentNameKey(agent.name),
                     executionLockedAt: now,
+                    ...(detachWorkspaceFromIssue
+                        ? {
+                            executionWorkspaceId: null,
+                            executionWorkspacePreference: null,
+                        }
+                        : {}),
                     updatedAt: now,
                 })
                     .where(and(eq(issues.id, issueId), eq(issues.companyId, run.companyId), eq(issues.executionRunId, run.id)));
@@ -6030,11 +7103,11 @@ export function heartbeatService(db, options = {}) {
                 eventType: "lifecycle",
                 stream: "system",
                 level: "info",
-                message: `Reused existing max-turn continuation ${retryRun.scheduledRetryAttempt}/${schedule.maxAttempts}`,
+                message: `Reused existing continuation retry ${retryRun.scheduledRetryAttempt}/${schedule.maxAttempts}`,
                 payload: {
                     retryRunId: retryRun.id,
                     retryReason,
-                    idempotencyKey: maxTurnContinuationIdempotencyKey,
+                    idempotencyKey: continuationRetryIdempotencyKey,
                     scheduledRetryAttempt: retryRun.scheduledRetryAttempt,
                     scheduledRetryAt: dueAt.toISOString(),
                 },
@@ -6062,9 +7135,23 @@ export function heartbeatService(db, options = {}) {
                 baseDelayMs: schedule.baseDelayMs,
                 delayMs: schedule.delayMs,
                 ...(transientRetryNotBefore ? { transientRetryNotBefore: transientRetryNotBefore.toISOString() } : {}),
+                ...(transientRecovery?.errorFamily === "provider_quota" && transientRetryNotBefore
+                    ? { providerQuotaRetryNotBefore: transientRetryNotBefore.toISOString() }
+                    : {}),
                 ...(codexTransientFallbackMode ? { codexTransientFallbackMode } : {}),
             },
         });
+        if (retryReason === INTERACTION_CONTINUATION_INFRA_RETRY_REASON) {
+            await recordPlanApprovalResumeFailureRetry({
+                run,
+                issueId,
+                retryRunId: retryRun.id,
+                attempt: schedule.attempt,
+                maxAttempts: schedule.maxAttempts,
+            }).catch((error) => {
+                logger.warn({ err: error, runId: run.id, issueId, retryRunId: retryRun.id }, "failed to record plan-approval resume retry failure");
+            });
+        }
         return {
             outcome: "scheduled",
             run: retryRun,
@@ -6073,11 +7160,36 @@ export function heartbeatService(db, options = {}) {
             maxAttempts: schedule.maxAttempts,
         };
     }
+    async function scheduleInteractionContinuationInfrastructureRetryIfEligible(run, agent) {
+        if (!run.wakeupRequestId)
+            return null;
+        if (!isResolvedInteractionContinuationWakeContext(run.contextSnapshot))
+            return null;
+        if (!isRetryableInteractionContinuationInfrastructureFailure(run)) {
+            const context = parseObject(run.contextSnapshot);
+            const issueId = readNonEmptyString(context.issueId);
+            await escalatePlanApprovalResumeFailureNeedsAttention({
+                run,
+                issueId,
+                attempt: Math.min(run.scheduledRetryAttempt ?? INTERACTION_CONTINUATION_INFRA_MAX_ATTEMPTS, INTERACTION_CONTINUATION_INFRA_MAX_ATTEMPTS),
+                maxAttempts: INTERACTION_CONTINUATION_INFRA_MAX_ATTEMPTS,
+            }).catch((error) => {
+                logger.warn({ err: error, runId: run.id, issueId }, "failed to escalate non-retryable plan-approval resume failure");
+            });
+            return null;
+        }
+        return scheduleBoundedRetryForRun(run, agent, {
+            retryReason: INTERACTION_CONTINUATION_INFRA_RETRY_REASON,
+            wakeReason: INTERACTION_CONTINUATION_INFRA_WAKE_REASON,
+            maxAttempts: INTERACTION_CONTINUATION_INFRA_MAX_ATTEMPTS,
+        });
+    }
     async function promoteDueScheduledRetries(now = new Date()) {
+        const cutoff = await getWorktreeExecutionCutoff();
         const dueRuns = await db
             .select()
             .from(heartbeatRuns)
-            .where(and(eq(heartbeatRuns.status, "scheduled_retry"), lte(heartbeatRuns.scheduledRetryAt, now)))
+            .where(and(eq(heartbeatRuns.status, "scheduled_retry"), lte(heartbeatRuns.scheduledRetryAt, now), cutoff ? gte(heartbeatRuns.createdAt, cutoff) : undefined))
             .orderBy(asc(heartbeatRuns.scheduledRetryAt), asc(heartbeatRuns.createdAt), asc(heartbeatRuns.id))
             .limit(50);
         const promotedRunIds = [];
@@ -6494,10 +7606,17 @@ export function heartbeatService(db, options = {}) {
             }
         }
         const claimedAt = new Date();
+        const responsibleUserId = await resolveResponsibleUserIdForRun({
+            run,
+            contextSnapshot: context,
+            issueContext: issueId ? await getIssueExecutionContext(run.companyId, issueId) : null,
+            routineEnvContext: { routineId: null, env: null, responsibleUserId: null },
+        });
         const claimed = await db
             .update(heartbeatRuns)
             .set({
             status: "running",
+            responsibleUserId,
             startedAt: run.startedAt ?? claimedAt,
             updatedAt: claimedAt,
         })
@@ -6747,7 +7866,7 @@ export function heartbeatService(db, options = {}) {
             return null;
         return trimmed.length > 500 ? `${trimmed.slice(0, 499)}…` : trimmed;
     }
-    async function finalizeAgentStatus(agentId, outcome, failureReason) {
+    async function finalizeAgentStatus(agentId, outcome, failureReason, options) {
         const existing = await getAgent(agentId);
         if (!existing)
             return;
@@ -6758,7 +7877,7 @@ export function heartbeatService(db, options = {}) {
         const runningCount = await countRunningRunsForAgent(agentId);
         const nextStatus = runningCount > 0
             ? "running"
-            : outcome === "succeeded" || outcome === "cancelled"
+            : outcome === "succeeded" || outcome === "interrupted" || outcome === "cancelled" || (outcome === "failed" && options?.keepIdleOnFailure)
                 ? "idle"
                 : "error";
         const updated = await db
@@ -7002,15 +8121,34 @@ export function heartbeatService(db, options = {}) {
             }
             const shouldRetry = tracksLocalChild && (!!run.processPid || !!run.processGroupId) && (run.processLossRetryCount ?? 0) < 1;
             const baseMessage = buildProcessLossMessage(run, descendantOnlyCleanup ? { descendantOnly: true } : undefined);
+            const unmanagedBackgroundTaskEvidence = descendantOnlyCleanup
+                ? {
+                    kind: "orphaned_process_group_cleanup",
+                    stopped: true,
+                    stopReason: UNMANAGED_BACKGROUND_TASK_STOP_REASON,
+                    reason: UNMANAGED_BACKGROUND_TASK_LIVENESS_REASON,
+                    processPid: run.processPid ?? null,
+                    processGroupId: run.processGroupId ?? null,
+                }
+                : null;
             let finalizedRun = await setRunStatus(run.id, "failed", {
                 error: shouldRetry ? `${baseMessage}; retrying once` : baseMessage,
                 errorCode: "process_lost",
                 finishedAt: now,
-                resultJson: mergeRunStopMetadataForAgent({ adapterType, adapterConfig }, "failed", {
-                    resultJson: parseObject(run.resultJson),
-                    errorCode: "process_lost",
-                    errorMessage: shouldRetry ? `${baseMessage}; retrying once` : baseMessage,
-                }),
+                resultJson: (() => {
+                    const result = mergeRunStopMetadataForAgent({ adapterType, adapterConfig }, "failed", {
+                        resultJson: parseObject(run.resultJson),
+                        errorCode: "process_lost",
+                        errorMessage: shouldRetry ? `${baseMessage}; retrying once` : baseMessage,
+                    });
+                    return unmanagedBackgroundTaskEvidence
+                        ? {
+                            ...result,
+                            stopReason: UNMANAGED_BACKGROUND_TASK_STOP_REASON,
+                            unmanagedBackgroundTask: unmanagedBackgroundTaskEvidence,
+                        }
+                        : result;
+                })(),
             });
             await setWakeupStatus(run.wakeupRequestId, "failed", {
                 finishedAt: now,
@@ -7029,13 +8167,17 @@ export function heartbeatService(db, options = {}) {
                 failureReason: finalizedRun.error ?? undefined,
             });
             let retriedRun = null;
+            const retryAgent = await getAgent(run.agentId);
             if (shouldRetry) {
-                const agent = await getAgent(run.agentId);
-                if (agent) {
-                    retriedRun = await enqueueProcessLossRetry(finalizedRun, agent, now);
+                if (retryAgent) {
+                    retriedRun = await enqueueProcessLossRetry(finalizedRun, retryAgent, now);
                 }
             }
-            else {
+            else if (retryAgent) {
+                const scheduled = await scheduleInteractionContinuationInfrastructureRetryIfEligible(finalizedRun, retryAgent);
+                retriedRun = scheduled?.outcome === "scheduled" ? scheduled.run : null;
+            }
+            if (!retriedRun) {
                 await releaseIssueExecutionAndPromote(finalizedRun);
             }
             await appendRunEvent(finalizedRun, await nextRunEventSeq(finalizedRun.id), {
@@ -7063,18 +8205,21 @@ export function heartbeatService(db, options = {}) {
         return { reaped: reaped.length, runIds: reaped };
     }
     async function resumeQueuedRuns() {
+        if ((await getSchedulingSuppression()).suppressed)
+            return;
+        const cutoff = await getWorktreeExecutionCutoff();
         const queuedRuns = await db
             .select({ agentId: heartbeatRuns.agentId })
             .from(heartbeatRuns)
             .innerJoin(companies, eq(companies.id, heartbeatRuns.companyId))
-            .where(and(eq(heartbeatRuns.status, "queued"), eq(companies.status, "active")));
+            .where(and(eq(heartbeatRuns.status, "queued"), eq(companies.status, "active"), cutoff ? gte(heartbeatRuns.createdAt, cutoff) : undefined));
         const agentIds = [...new Set(queuedRuns.map((r) => r.agentId))];
         for (const agentId of agentIds) {
             await startNextQueuedRunForAgent(agentId);
         }
     }
     async function reconcileStrandedAssignedIssues() {
-        return recovery.reconcileStrandedAssignedIssues();
+        return recovery.reconcileStrandedAssignedIssues({ issueCreatedAtGte: await getWorktreeExecutionCutoff() });
     }
     async function sweepStaleIssueLocks() {
         return recovery.sweepStaleIssueLocks();
@@ -7091,13 +8236,13 @@ export function heartbeatService(db, options = {}) {
             readNonEmptyString(nestedContext.taskId);
     }
     async function scanSilentActiveRuns(opts) {
-        return recovery.scanSilentActiveRuns(opts);
+        return recovery.scanSilentActiveRuns({ ...opts, issueCreatedAtGte: await getWorktreeExecutionCutoff() });
     }
     async function reconcileProductivityReviews(opts) {
-        return productivityReviews.reconcileProductivityReviews(opts);
+        return productivityReviews.reconcileProductivityReviews({ ...opts, issueCreatedAtGte: await getWorktreeExecutionCutoff() });
     }
     async function reconcileTaskWatchdogs(opts) {
-        return taskWatchdogs.reconcileTaskWatchdogs(opts);
+        return taskWatchdogs.reconcileTaskWatchdogs({ ...opts, issueCreatedAtGte: await getWorktreeExecutionCutoff() });
     }
     async function buildRunOutputSilence(run, now = new Date()) {
         return recovery.buildRunOutputSilence(run, now);
@@ -7106,7 +8251,7 @@ export function heartbeatService(db, options = {}) {
         return recovery.buildIssueGraphLivenessAutoRecoveryPreview(opts);
     }
     async function reconcileIssueGraphLiveness(opts) {
-        return recovery.reconcileIssueGraphLiveness(opts);
+        return recovery.reconcileIssueGraphLiveness({ ...opts, issueCreatedAtGte: await getWorktreeExecutionCutoff() });
     }
     async function updateRuntimeState(agent, run, result, session, normalizedUsage) {
         await ensureRuntimeState(agent);
@@ -7117,6 +8262,12 @@ export function heartbeatService(db, options = {}) {
         const billingType = normalizeLedgerBillingType(result.billingType);
         const additionalCostCents = normalizeBilledCostCents(result.costUsd, billingType);
         const hasTokenUsage = inputTokens > 0 || outputTokens > 0 || cachedInputTokens > 0;
+        const costStatus = resolveLedgerCostStatus({
+            costUsd: result.costUsd,
+            inputTokens,
+            cachedInputTokens,
+            outputTokens,
+        });
         const provider = result.provider ?? "unknown";
         const biller = resolveLedgerBiller(result);
         const ledgerScope = await resolveLedgerScopeForRun(db, agent.companyId, run);
@@ -7145,6 +8296,7 @@ export function heartbeatService(db, options = {}) {
                 provider,
                 biller,
                 billingType,
+                costStatus,
                 model: result.model ?? "unknown",
                 inputTokens,
                 cachedInputTokens,
@@ -7155,6 +8307,9 @@ export function heartbeatService(db, options = {}) {
         }
     }
     async function startNextQueuedRunForAgent(agentId) {
+        if ((await getSchedulingSuppression()).suppressed)
+            return [];
+        const cutoff = await getWorktreeExecutionCutoff();
         return withAgentStartLock(agentId, async () => {
             const agent = await getAgent(agentId);
             if (!agent)
@@ -7174,7 +8329,7 @@ export function heartbeatService(db, options = {}) {
             const queuedRuns = await db
                 .select()
                 .from(heartbeatRuns)
-                .where(and(eq(heartbeatRuns.agentId, agentId), eq(heartbeatRuns.status, "queued")))
+                .where(and(eq(heartbeatRuns.agentId, agentId), eq(heartbeatRuns.status, "queued"), cutoff ? gte(heartbeatRuns.createdAt, cutoff) : undefined))
                 .orderBy(asc(heartbeatRuns.createdAt));
             if (queuedRuns.length === 0)
                 return [];
@@ -7232,6 +8387,8 @@ export function heartbeatService(db, options = {}) {
         });
     }
     async function executeRun(runId) {
+        if ((await getSchedulingSuppression()).suppressed)
+            return;
         let run = await getRun(runId);
         if (!run)
             return;
@@ -7246,6 +8403,7 @@ export function heartbeatService(db, options = {}) {
             run = claimed;
         }
         activeRunExecutions.add(run.id);
+        let runScratch = null;
         try {
             const agent = await getAgent(run.agentId);
             if (!agent) {
@@ -7282,6 +8440,7 @@ export function heartbeatService(db, options = {}) {
                     contextSnapshot: context,
                     issueStatus: issueContext.status,
                     issueAssigneeAgentId: issueContext.assigneeAgentId,
+                    issueExecutionState: issueContext.executionState,
                     isDependencyReady: issueDependencyReadiness?.isDependencyReady ?? true,
                     agentId: agent.id,
                 })) {
@@ -7382,6 +8541,26 @@ export function heartbeatService(db, options = {}) {
                 delete context.acceptedPlanWakeRouting;
             }
             const routineEnvContext = await getRoutineEnvForExecutionIssue(agent.companyId, issueContext);
+            const responsibleUserId = await resolveResponsibleUserIdForRun({
+                run,
+                contextSnapshot: context,
+                issueContext,
+                routineEnvContext,
+            });
+            if (responsibleUserId && run.responsibleUserId !== responsibleUserId) {
+                await db
+                    .update(heartbeatRuns)
+                    .set({ responsibleUserId, updatedAt: new Date() })
+                    .where(eq(heartbeatRuns.id, run.id));
+                run = { ...run, responsibleUserId };
+            }
+            if (responsibleUserId && issueContext && !issueContext.responsibleUserId) {
+                await db
+                    .update(issues)
+                    .set({ responsibleUserId, updatedAt: new Date() })
+                    .where(and(eq(issues.companyId, agent.companyId), eq(issues.id, issueContext.id), isNull(issues.responsibleUserId)));
+                issueContext = { ...issueContext, responsibleUserId };
+            }
             const projectExecutionWorkspacePolicy = gateProjectExecutionWorkspacePolicy(parseProjectExecutionWorkspacePolicy(projectContext?.executionWorkspacePolicy), isolatedWorkspacesEnabled);
             const trustPreset = resolveCoreTrustPreset({
                 companyId: agent.companyId,
@@ -7459,6 +8638,18 @@ export function heartbeatService(db, options = {}) {
             else {
                 delete context.paperclipContinuationSummary;
             }
+            const pinnedSkillTestContext = issueRef?.workMode === "skill_test"
+                ? await getPinnedSkillTestContext(agent.companyId, issueRef.id)
+                : null;
+            if (pinnedSkillTestContext) {
+                context.paperclipSkillTest = {
+                    ...pinnedSkillTestContext,
+                    directive: "Use this pinned file inventory as the exact skill revision under test, regardless of synced runtime skills.",
+                };
+            }
+            else {
+                delete context.paperclipSkillTest;
+            }
             const paperclipWakePayload = await buildPaperclipWakePayload({
                 db,
                 companyId: agent.companyId,
@@ -7527,15 +8718,20 @@ export function heartbeatService(db, options = {}) {
             else {
                 delete context.paperclipTaskMarkdown;
             }
-            const existingExecutionWorkspace = issueRef?.executionWorkspaceId ? await executionWorkspacesSvc.getById(issueRef.executionWorkspaceId) : null;
-            const requestedShouldReuseExisting = issueRef?.executionWorkspacePreference === "reuse_existing" &&
-                existingExecutionWorkspace !== null &&
-                existingExecutionWorkspace.status !== "archived";
-            const requestedReusableExecutionWorkspaceConfig = requestedShouldReuseExisting
-                ? existingExecutionWorkspace?.config ?? null
+            const requestedExecutionWorkspaceId = readNonEmptyString(issueRef?.executionWorkspaceId);
+            const existingExecutionWorkspace = requestedExecutionWorkspaceId ? await executionWorkspacesSvc.getById(requestedExecutionWorkspaceId) : null;
+            const workspaceReuseRequest = resolveExecutionWorkspaceReuseRequestForIssue({
+                issueExecutionWorkspaceId: requestedExecutionWorkspaceId,
+                issueExecutionWorkspacePreference: issueRef?.executionWorkspacePreference ?? null,
+                existingExecutionWorkspaceStatus: existingExecutionWorkspace?.status ?? null,
+            });
+            const requestedShouldReuseExisting = workspaceReuseRequest.requestedShouldReuseExisting;
+            const reusableExistingExecutionWorkspace = workspaceReuseRequest.existingExecutionWorkspaceAvailable
+                ? existingExecutionWorkspace
                 : null;
-            const persistedExecutionWorkspaceMode = requestedShouldReuseExisting && existingExecutionWorkspace
-                ? issueExecutionWorkspaceModeForPersistedWorkspace(existingExecutionWorkspace.mode)
+            const requestedReusableExecutionWorkspaceConfig = reusableExistingExecutionWorkspace?.config ?? null;
+            const persistedExecutionWorkspaceMode = requestedShouldReuseExisting && reusableExistingExecutionWorkspace
+                ? issueExecutionWorkspaceModeForPersistedWorkspace(reusableExistingExecutionWorkspace.mode)
                 : null;
             const localEnvironment = await environmentsSvc.ensureLocalEnvironment(agent.companyId);
             const resolvedInstanceSettings = await instanceSettings.get();
@@ -7674,6 +8870,7 @@ export function heartbeatService(db, options = {}) {
                 environmentEnv: selectedEnvironmentForConfig?.envVars ?? null,
                 projectId: projectContext?.id ?? null,
                 routineId: routineEnvContext.routineId,
+                responsibleUserId,
                 executionRunConfig,
                 projectEnv: projectContext?.env ?? null,
                 routineEnv: routineEnvContext.env,
@@ -7724,16 +8921,16 @@ export function heartbeatService(db, options = {}) {
                     projectPolicy: projectExecutionWorkspacePolicy,
                     issueSettings: issueExecutionWorkspaceSettings,
                     reusableExecutionWorkspaceConfig: requestedReusableExecutionWorkspaceConfig,
-                    existingExecutionWorkspace: existingExecutionWorkspace
+                    existingExecutionWorkspace: reusableExistingExecutionWorkspace
                         ? {
-                            id: existingExecutionWorkspace.id,
-                            mode: existingExecutionWorkspace.mode,
-                            strategyType: existingExecutionWorkspace.strategyType,
-                            projectWorkspaceId: existingExecutionWorkspace.projectWorkspaceId,
-                            repoUrl: existingExecutionWorkspace.repoUrl,
-                            baseRef: existingExecutionWorkspace.baseRef,
-                            branchName: existingExecutionWorkspace.branchName,
-                            config: existingExecutionWorkspace.config,
+                            id: reusableExistingExecutionWorkspace.id,
+                            mode: reusableExistingExecutionWorkspace.mode,
+                            strategyType: reusableExistingExecutionWorkspace.strategyType,
+                            projectWorkspaceId: reusableExistingExecutionWorkspace.projectWorkspaceId,
+                            repoUrl: reusableExistingExecutionWorkspace.repoUrl,
+                            baseRef: reusableExistingExecutionWorkspace.baseRef,
+                            branchName: reusableExistingExecutionWorkspace.branchName,
+                            config: reusableExistingExecutionWorkspace.config,
                         }
                         : null,
                 },
@@ -7818,15 +9015,15 @@ export function heartbeatService(db, options = {}) {
                 repoUrl: resolvedWorkspace.repoUrl,
                 repoRef: resolvedWorkspace.repoRef,
             };
+            await assertGitWorktreeBaseWorkspaceReady({
+                requestedExecutionWorkspaceMode,
+                config: hostExecutionWorkspaceConfig,
+                issue: issueRef,
+                base: executionWorkspaceBase,
+            });
             const workspaceStrategyForFingerprint = parseObject(hostExecutionWorkspaceConfig.workspaceStrategy);
             const workspaceStrategyFingerprintValue = Object.keys(workspaceStrategyForFingerprint).length > 0 ? workspaceStrategyForFingerprint : null;
-            const latestWorkspaceStrategyType = readNonEmptyString(workspaceStrategyForFingerprint.type) ??
-                (requestedExecutionWorkspaceMode === "agent_default"
-                    ? "adapter_managed"
-                    : requestedExecutionWorkspaceMode === "isolated_workspace" ||
-                        requestedExecutionWorkspaceMode === "operator_branch"
-                        ? "git_worktree"
-                        : "project_primary");
+            const latestWorkspaceStrategyType = resolveEffectiveWorkspaceStrategyType(requestedExecutionWorkspaceMode, hostExecutionWorkspaceConfig);
             const selectedEnvironmentConfigForFingerprint = parseObject(selectedEnvironmentForConfig?.config);
             const workspaceEnvironmentFingerprint = selectedEnvironmentForConfig
                 ? {
@@ -7860,24 +9057,24 @@ export function heartbeatService(db, options = {}) {
                 realization: workspaceRealizationFingerprint,
                 secretManifest,
             });
-            const inferredExistingWorkspaceConfigMetadata = existingExecutionWorkspace
+            const inferredExistingWorkspaceConfigMetadata = reusableExistingExecutionWorkspace
                 ? buildEffectiveRunWorkspaceConfigMetadata({
-                    mode: issueExecutionWorkspaceModeForPersistedWorkspace(existingExecutionWorkspace.mode),
-                    projectId: existingExecutionWorkspace.projectId,
-                    projectWorkspaceId: existingExecutionWorkspace.projectWorkspaceId,
-                    strategyType: existingExecutionWorkspace.strategyType,
+                    mode: issueExecutionWorkspaceModeForPersistedWorkspace(reusableExistingExecutionWorkspace.mode),
+                    projectId: reusableExistingExecutionWorkspace.projectId,
+                    projectWorkspaceId: reusableExistingExecutionWorkspace.projectWorkspaceId,
+                    strategyType: reusableExistingExecutionWorkspace.strategyType,
                     workspaceStrategy: workspaceStrategyFingerprintValue
                         ? {
                             ...workspaceStrategyFingerprintValue,
-                            type: existingExecutionWorkspace.strategyType,
-                            ...(existingExecutionWorkspace.baseRef
-                                ? { baseRef: existingExecutionWorkspace.baseRef }
+                            type: reusableExistingExecutionWorkspace.strategyType,
+                            ...(reusableExistingExecutionWorkspace.baseRef
+                                ? { baseRef: reusableExistingExecutionWorkspace.baseRef }
                                 : {}),
                         }
-                        : { type: existingExecutionWorkspace.strategyType },
-                    repoUrl: existingExecutionWorkspace.repoUrl,
-                    repoRef: existingExecutionWorkspace.baseRef,
-                    configSnapshot: existingExecutionWorkspace.config,
+                        : { type: reusableExistingExecutionWorkspace.strategyType },
+                    repoUrl: reusableExistingExecutionWorkspace.repoUrl,
+                    repoRef: reusableExistingExecutionWorkspace.baseRef,
+                    configSnapshot: reusableExistingExecutionWorkspace.config,
                     environment: workspaceEnvironmentFingerprint,
                     realization: workspaceRealizationFingerprint,
                     secretManifest,
@@ -7885,82 +9082,107 @@ export function heartbeatService(db, options = {}) {
                 })
                 : null;
             const workspaceConfigFreshness = resolveExecutionWorkspaceConfigFreshness({
-                hasExistingWorkspace: requestedShouldReuseExisting && Boolean(existingExecutionWorkspace),
-                existingWorkspaceMetadata: existingExecutionWorkspace?.metadata ?? null,
+                hasExistingWorkspace: requestedShouldReuseExisting && Boolean(reusableExistingExecutionWorkspace),
+                existingWorkspaceMetadata: reusableExistingExecutionWorkspace?.metadata ?? null,
                 inferredMetadata: inferredExistingWorkspaceConfigMetadata,
                 nextMetadata: latestWorkspaceConfigMetadata,
             });
-            const shouldReuseExisting = requestedShouldReuseExisting && workspaceConfigFreshness.shouldReuseExisting;
-            const shouldRefreshWorkspaceConfigSnapshot = shouldReuseExisting && workspaceConfigFreshness.shouldRefreshConfigSnapshot;
+            const workspaceReuseProvisioningPolicy = resolveExecutionWorkspaceReuseProvisioningPolicy({
+                requestedShouldReuseExisting,
+                workspaceConfigFreshness,
+            });
             const workspaceOperationRecorder = workspaceOperationsSvc.createRecorder({
                 companyId: agent.companyId,
                 heartbeatRunId: run.id,
-                executionWorkspaceId: shouldReuseExisting ? existingExecutionWorkspace?.id ?? null : null,
+                executionWorkspaceId: workspaceReuseProvisioningPolicy.shouldRestoreExistingWorkspace
+                    ? workspaceReuseRequest.requestedExecutionWorkspaceId
+                    : null,
                 issueId,
             });
-            const reusedExecutionWorkspace = shouldReuseExisting && existingExecutionWorkspace
-                ? await ensurePersistedExecutionWorkspaceAvailable({
-                    base: executionWorkspaceBase,
-                    workspace: {
-                        id: existingExecutionWorkspace.id,
-                        mode: existingExecutionWorkspace.mode,
-                        strategyType: existingExecutionWorkspace.strategyType,
-                        cwd: existingExecutionWorkspace.cwd,
-                        providerRef: existingExecutionWorkspace.providerRef,
-                        projectId: existingExecutionWorkspace.projectId,
-                        projectWorkspaceId: existingExecutionWorkspace.projectWorkspaceId,
-                        repoUrl: existingExecutionWorkspace.repoUrl,
-                        baseRef: existingExecutionWorkspace.baseRef,
-                        branchName: existingExecutionWorkspace.branchName,
-                        metadata: existingExecutionWorkspace.metadata,
-                        config: {
-                            provisionCommand: configSnapshot?.provisionCommand
-                                ?? existingExecutionWorkspace.config?.provisionCommand
-                                ?? projectExecutionWorkspacePolicy?.workspaceStrategy?.provisionCommand
-                                ?? null,
+            const { executionWorkspace, reusedExecutionWorkspace, policy: resolvedWorkspaceReusePolicy } = await provisionExecutionWorkspaceForFreshnessDecision({
+                requestedShouldReuseExisting,
+                existingExecutionWorkspaceId: workspaceReuseRequest.requestedExecutionWorkspaceId,
+                issueRef,
+                runId: run.id,
+                workspaceConfigFreshness,
+                restoreExistingWorkspace: reusableExistingExecutionWorkspace
+                    ? () => ensurePersistedExecutionWorkspaceAvailable({
+                        db,
+                        base: executionWorkspaceBase,
+                        workspace: {
+                            id: reusableExistingExecutionWorkspace.id,
+                            mode: reusableExistingExecutionWorkspace.mode,
+                            strategyType: reusableExistingExecutionWorkspace.strategyType,
+                            cwd: reusableExistingExecutionWorkspace.cwd,
+                            providerRef: reusableExistingExecutionWorkspace.providerRef,
+                            projectId: reusableExistingExecutionWorkspace.projectId,
+                            projectWorkspaceId: reusableExistingExecutionWorkspace.projectWorkspaceId,
+                            repoUrl: reusableExistingExecutionWorkspace.repoUrl,
+                            baseRef: reusableExistingExecutionWorkspace.baseRef,
+                            branchName: reusableExistingExecutionWorkspace.branchName,
+                            metadata: reusableExistingExecutionWorkspace.metadata,
+                            config: {
+                                provisionCommand: configSnapshot?.provisionCommand
+                                    ?? reusableExistingExecutionWorkspace.config?.provisionCommand
+                                    ?? projectExecutionWorkspacePolicy?.workspaceStrategy?.provisionCommand
+                                    ?? null,
+                            },
                         },
-                    },
+                        issue: issueRef,
+                        agent: {
+                            id: agent.id,
+                            name: agent.name,
+                            companyId: agent.companyId,
+                        },
+                        heartbeatRunId: run.id,
+                        enableWorkspaceBranchReconcileForward: resolvedInstanceSettings.experimental.enableWorkspaceBranchReconcileForward,
+                        enableWorkspaceDirtyQuarantineRepair: resolvedInstanceSettings.experimental.enableWorkspaceDirtyQuarantineRepair,
+                        recorder: workspaceOperationRecorder,
+                    })
+                    : null,
+                realizeWorkspace: () => realizeExecutionWorkspace({
+                    db,
+                    base: executionWorkspaceBase,
+                    config: hostExecutionWorkspaceConfig,
                     issue: issueRef,
                     agent: {
                         id: agent.id,
                         name: agent.name,
                         companyId: agent.companyId,
                     },
+                    heartbeatRunId: run.id,
+                    enableWorkspaceBranchReconcileForward: resolvedInstanceSettings.experimental.enableWorkspaceBranchReconcileForward,
+                    enableWorkspaceDirtyQuarantineRepair: resolvedInstanceSettings.experimental.enableWorkspaceDirtyQuarantineRepair,
                     recorder: workspaceOperationRecorder,
-                })
-                : null;
-            const executionWorkspace = reusedExecutionWorkspace ?? await realizeExecutionWorkspace({
-                base: executionWorkspaceBase,
-                config: hostExecutionWorkspaceConfig,
-                issue: issueRef,
-                agent: {
-                    id: agent.id,
-                    name: agent.name,
-                    companyId: agent.companyId,
-                },
-                recorder: workspaceOperationRecorder,
+                }),
             });
             const resolvedProjectId = executionWorkspace.projectId ?? issueRef?.projectId ?? executionProjectId ?? null;
             const resolvedProjectWorkspaceId = issueRef?.projectWorkspaceId ?? resolvedWorkspace.workspaceId ?? null;
             let persistedExecutionWorkspace = null;
             const nextExecutionWorkspaceMetadata = mergeExecutionWorkspaceMetadataForPersistence({
-                existingMetadata: shouldReuseExisting ? existingExecutionWorkspace?.metadata ?? null : null,
+                existingMetadata: resolvedWorkspaceReusePolicy.shouldRestoreExistingWorkspace
+                    ? reusableExistingExecutionWorkspace?.metadata ?? null
+                    : null,
                 source: executionWorkspace.source,
                 createdByRuntime: executionWorkspace.created,
                 configSnapshot,
-                shouldReuseExisting,
-                shouldRefreshConfigSnapshot: shouldRefreshWorkspaceConfigSnapshot,
-                workspaceConfigMetadata: latestWorkspaceConfigMetadata,
+                shouldReuseExisting: resolvedWorkspaceReusePolicy.shouldRestoreExistingWorkspace,
+                shouldRefreshConfigSnapshot: resolvedWorkspaceReusePolicy.shouldRefreshWorkspaceConfigSnapshot,
+                workspaceConfigMetadata: resolvedWorkspaceReusePolicy.shouldPersistLatestWorkspaceConfigMetadata
+                    ? latestWorkspaceConfigMetadata
+                    : null,
                 baseRef: executionWorkspace.repoRef,
                 baseRefSha: executionWorkspace.baseRefSha ?? null,
             });
+            const pendingForwardBranchReconcile = executionWorkspace.pendingForwardBranchReconcile ?? null;
+            const branchNameForInitialPersistence = pendingForwardBranchReconcile?.recordedBranchName ?? executionWorkspace.branchName;
             try {
-                persistedExecutionWorkspace = shouldReuseExisting && existingExecutionWorkspace
-                    ? await executionWorkspacesSvc.update(existingExecutionWorkspace.id, {
+                persistedExecutionWorkspace = resolvedWorkspaceReusePolicy.shouldRestoreExistingWorkspace && reusableExistingExecutionWorkspace
+                    ? await executionWorkspacesSvc.update(reusableExistingExecutionWorkspace.id, {
                         cwd: executionWorkspace.cwd,
                         repoUrl: executionWorkspace.repoUrl,
                         baseRef: executionWorkspace.repoRef,
-                        branchName: executionWorkspace.branchName,
+                        branchName: branchNameForInitialPersistence,
                         providerType: executionWorkspace.strategy === "git_worktree" ? "git_worktree" : "local_fs",
                         providerRef: executionWorkspace.worktreePath,
                         status: "active",
@@ -7981,12 +9203,12 @@ export function heartbeatService(db, options = {}) {
                                         ? "adapter_managed"
                                         : "shared_workspace",
                             strategyType: executionWorkspace.strategy === "git_worktree" ? "git_worktree" : "project_primary",
-                            name: executionWorkspace.branchName ?? issueRef?.identifier ?? `workspace-${agent.id.slice(0, 8)}`,
+                            name: branchNameForInitialPersistence ?? issueRef?.identifier ?? `workspace-${agent.id.slice(0, 8)}`,
                             status: "active",
                             cwd: executionWorkspace.cwd,
                             repoUrl: executionWorkspace.repoUrl,
                             baseRef: executionWorkspace.repoRef,
-                            branchName: executionWorkspace.branchName,
+                            branchName: branchNameForInitialPersistence,
                             providerType: executionWorkspace.strategy === "git_worktree" ? "git_worktree" : "local_fs",
                             providerRef: executionWorkspace.worktreePath,
                             lastUsedAt: new Date(),
@@ -8000,7 +9222,9 @@ export function heartbeatService(db, options = {}) {
                     try {
                         await cleanupExecutionWorkspaceArtifacts({
                             workspace: {
-                                id: existingExecutionWorkspace?.id ?? `transient-${run.id}`,
+                                id: reusableExistingExecutionWorkspace?.id
+                                    ?? workspaceReuseRequest.requestedExecutionWorkspaceId
+                                    ?? `transient-${run.id}`,
                                 cwd: executionWorkspace.cwd,
                                 providerType: executionWorkspace.strategy === "git_worktree" ? "git_worktree" : "local_fs",
                                 providerRef: executionWorkspace.worktreePath,
@@ -8040,18 +9264,18 @@ export function heartbeatService(db, options = {}) {
                 recorder: workspaceOperationRecorder,
                 runId: run.id,
                 decision: workspaceConfigFreshness,
-                hasExistingWorkspace: Boolean(existingExecutionWorkspace),
+                hasExistingWorkspace: Boolean(reusableExistingExecutionWorkspace),
                 reuseRequested: requestedShouldReuseExisting,
                 workspaceReused: Boolean(reusedExecutionWorkspace),
-                configSnapshotRefreshed: shouldRefreshWorkspaceConfigSnapshot,
-                previousWorkspaceId: existingExecutionWorkspace?.id ?? null,
+                configSnapshotRefreshed: resolvedWorkspaceReusePolicy.shouldRefreshWorkspaceConfigSnapshot,
+                previousWorkspaceId: workspaceReuseRequest.requestedExecutionWorkspaceId,
                 activeWorkspaceId: persistedExecutionWorkspace?.id ?? null,
             });
-            if (existingExecutionWorkspace &&
+            if (reusableExistingExecutionWorkspace &&
                 persistedExecutionWorkspace &&
-                existingExecutionWorkspace.id !== persistedExecutionWorkspace.id &&
-                existingExecutionWorkspace.status === "active") {
-                await executionWorkspacesSvc.update(existingExecutionWorkspace.id, {
+                reusableExistingExecutionWorkspace.id !== persistedExecutionWorkspace.id &&
+                reusableExistingExecutionWorkspace.status === "active") {
+                await executionWorkspacesSvc.update(reusableExistingExecutionWorkspace.id, {
                     status: "idle",
                     cleanupReason: null,
                 });
@@ -8144,6 +9368,46 @@ export function heartbeatService(db, options = {}) {
             const workspaceRealization = realizationResult.workspaceRealization;
             const executionTarget = realizationResult.executionTarget;
             const remoteExecution = realizationResult.remoteExecution;
+            if (!executionTarget || executionTarget.kind === "local") {
+                try {
+                    runScratch = await prepareHeartbeatRunScratch({
+                        companyId: agent.companyId,
+                        agentId: agent.id,
+                        runId: run.id,
+                        issueId: issueRef?.id ?? null,
+                        issueIdentifier: issueRef?.identifier ?? null,
+                    });
+                    const existingRuntimeEnv = parseObject(runtimeConfig.env);
+                    const scratchEnv = buildHeartbeatRunScratchEnv(existingRuntimeEnv, runScratch);
+                    runtimeConfig = {
+                        ...runtimeConfig,
+                        env: {
+                            ...existingRuntimeEnv,
+                            ...scratchEnv.env,
+                        },
+                    };
+                    context.paperclipScratch = {
+                        type: "heartbeat_run",
+                        dir: runScratch.dir,
+                        cleanupPolicy: "terminal_run",
+                        marker: HEARTBEAT_RUN_SCRATCH_MARKER,
+                        tempKeysApplied: scratchEnv.tempKeysApplied,
+                    };
+                }
+                catch (scratchPrepareError) {
+                    runScratch = null;
+                    delete context.paperclipScratch;
+                    logger.warn({
+                        err: scratchPrepareError,
+                        runId: run.id,
+                        issueId,
+                        agentId: agent.id,
+                    }, "failed to prepare heartbeat run scratch directory; continuing without scratch env");
+                }
+            }
+            else {
+                delete context.paperclipScratch;
+            }
             context.paperclipEnvironment = {
                 id: selectedEnvironment.id,
                 name: selectedEnvironment.name,
@@ -8217,6 +9481,16 @@ export function heartbeatService(db, options = {}) {
                 })(),
             };
             context.paperclipWorkspaces = resolvedWorkspace.workspaceHints;
+            // The wake payload is built before the execution workspace is resolved, so
+            // attach the branch pin here; the shared wake-prompt renderer surfaces it as
+            // a one-time "stay on this branch" hint on non-resumed sessions.
+            if (executionWorkspace.branchName) {
+                const wakePayloadForWorkspace = parseObject(context[PAPERCLIP_WAKE_PAYLOAD_KEY]);
+                context[PAPERCLIP_WAKE_PAYLOAD_KEY] = {
+                    ...wakePayloadForWorkspace,
+                    executionWorkspace: { branchName: executionWorkspace.branchName },
+                };
+            }
             const runtimeServiceIntents = (() => {
                 const runtimeConfig = parseObject(hostExecutionWorkspaceConfig.workspaceRuntime);
                 return Array.isArray(runtimeConfig.services)
@@ -8302,12 +9576,12 @@ export function heartbeatService(db, options = {}) {
                     reasons: workspaceConfigFreshness.reasons,
                     reuseRequested: requestedShouldReuseExisting,
                     workspaceReused: Boolean(reusedExecutionWorkspace),
-                    configSnapshotRefreshed: shouldRefreshWorkspaceConfigSnapshot,
+                    configSnapshotRefreshed: resolvedWorkspaceReusePolicy.shouldRefreshWorkspaceConfigSnapshot,
                     storedFingerprintPresent: workspaceConfigFreshness.storedFingerprintPresent,
                     storedFingerprint: workspaceConfigFreshness.storedFingerprint,
                     inferredFingerprint: workspaceConfigFreshness.inferredFingerprint,
                     nextFingerprint: workspaceConfigFreshness.nextFingerprint,
-                    previousWorkspaceId: existingExecutionWorkspace?.id ?? null,
+                    previousWorkspaceId: workspaceReuseRequest.requestedExecutionWorkspaceId,
                     activeWorkspaceId: persistedExecutionWorkspace?.id ?? null,
                 },
             };
@@ -8424,19 +9698,21 @@ export function heartbeatService(db, options = {}) {
                     if (stream === "stderr")
                         stderrExcerpt = appendExcerpt(stderrExcerpt, sanitizedChunk);
                     const ts = new Date().toISOString();
+                    outputSeq += 1;
+                    const chunkSeq = outputSeq;
                     let appendedBytes = 0;
                     if (handle) {
                         appendedBytes = await runLogStore.append(handle, {
                             stream,
                             chunk: sanitizedChunk,
                             ts,
+                            seq: chunkSeq,
                         });
                         persistedLogBytes += appendedBytes;
                     }
-                    outputSeq += 1;
                     outputProgressState.pending = {
                         at: new Date(ts),
-                        seq: outputSeq,
+                        seq: chunkSeq,
                         stream,
                         bytes: persistedLogBytes,
                     };
@@ -8472,6 +9748,7 @@ export function heartbeatService(db, options = {}) {
                             agentId: run.agentId,
                             issueId,
                             ts,
+                            seq: chunkSeq,
                             stream,
                             chunk: payloadChunk,
                             truncated: payloadChunk.length !== sanitizedChunk.length,
@@ -8572,8 +9849,11 @@ export function heartbeatService(db, options = {}) {
                     });
                 };
                 const adapter = getServerAdapter(agent.adapterType);
+                const localAgentJwtScope = issueRef?.workMode === "skill_test"
+                    ? { kind: "skill_test", issueId: issueRef.id }
+                    : { kind: "standard" };
                 const authToken = adapter.supportsLocalAgentJwt
-                    ? createLocalAgentJwt(agent.id, agent.companyId, agent.adapterType, run.id)
+                    ? createLocalAgentJwt(agent.id, agent.companyId, agent.adapterType, run.id, run.responsibleUserId, localAgentJwtScope)
                     : null;
                 if (adapter.supportsLocalAgentJwt && !authToken) {
                     logger.warn({
@@ -8615,8 +9895,10 @@ export function heartbeatService(db, options = {}) {
                             let inspection = branchInspection.inspection;
                             const initialManagedGitWorktreeBranch = formatManagedGitWorktreeBranchInspection(inspection);
                             if (!inspection.valid && inspection.reasonCode === "branch_mismatch" && inspection.repoRoot) {
+                                let repairedExpectedBranchName = inspection.expectedBranchName;
                                 try {
-                                    await ensureGitWorktreeBranchCoherent({
+                                    const coherence = await ensureGitWorktreeBranchCoherent({
+                                        db,
                                         repoRoot: inspection.repoRoot,
                                         worktreePath: inspection.worktreePath,
                                         expectedBranchName: inspection.expectedBranchName,
@@ -8630,8 +9912,18 @@ export function heartbeatService(db, options = {}) {
                                             }
                                             : null,
                                         executionWorkspaceId: branchInspection.workspaceRecord.id,
+                                        heartbeatRunId: run.id,
+                                        enableWorkspaceBranchReconcileForward: resolvedInstanceSettings.experimental.enableWorkspaceBranchReconcileForward,
+                                        enableWorkspaceDirtyQuarantineRepair: resolvedInstanceSettings.experimental.enableWorkspaceDirtyQuarantineRepair,
+                                        persistForwardReconcile: false,
+                                        reconcileOperationPhase: "workspace_finalize",
                                         recorder: workspaceOperationRecorder,
                                     });
+                                    if (coherence.branchName && coherence.branchName !== branchInspection.workspaceRecord.branchName) {
+                                        repairedExpectedBranchName = coherence.branchName;
+                                        executionWorkspace.branchName = coherence.branchName;
+                                        executionWorkspace.warnings.push(...coherence.warnings);
+                                    }
                                 }
                                 catch (repairErr) {
                                     const workspaceValidationFailure = isWorkspaceValidationFailure(repairErr) ? repairErr : null;
@@ -8668,7 +9960,7 @@ export function heartbeatService(db, options = {}) {
                                 }
                                 const repairedInspection = await inspectManagedGitWorktreeBranch({
                                     worktreePath: inspection.worktreePath,
-                                    expectedBranchName: inspection.expectedBranchName,
+                                    expectedBranchName: repairedExpectedBranchName,
                                     repoRoot: inspection.repoRoot,
                                 });
                                 finalizeBranchRepairMetadata = {
@@ -8868,6 +10160,7 @@ export function heartbeatService(db, options = {}) {
                     runId: run.id,
                     sessionId: nextSessionState.displayId ?? nextSessionState.legacySessionId,
                     rawUsage,
+                    usageBasis: adapterResult.usageBasis ?? null,
                 });
                 const normalizedUsage = sessionUsageResolution.normalizedUsage;
                 const runErrorMessage = outcome === "cancelled"
@@ -8875,12 +10168,13 @@ export function heartbeatService(db, options = {}) {
                     : outcome === "succeeded"
                         ? null
                         : redactCurrentUserText(adapterResult.errorMessage ?? (outcome === "timed_out" ? "Timed out" : "Adapter failed"), currentUserRedactionOptions);
+                const recordedResponsibleUserDenialCode = normalizeResponsibleUserDenialCode(latestRun?.errorCode);
                 const runErrorCode = outcome === "timed_out"
                     ? "timeout"
                     : outcome === "cancelled"
                         ? (latestRun?.errorCode ?? "cancelled")
                         : outcome === "failed"
-                            ? (adapterResult.errorCode ?? "adapter_failed")
+                            ? (adapterResult.errorCode ?? recordedResponsibleUserDenialCode ?? "adapter_failed")
                             : null;
                 let logSummary = null;
                 if (handle) {
@@ -8906,7 +10200,11 @@ export function heartbeatService(db, options = {}) {
                             rawCachedInputTokens: rawUsage.cachedInputTokens,
                             rawOutputTokens: rawUsage.outputTokens,
                         } : {}),
-                        ...(sessionUsageResolution.derivedFromSessionTotals ? { usageSource: "session_delta" } : {}),
+                        ...(sessionUsageResolution.derivedFromSessionTotals
+                            ? { usageSource: "session_delta" }
+                            : adapterResult.usageBasis === "per_run"
+                                ? { usageSource: "per_run" }
+                                : {}),
                         ...((nextSessionState.displayId ?? nextSessionState.legacySessionId)
                             ? { persistedSessionId: nextSessionState.displayId ?? nextSessionState.legacySessionId }
                             : {}),
@@ -8920,6 +10218,12 @@ export function heartbeatService(db, options = {}) {
                         biller: resolveLedgerBiller(adapterResult),
                         model: readNonEmptyString(adapterResult.model) ?? "unknown",
                         ...(adapterResult.costUsd != null ? { costUsd: adapterResult.costUsd } : {}),
+                        costStatus: resolveLedgerCostStatus({
+                            costUsd: adapterResult.costUsd,
+                            inputTokens: normalizedUsage?.inputTokens ?? 0,
+                            cachedInputTokens: normalizedUsage?.cachedInputTokens ?? 0,
+                            outputTokens: normalizedUsage?.outputTokens ?? 0,
+                        }),
                         billingType: normalizeLedgerBillingType(adapterResult.billingType),
                     }
                     : null;
@@ -8978,6 +10282,19 @@ export function heartbeatService(db, options = {}) {
                             exitCode: adapterResult.exitCode,
                         },
                     });
+                    try {
+                        await completeSkillTestRunForHeartbeatOutcome({
+                            run: finalizedRun,
+                            issueId,
+                            issueWorkMode: issueRef?.workMode ?? null,
+                            outcome,
+                            error: runErrorMessage,
+                        });
+                    }
+                    catch (err) {
+                        logger.warn({ err, runId: finalizedRun.id, issueId }, "failed to complete skill test run after heartbeat finalization");
+                        await onLog("stderr", `[paperclip] Failed to complete skill test run: ${err instanceof Error ? err.message : String(err)}\n`);
+                    }
                     const livenessRun = finalizedRun;
                     await refreshContinuationSummaryForRun(livenessRun, agent);
                     const skipRunIssueComment = parseObject(livenessRun.contextSnapshot).skipIssueComment === true;
@@ -9032,11 +10349,9 @@ export function heartbeatService(db, options = {}) {
                         : livenessRun, agent);
                     // Dependency wake re-check: if this run's issue was marked done mid-run,
                     // the route-time `issue_blockers_resolved` wake may have been gated by
-                    // workspace finalization or merged into this run. Re-evaluate after any
-                    // run completion, including failed adapter outcomes; this is safe because
-                    // `listWakeableBlockedDependents` delegates to dependency readiness, which
-                    // only returns dependents whose done blockers have crossed the successful
-                    // `workspace_finalize` barrier.
+                    // workspace finalization or merged into this run. Reuse the level-triggered
+                    // dependency backstop so finalize and periodic recovery share idempotency,
+                    // readiness, active-path, and observability rules.
                     if (issueId && finalizedRun) {
                         try {
                             const blockerIssueStatus = await db
@@ -9045,59 +10360,12 @@ export function heartbeatService(db, options = {}) {
                                 .where(eq(issues.id, issueId))
                                 .then((rows) => rows[0]?.status ?? null);
                             if (blockerIssueStatus === "done") {
-                                const dependents = await issuesSvc.listWakeableBlockedDependents(issueId);
-                                for (const dependent of dependents) {
-                                    const idempotencyKey = buildIssueBlockersResolvedWakeIdempotencyKey({
-                                        dependentIssueId: dependent.id,
-                                        resolvedBlockerIssueId: issueId,
-                                    });
-                                    const existingWake = await findExistingIssueBlockersResolvedWake(db, {
-                                        companyId: finalizedRun.companyId,
-                                        idempotencyKey,
-                                    });
-                                    if (existingWake)
-                                        continue;
-                                    await enqueueWakeup(dependent.assigneeAgentId, {
-                                        source: "automation",
-                                        triggerDetail: "system",
-                                        reason: ISSUE_BLOCKERS_RESOLVED_WAKE_REASON,
-                                        payload: {
-                                            issueId: dependent.id,
-                                            resolvedBlockerIssueId: issueId,
-                                            blockerIssueIds: dependent.blockerIssueIds,
-                                            deferredFor: "workspace_finalize",
-                                        },
-                                        idempotencyKey,
-                                        requestedByActorType: "system",
-                                        requestedByActorId: "heartbeat_finalize",
-                                        contextSnapshot: {
-                                            issueId: dependent.id,
-                                            taskId: dependent.id,
-                                            wakeReason: ISSUE_BLOCKERS_RESOLVED_WAKE_REASON,
-                                            source: "workspace.finalize",
-                                            resolvedBlockerIssueId: issueId,
-                                            blockerIssueIds: dependent.blockerIssueIds,
-                                        },
-                                    }).then((wakeRun) => logActivity(db, {
-                                        companyId: finalizedRun.companyId,
-                                        actorType: "system",
-                                        actorId: "heartbeat_finalize",
-                                        agentId: dependent.assigneeAgentId,
-                                        runId: finalizedRun.id,
-                                        action: "issue.blockers_resolved_wake_emitted",
-                                        entityType: "issue",
-                                        entityId: dependent.id,
-                                        details: {
-                                            source: "workspace.finalize",
-                                            wakeupRunId: wakeRun?.id ?? null,
-                                            idempotencyKey,
-                                            resolvedBlockerIssueId: issueId,
-                                            blockerIssueIds: dependent.blockerIssueIds,
-                                        },
-                                    })).catch((wakeErr) => {
-                                        logger.warn({ err: wakeErr, issueId, dependentIssueId: dependent.id, agentId: dependent.assigneeAgentId }, "failed to fire deferred dependent wake after workspace_finalize");
-                                    });
-                                }
+                                await recovery.reconcileResolvedDependencyWakeBackstop({
+                                    runId: finalizedRun.id,
+                                    companyId: finalizedRun.companyId,
+                                    blockerIssueId: issueId,
+                                    source: "workspace.finalize",
+                                });
                             }
                         }
                         catch (finalizeWakeErr) {
@@ -9130,13 +10398,20 @@ export function heartbeatService(db, options = {}) {
                         }
                     }
                 }
-                await finalizeAgentStatus(agent.id, outcome, outcome === "succeeded" ? null : (adapterResult.errorMessage ?? null));
+                await finalizeAgentStatus(agent.id, outcome, outcome === "succeeded" ? null : (adapterResult.errorMessage ?? null), {
+                    keepIdleOnFailure: outcome === "failed" &&
+                        (finalizedRun ? readHeartbeatRunErrorFamily(finalizedRun) === "provider_quota" : runErrorCode === "provider_quota"),
+                });
             }
             catch (err) {
                 const message = redactCurrentUserText(err instanceof Error ? err.message : "Unknown adapter failure", await getCurrentUserRedactionOptions());
                 const workspaceValidationFailure = isWorkspaceValidationFailure(err) ? err : null;
                 const configurationIncompleteFailure = isConfigurationIncompleteFailure(err) ? err : null;
-                const failureErrorCode = workspaceValidationFailure?.code ?? configurationIncompleteFailure?.code ?? "adapter_failed";
+                const recordedResponsibleUserDenialCode = normalizeResponsibleUserDenialCode((await getRun(run.id).catch(() => null))?.errorCode);
+                const failureErrorCode = workspaceValidationFailure?.code
+                    ?? configurationIncompleteFailure?.code
+                    ?? recordedResponsibleUserDenialCode
+                    ?? "adapter_failed";
                 logger.error({ err, runId }, "heartbeat execution failed");
                 let logSummary = null;
                 if (handle) {
@@ -9190,10 +10465,23 @@ export function heartbeatService(db, options = {}) {
                         message,
                     });
                     const livenessRun = await classifyAndPersistRunLiveness(failedRun) ?? failedRun;
+                    try {
+                        await completeSkillTestRunForHeartbeatOutcome({
+                            run: livenessRun,
+                            issueId,
+                            issueWorkMode: issueRef?.workMode ?? null,
+                            outcome: "failed",
+                            error: message,
+                        });
+                    }
+                    catch (err) {
+                        logger.warn({ err, runId: livenessRun.id, issueId }, "failed to complete skill test run after heartbeat adapter failure");
+                    }
                     await refreshContinuationSummaryForRun(livenessRun, agent);
                     if (!isWorkspaceValidationFailedRun(livenessRun) && !isConfigurationIncompleteFailedRun(livenessRun)) {
                         await finalizeIssueCommentPolicy(livenessRun, agent);
                     }
+                    await scheduleInteractionContinuationInfrastructureRetryIfEligible(livenessRun, agent);
                     await releaseIssueExecutionAndPromote(livenessRun);
                     await updateRuntimeState(agent, livenessRun, {
                         exitCode: null,
@@ -9228,7 +10516,11 @@ export function heartbeatService(db, options = {}) {
             // recovery path routes it to a human owner instead of looping retries.
             const workspaceValidationSetupFailure = isWorkspaceValidationFailure(outerErr) ? outerErr : null;
             const configurationIncompleteSetupFailure = isConfigurationIncompleteFailure(outerErr) ? outerErr : null;
-            const setupFailureErrorCode = workspaceValidationSetupFailure?.code ?? configurationIncompleteSetupFailure?.code ?? "setup_failed";
+            const recordedResponsibleUserDenialCode = normalizeResponsibleUserDenialCode((await getRun(runId).catch(() => null))?.errorCode);
+            const setupFailureErrorCode = workspaceValidationSetupFailure?.code ??
+                configurationIncompleteSetupFailure?.code ??
+                recordedResponsibleUserDenialCode ??
+                "setup_failed";
             logger.error({ err: outerErr, runId }, "heartbeat execution setup failed");
             const setupFailureAgent = await getAgent(run.agentId).catch(() => null);
             const setupFailureWrite = await setRunStatusIfRunning(runId, "failed", {
@@ -9267,14 +10559,30 @@ export function heartbeatService(db, options = {}) {
                     message,
                 }).catch(() => undefined);
                 const livenessRun = await classifyAndPersistRunLiveness(failedRun).catch(() => failedRun);
+                const setupFailureIssueId = readNonEmptyString(parseObject(livenessRun.contextSnapshot).issueId);
+                if (setupFailureIssueId) {
+                    await completeSkillTestRunForHeartbeatOutcome({
+                        run: livenessRun,
+                        issueId: setupFailureIssueId,
+                        outcome: "failed",
+                        error: message,
+                    }).catch((completionErr) => {
+                        logger.warn({ err: completionErr, runId: livenessRun.id, issueId: setupFailureIssueId }, "failed to complete skill test run after heartbeat setup failure");
+                    });
+                }
                 const failedAgent = setupFailureAgent ?? await getAgent(run.agentId).catch(() => null);
                 if (failedAgent) {
                     await refreshContinuationSummaryForRun(livenessRun, failedAgent).catch(() => undefined);
                     if (!isWorkspaceValidationFailedRun(livenessRun) && !isConfigurationIncompleteFailedRun(livenessRun)) {
                         await finalizeIssueCommentPolicy(livenessRun, failedAgent).catch(() => undefined);
                     }
+                    await scheduleInteractionContinuationInfrastructureRetryIfEligible(livenessRun, failedAgent).catch((retryError) => {
+                        logger.warn({ err: retryError, runId: livenessRun.id }, "failed to schedule interaction continuation retry after setup failure");
+                    });
                 }
-                await releaseIssueExecutionAndPromote(livenessRun).catch(() => undefined);
+                await releaseIssueExecutionAndPromote(livenessRun).catch((releaseError) => {
+                    logger.error({ err: releaseError, runId }, "failed to release issue execution after heartbeat setup failure");
+                });
             }
             // Ensure the agent is not left stuck in "running" if the setup-failure
             // path owned the terminal transition. If another path already finalized
@@ -9293,6 +10601,53 @@ export function heartbeatService(db, options = {}) {
                 failureReason: latestRun?.error ?? undefined,
             });
             await releaseRuntimeServicesForRun(run.id).catch(() => undefined);
+            if (runScratch && latestRun && isHeartbeatRunTerminalStatus(latestRun.status)) {
+                const scratchForCleanup = runScratch;
+                let scratchCleanup = null;
+                try {
+                    scratchCleanup = await cleanupHeartbeatRunScratch({
+                        scratch: scratchForCleanup,
+                        processGroupId: latestRun.processGroupId,
+                        isProcessGroupAlive,
+                    });
+                }
+                catch (scratchCleanupError) {
+                    logger.warn({
+                        err: scratchCleanupError,
+                        runId: run.id,
+                        scratchDir: scratchForCleanup.dir,
+                    }, "failed to clean heartbeat run scratch directory");
+                    await appendRunEvent(latestRun, await nextRunEventSeq(latestRun.id), {
+                        eventType: "error",
+                        stream: "system",
+                        level: "warn",
+                        message: "run scratch cleanup failed",
+                        payload: {
+                            dir: scratchForCleanup.dir,
+                            error: scratchCleanupError instanceof Error
+                                ? scratchCleanupError.message
+                                : String(scratchCleanupError),
+                        },
+                    }).catch(() => undefined);
+                }
+                if (scratchCleanup) {
+                    await appendRunEvent(latestRun, await nextRunEventSeq(latestRun.id), {
+                        eventType: "lifecycle",
+                        stream: "system",
+                        level: scratchCleanup.removed ? "info" : "warn",
+                        message: scratchCleanup.removed
+                            ? "run scratch cleaned"
+                            : `run scratch cleanup skipped: ${scratchCleanup.reason}`,
+                        payload: scratchCleanup,
+                    }).catch((scratchCleanupEventError) => {
+                        logger.warn({
+                            err: scratchCleanupEventError,
+                            runId: run.id,
+                            scratchDir: scratchForCleanup.dir,
+                        }, "failed to record heartbeat run scratch cleanup event");
+                    });
+                }
+            }
             activeRunExecutions.delete(run.id);
             await startNextQueuedRunForAgent(run.agentId);
         }
@@ -9595,6 +10950,27 @@ export function heartbeatService(db, options = {}) {
                 const sessionBefore = readNonEmptyString(promotedContextSnapshot.resumeSessionDisplayId) ??
                     await resolveSessionBeforeForWakeup(deferredAgent, promotedTaskKey);
                 const promotedContinuationAttempt = readContinuationAttempt(promotedContextSnapshot.livenessContinuationAttempt);
+                const promotedResponsibleUserId = await resolveResponsibleUserIdForRunSeed({
+                    companyId: deferredAgent.companyId,
+                    contextSnapshot: promotedContextSnapshot,
+                    issueContext: issue,
+                    routineEnvContext: await getRoutineEnvForExecutionIssue(deferredAgent.companyId, issue),
+                    requestedByActorType: deferred.requestedByActorType,
+                    requestedByActorId: deferred.requestedByActorId,
+                    source: promotedSource,
+                    triggerDetail: promotedTriggerDetail,
+                    existingRunResponsibleUserId: run.responsibleUserId,
+                });
+                if (!promotedResponsibleUserId) {
+                    throw new HttpError(422, "Unable to resolve responsible user for promoted heartbeat run", {
+                        code: "responsible_user_unresolved",
+                        runId: run.id,
+                        agentId: deferredAgent.id,
+                        companyId: deferredAgent.companyId,
+                        issueId: issue.id,
+                        wakeReason: readNonEmptyString(promotedContextSnapshot.wakeReason),
+                    });
+                }
                 const now = new Date();
                 const newRun = await tx
                     .insert(heartbeatRuns)
@@ -9606,6 +10982,7 @@ export function heartbeatService(db, options = {}) {
                     status: "queued",
                     wakeupRequestId: deferred.id,
                     contextSnapshot: promotedContextSnapshot,
+                    responsibleUserId: promotedResponsibleUserId,
                     sessionIdBefore: sessionBefore,
                     continuationAttempt: promotedContinuationAttempt,
                 })
@@ -9645,8 +11022,14 @@ export function heartbeatService(db, options = {}) {
                 .where(and(eq(heartbeatRuns.companyId, issue.companyId), inArray(heartbeatRuns.status, [...EXECUTION_PATH_HEARTBEAT_RUN_STATUSES]), sql `${heartbeatRuns.contextSnapshot} ->> 'issueId' = ${issue.id}`, sql `${heartbeatRuns.id} <> ${run.id}`, agentId ? eq(heartbeatRuns.agentId, agentId) : sql `true`))
                 .limit(1)
                 .then((rows) => rows[0] ?? null);
-            const issueHasScheduledMonitor = issue.monitorNextCheckAt instanceof Date &&
-                issue.monitorNextCheckAt.getTime() > Date.now();
+            const issueHasPersistedMonitor = Boolean(issue.monitorNextCheckAt);
+            const findExplicitBlockerPath = () => tx
+                .select({ id: issueRelations.issueId })
+                .from(issueRelations)
+                .innerJoin(issues, eq(issueRelations.issueId, issues.id))
+                .where(and(eq(issueRelations.companyId, issue.companyId), eq(issueRelations.relatedIssueId, issue.id), eq(issueRelations.type, "blocks"), eq(issues.companyId, issue.companyId), notInArray(issues.status, ["done", "cancelled"]), isNull(issues.hiddenAt)))
+                .limit(1)
+                .then((rows) => rows[0] ?? null);
             const executionState = parseIssueExecutionState(issue.executionState);
             const currentParticipant = executionState?.status === "pending"
                 ? executionState.currentParticipant
@@ -9661,7 +11044,7 @@ export function heartbeatService(db, options = {}) {
                 const existingReviewParticipantExecutionPath = await findExistingExecutionPath(currentParticipant.agentId);
                 if (options.suppressImmediateRecovery ||
                     existingReviewParticipantExecutionPath ||
-                    issueHasScheduledMonitor ||
+                    issueHasPersistedMonitor ||
                     await isAutomaticRecoverySuppressedByPauseHold(db, issue.companyId, issue.id, treeControlSvc)) {
                     return { kind: "released" };
                 }
@@ -9766,7 +11149,7 @@ export function heartbeatService(db, options = {}) {
                 return { kind: "released" };
             }
             const existingExecutionPath = await findExistingExecutionPath();
-            if (existingExecutionPath) {
+            if (existingExecutionPath || issueHasPersistedMonitor || await findExplicitBlockerPath()) {
                 return { kind: "released" };
             }
             if (await isAutomaticRecoverySuppressedByPauseHold(db, issue.companyId, issue.id, treeControlSvc)) {
@@ -9811,6 +11194,35 @@ export function heartbeatService(db, options = {}) {
             const recoveryReason = issue.status === "todo" ? "issue_assignment_recovery" : "issue_continuation_needed";
             const recoverySource = issue.status === "todo" ? "issue.assignment_recovery" : "issue.continuation_recovery";
             const now = new Date();
+            const recoveryContextSnapshot = withRecoveryModelProfileHint({
+                issueId: issue.id,
+                taskId: issue.id,
+                wakeReason: recoveryReason,
+                retryReason,
+                source: recoverySource,
+                retryOfRunId: run.id,
+            }, "normal_model");
+            const responsibleUserId = await resolveResponsibleUserIdForRunSeed({
+                companyId: issue.companyId,
+                contextSnapshot: recoveryContextSnapshot,
+                issueContext: issue,
+                routineEnvContext: await getRoutineEnvForExecutionIssue(issue.companyId, issue),
+                requestedByActorType: "system",
+                requestedByActorId: null,
+                source: "automation",
+                triggerDetail: "system",
+                existingRunResponsibleUserId: run.responsibleUserId,
+            });
+            if (!responsibleUserId) {
+                throw new HttpError(422, "Unable to resolve responsible user for recovery heartbeat run", {
+                    code: "responsible_user_unresolved",
+                    runId: run.id,
+                    agentId: recoveryAgent.id,
+                    companyId: issue.companyId,
+                    issueId: issue.id,
+                    wakeReason: recoveryReason,
+                });
+            }
             const wakeupRequest = await tx
                 .insert(agentWakeupRequests)
                 .values({
@@ -9839,14 +11251,8 @@ export function heartbeatService(db, options = {}) {
                 triggerDetail: "system",
                 status: "queued",
                 wakeupRequestId: wakeupRequest.id,
-                contextSnapshot: withRecoveryModelProfileHint({
-                    issueId: issue.id,
-                    taskId: issue.id,
-                    wakeReason: recoveryReason,
-                    retryReason,
-                    source: recoverySource,
-                    retryOfRunId: run.id,
-                }, "normal_model"),
+                contextSnapshot: recoveryContextSnapshot,
+                responsibleUserId,
                 sessionIdBefore: recoverySessionBefore,
                 retryOfRunId: run.id,
                 updatedAt: now,
@@ -9961,6 +11367,16 @@ export function heartbeatService(db, options = {}) {
                 },
             });
         };
+        const schedulingSuppression = await getSchedulingSuppression();
+        if (schedulingSuppression.suppressed) {
+            await writeSkippedHeartbeatRequest("heartbeat.scheduling_suppressed", {
+                reason: schedulingSuppression.reason,
+            });
+            return null;
+        }
+        const worktreeExecutionCutoff = opts.requestedByActorType === "user"
+            ? null
+            : await getWorktreeExecutionCutoff();
         const company = await db
             .select({ status: companies.status })
             .from(companies)
@@ -9995,6 +11411,20 @@ export function heartbeatService(db, options = {}) {
         const effectiveTaskKey = readNonEmptyString(enrichedContextSnapshot.taskKey) ?? taskKey;
         const sessionBefore = explicitResumeSession?.sessionDisplayId ??
             await resolveSessionBeforeForWakeup(agent, effectiveTaskKey);
+        let hasResolvablePriorSessionWorkspace = null;
+        const resolveHasResolvablePriorSessionWorkspace = async () => {
+            if (hasResolvablePriorSessionWorkspace !== null)
+                return hasResolvablePriorSessionWorkspace;
+            hasResolvablePriorSessionWorkspace = issueId
+                ? await hasResolvablePriorSessionWorkspaceForWake({
+                    agent,
+                    contextSnapshot: enrichedContextSnapshot,
+                    taskKey: effectiveTaskKey,
+                    explicitResumeSession,
+                })
+                : false;
+            return hasResolvablePriorSessionWorkspace;
+        };
         const continuationAttempt = readContinuationAttempt(enrichedContextSnapshot.livenessContinuationAttempt);
         let projectId = readNonEmptyString(enrichedContextSnapshot.projectId);
         if (!projectId && issueId) {
@@ -10009,11 +11439,19 @@ export function heartbeatService(db, options = {}) {
                 ? or(eq(issues.id, issueId), eq(issues.identifier, issueId.toUpperCase()))
                 : eq(issues.identifier, issueId.toUpperCase());
             const resolvedIssue = await db
-                .select({ id: issues.id, projectId: issues.projectId })
+                .select({ id: issues.id, projectId: issues.projectId, createdAt: issues.createdAt })
                 .from(issues)
                 .where(and(eq(issues.companyId, agent.companyId), idMatch))
                 .then((rows) => rows[0] ?? null);
             if (resolvedIssue) {
+                if (worktreeExecutionCutoff && resolvedIssue.createdAt < worktreeExecutionCutoff) {
+                    await writeSkippedHeartbeatRequest("heartbeat.worktree_execution_cutoff", {
+                        reason: "worktree_execution_cutoff",
+                        cutoff: worktreeExecutionCutoff.toISOString(),
+                        issueId: resolvedIssue.id,
+                    });
+                    return null;
+                }
                 projectId = resolvedIssue.projectId ?? null;
                 // Canonicalize context to the UUID so downstream lookups always use UUID
                 if (resolvedIssue.id !== issueId) {
@@ -10030,6 +11468,39 @@ export function heartbeatService(db, options = {}) {
         if (projectId && !readNonEmptyString(enrichedContextSnapshot.projectId)) {
             enrichedContextSnapshot.projectId = projectId;
         }
+        const isolatedWorkspacesEnabled = issueId
+            ? (await instanceSettings.getExperimental()).enableIsolatedWorkspaces
+            : false;
+        let queuedResponsibleUserIdPromise = null;
+        const resolveQueuedResponsibleUserId = () => {
+            queuedResponsibleUserIdPromise ??= (async () => {
+                const queuedIssueContext = issueId ? await getIssueExecutionContext(agent.companyId, issueId) : null;
+                const queuedRoutineEnvContext = await getRoutineEnvForExecutionIssue(agent.companyId, queuedIssueContext);
+                const queuedResponsibleUserId = await resolveResponsibleUserIdForRunSeed({
+                    companyId: agent.companyId,
+                    contextSnapshot: enrichedContextSnapshot,
+                    issueContext: queuedIssueContext,
+                    routineEnvContext: queuedRoutineEnvContext,
+                    requestedByActorType: opts.requestedByActorType ?? null,
+                    requestedByActorId: opts.requestedByActorId ?? null,
+                    source,
+                    triggerDetail,
+                });
+                if (!queuedResponsibleUserId) {
+                    throw new HttpError(422, "Unable to resolve responsible user for heartbeat run dispatch", {
+                        code: "responsible_user_unresolved",
+                        agentId,
+                        companyId: agent.companyId,
+                        issueId: issueId ?? null,
+                        source,
+                        triggerDetail,
+                        wakeReason: readNonEmptyString(enrichedContextSnapshot.wakeReason),
+                    });
+                }
+                return queuedResponsibleUserId;
+            })();
+            return queuedResponsibleUserIdPromise;
+        };
         const budgetBlock = await budgets.getInvocationBlock(agent.companyId, agentId, {
             issueId,
             projectId,
@@ -10131,10 +11602,17 @@ export function heartbeatService(db, options = {}) {
                     .select({
                     id: issues.id,
                     companyId: issues.companyId,
+                    identifier: issues.identifier,
                     status: issues.status,
+                    projectId: issues.projectId,
+                    projectWorkspaceId: issues.projectWorkspaceId,
+                    executionWorkspaceId: issues.executionWorkspaceId,
+                    executionWorkspacePreference: issues.executionWorkspacePreference,
+                    executionWorkspaceSettings: issues.executionWorkspaceSettings,
                     assigneeAgentId: issues.assigneeAgentId,
                     executionRunId: issues.executionRunId,
                     executionAgentNameKey: issues.executionAgentNameKey,
+                    createdAt: issues.createdAt,
                 })
                     .from(issues)
                     .where(and(eq(issues.id, issueId), eq(issues.companyId, agent.companyId)))
@@ -10155,6 +11633,29 @@ export function heartbeatService(db, options = {}) {
                     });
                     return { kind: "skipped" };
                 }
+                if (worktreeExecutionCutoff && issue.createdAt < worktreeExecutionCutoff) {
+                    await tx.insert(agentWakeupRequests).values({
+                        companyId: agent.companyId,
+                        agentId,
+                        source,
+                        triggerDetail,
+                        reason: "heartbeat.worktree_execution_cutoff",
+                        payload: {
+                            ...(payload ?? {}),
+                            heartbeatSkip: {
+                                reason: "worktree_execution_cutoff",
+                                cutoff: worktreeExecutionCutoff.toISOString(),
+                                issueId: issue.id,
+                            },
+                        },
+                        status: "skipped",
+                        requestedByActorType: opts.requestedByActorType ?? null,
+                        requestedByActorId: opts.requestedByActorId ?? null,
+                        idempotencyKey: opts.idempotencyKey ?? null,
+                        finishedAt: new Date(),
+                    });
+                    return { kind: "skipped" };
+                }
                 const cancelStaleScheduledRetry = async (scheduledRun) => {
                     const issueCancelled = issue.status === "cancelled";
                     if (scheduledRun.status !== "scheduled_retry" ||
@@ -10362,6 +11863,118 @@ export function heartbeatService(db, options = {}) {
                     });
                     return { kind: "skipped" };
                 }
+                if (isolatedWorkspacesEnabled && !activeExecutionRun && issue.status !== "done" && issue.status !== "cancelled") {
+                    const issueSettings = parseIssueExecutionWorkspaceSettings(issue.executionWorkspaceSettings);
+                    const resolvedMode = resolveExecutionWorkspaceMode({
+                        projectPolicy: null,
+                        issueSettings,
+                        legacyUseProjectWorkspace: null,
+                    });
+                    const workspaceManagedConfig = buildExecutionWorkspaceAdapterConfig({
+                        agentConfig: parseObject(agent.adapterConfig),
+                        projectPolicy: null,
+                        issueSettings,
+                        mode: resolvedMode,
+                        legacyUseProjectWorkspace: null,
+                    });
+                    const resolvedStrategy = resolveEffectiveWorkspaceStrategyType(resolvedMode, workspaceManagedConfig);
+                    const existingExecutionWorkspaceStatus = issue.executionWorkspaceId
+                        ? await tx
+                            .select({ status: executionWorkspaces.status })
+                            .from(executionWorkspaces)
+                            .where(and(eq(executionWorkspaces.id, issue.executionWorkspaceId), eq(executionWorkspaces.companyId, issue.companyId)))
+                            .then((rows) => rows[0]?.status ?? null)
+                        : null;
+                    const reuseRequest = resolveExecutionWorkspaceReuseRequestForIssue({
+                        issueExecutionWorkspaceId: issue.executionWorkspaceId,
+                        issueExecutionWorkspacePreference: issue.executionWorkspacePreference,
+                        existingExecutionWorkspaceStatus,
+                    });
+                    const hasResolvablePriorSessionWorkspace = await resolveHasResolvablePriorSessionWorkspace();
+                    if (isUnrunnableWorktreeCombo({
+                        issue: {
+                            projectId: issue.projectId ?? projectId ?? null,
+                            projectWorkspaceId: issue.projectWorkspaceId,
+                            executionWorkspaceId: issue.executionWorkspaceId,
+                            executionWorkspacePreference: issue.executionWorkspacePreference,
+                        },
+                        resolvedMode,
+                        resolvedStrategy,
+                        reusableExecutionWorkspaceAvailable: reuseRequest.existingExecutionWorkspaceAvailable,
+                        hasResolvablePriorSessionWorkspace,
+                    })) {
+                        const now = new Date();
+                        const issueLabel = formatIssueIdentifierLink(issue.identifier, issue.id);
+                        const blockedComment = [
+                            `Paperclip blocked ${issueLabel} before dispatch because its workspace settings are not runnable.`,
+                            "",
+                            `- Code: \`${WORKSPACE_WORKTREE_REQUIRES_PROJECT_CODE}\``,
+                            `- Reason: ${WORKSPACE_WORKTREE_REQUIRES_PROJECT_MESSAGE}`,
+                            `- Next action: ${WORKSPACE_WORKTREE_REQUIRES_PROJECT_REMEDIATION}`,
+                        ].join("\n");
+                        await tx
+                            .update(issues)
+                            .set({
+                            status: "blocked",
+                            checkoutRunId: null,
+                            executionRunId: null,
+                            executionAgentNameKey: null,
+                            executionLockedAt: null,
+                            updatedAt: now,
+                        })
+                            .where(eq(issues.id, issue.id));
+                        await tx.insert(issueComments).values({
+                            companyId: issue.companyId,
+                            issueId: issue.id,
+                            body: blockedComment,
+                            createdAt: now,
+                            updatedAt: now,
+                        });
+                        await tx.insert(agentWakeupRequests).values({
+                            companyId: agent.companyId,
+                            agentId,
+                            source,
+                            triggerDetail,
+                            reason: WORKSPACE_WORKTREE_REQUIRES_PROJECT_CODE,
+                            payload: {
+                                ...(payload ?? {}),
+                                issueId,
+                                heartbeatSkip: {
+                                    code: WORKSPACE_WORKTREE_REQUIRES_PROJECT_CODE,
+                                    reason: WORKSPACE_WORKTREE_REQUIRES_PROJECT_MESSAGE,
+                                    remediation: WORKSPACE_WORKTREE_REQUIRES_PROJECT_REMEDIATION,
+                                },
+                            },
+                            status: "skipped",
+                            requestedByActorType: opts.requestedByActorType ?? null,
+                            requestedByActorId: opts.requestedByActorId ?? null,
+                            idempotencyKey: opts.idempotencyKey ?? null,
+                            finishedAt: now,
+                        });
+                        await logActivity(tx, {
+                            companyId: issue.companyId,
+                            actorType: "system",
+                            actorId: "system",
+                            agentId,
+                            runId: null,
+                            action: "issue.workspace_preflight_blocked",
+                            entityType: "issue",
+                            entityId: issue.id,
+                            details: {
+                                code: WORKSPACE_WORKTREE_REQUIRES_PROJECT_CODE,
+                                reason: WORKSPACE_WORKTREE_REQUIRES_PROJECT_MESSAGE,
+                                remediation: WORKSPACE_WORKTREE_REQUIRES_PROJECT_REMEDIATION,
+                                requestedReason: reason,
+                                source,
+                                triggerDetail,
+                                resolvedMode,
+                                resolvedStrategy,
+                                hasResolvablePriorSessionWorkspace,
+                            },
+                        });
+                        return { kind: "skipped" };
+                    }
+                }
                 if (activeExecutionRun) {
                     const executionAgent = await tx
                         .select({ name: agents.name })
@@ -10469,6 +12082,81 @@ export function heartbeatService(db, options = {}) {
                         return { kind: "deferred" };
                     }
                 }
+                // PAP-13775: no live run holds the lock, so this wake would start a
+                // fresh adapter session. If this agent's recent runs on this issue
+                // keep succeeding without any issue-visible progress and the wake
+                // carries no new information, hold it back for an escalating cooldown
+                // so external pollers/reconcilers can't storm full-price sessions.
+                // Server-side recovery retries insert runs directly and never reach
+                // this gate.
+                if (isThrottleCandidateIssueRewake({
+                    reason,
+                    wakeCommentId: wakeCommentId ?? null,
+                    forceFreshSession: enrichedContextSnapshot.forceFreshSession === true,
+                    hasExplicitResume: Boolean(explicitResumeSession),
+                })) {
+                    const throttleNow = new Date();
+                    const recentTerminalRuns = await tx
+                        .select({
+                        id: heartbeatRuns.id,
+                        status: heartbeatRuns.status,
+                        finishedAt: heartbeatRuns.finishedAt,
+                    })
+                        .from(heartbeatRuns)
+                        .where(and(eq(heartbeatRuns.companyId, agent.companyId), eq(heartbeatRuns.agentId, agentId), sql `${heartbeatRuns.finishedAt} is not null`, gte(heartbeatRuns.finishedAt, new Date(throttleNow.getTime() - ISSUE_REWAKE_LOOKBACK_MS)), sql `${heartbeatRuns.contextSnapshot} ->> 'issueId' = ${issue.id}`))
+                        .orderBy(desc(heartbeatRuns.finishedAt))
+                        .limit(ISSUE_REWAKE_RUN_SAMPLE_LIMIT);
+                    if (recentTerminalRuns.length > 0) {
+                        const sampleRunIds = recentTerminalRuns.map((sampleRun) => sampleRun.id);
+                        const progressRows = await tx
+                            .select({ runId: activityLog.runId })
+                            .from(activityLog)
+                            .where(and(eq(activityLog.companyId, agent.companyId), eq(activityLog.entityType, "issue"), eq(activityLog.entityId, issue.id), inArray(activityLog.runId, sampleRunIds), inArray(activityLog.action, ISSUE_PROGRESS_ACTIVITY_ACTIONS)));
+                        const lastRunFinishedAt = recentTerminalRuns[0]?.finishedAt ?? null;
+                        const newInputRows = lastRunFinishedAt
+                            ? await tx
+                                .select({ id: activityLog.id })
+                                .from(activityLog)
+                                .where(and(eq(activityLog.companyId, agent.companyId), eq(activityLog.entityType, "issue"), eq(activityLog.entityId, issue.id), gt(activityLog.createdAt, lastRunFinishedAt), inArray(activityLog.action, ISSUE_NEW_INPUT_ACTIVITY_ACTIONS)))
+                                .limit(1)
+                            : [];
+                        const throttleDecision = evaluateIssueRewakeThrottle({
+                            now: throttleNow,
+                            recentTerminalRuns,
+                            runIdsWithIssueProgress: new Set(progressRows
+                                .map((row) => row.runId)
+                                .filter((runId) => Boolean(runId))),
+                            hasNewIssueInputSinceLastRun: newInputRows.length > 0,
+                        });
+                        if (throttleDecision.blocked) {
+                            await tx.insert(agentWakeupRequests).values({
+                                companyId: agent.companyId,
+                                agentId,
+                                source,
+                                triggerDetail,
+                                reason: "issue_rewake_throttled",
+                                payload: {
+                                    ...(payload ?? {}),
+                                    issueId,
+                                    heartbeatSkip: {
+                                        reason: "issue_rewake_throttled",
+                                        requestedReason: reason,
+                                        noProgressStreak: throttleDecision.noProgressStreak,
+                                        cooldownMs: throttleDecision.cooldownMs,
+                                        lastRunFinishedAt: throttleDecision.lastRunFinishedAt.toISOString(),
+                                        nextAllowedAt: throttleDecision.nextAllowedAt.toISOString(),
+                                    },
+                                },
+                                status: "skipped",
+                                requestedByActorType: opts.requestedByActorType ?? null,
+                                requestedByActorId: opts.requestedByActorId ?? null,
+                                idempotencyKey: opts.idempotencyKey ?? null,
+                                finishedAt: throttleNow,
+                            });
+                            return { kind: "skipped" };
+                        }
+                    }
+                }
                 const dailyCapBlock = await getHeartbeatDailyCapBlock(agent, policy, {}, tx);
                 if (dailyCapBlock) {
                     const now = new Date();
@@ -10527,6 +12215,7 @@ export function heartbeatService(db, options = {}) {
                     invocationSource: source,
                     triggerDetail,
                     status: "queued",
+                    responsibleUserId: await resolveQueuedResponsibleUserId(),
                     wakeupRequestId: wakeupRequest.id,
                     contextSnapshot: enrichedContextSnapshot,
                     sessionIdBefore: sessionBefore,
@@ -10679,6 +12368,7 @@ export function heartbeatService(db, options = {}) {
                 invocationSource: source,
                 triggerDetail,
                 status: "queued",
+                responsibleUserId: await resolveQueuedResponsibleUserId(),
                 wakeupRequestId: wakeupRequest.id,
                 contextSnapshot: enrichedContextSnapshot,
                 sessionIdBefore: sessionBefore,
@@ -10924,6 +12614,17 @@ export function heartbeatService(db, options = {}) {
         await cancelPendingWakeupsForBudgetScope(scope);
     }
     return {
+        waitForRunExecutionDrain: async (runId, options = {}) => {
+            const timeoutMs = options.timeoutMs ?? 5_000;
+            const intervalMs = options.intervalMs ?? 25;
+            const deadline = Date.now() + timeoutMs;
+            while (liveRunExecutions.has(runId)) {
+                if (Date.now() >= deadline) {
+                    throw new Error(`Timed out waiting for heartbeat run ${runId} execution to drain`);
+                }
+                await new Promise((resolve) => setTimeout(resolve, intervalMs));
+            }
+        },
         list: async (companyId, agentId, limit, options = {}) => {
             const safeForLegacyEncoding = await hasUnsafeTextProjectionDatabase();
             const summary = options.summary === true;
@@ -11092,6 +12793,11 @@ export function heartbeatService(db, options = {}) {
         triggerIssueMonitor,
         reportRunActivity: clearDetachedRunWarning,
         reapOrphanedRuns,
+        // Override-aware scheduling-suppression check (honors the worktree
+        // run-execution experimental setting). Callers outside the service that
+        // gate on suppression should prefer this over the env-only resolver.
+        resolveSchedulingSuppression: getSchedulingSuppression,
+        drainRunningRunsForShutdown,
         promoteDueScheduledRetries,
         retryScheduledRetryNow,
         resumeQueuedRuns,
@@ -11113,6 +12819,14 @@ export function heartbeatService(db, options = {}) {
         reconcileTaskWatchdogs,
         buildRunOutputSilence,
         tickTimers: async (now = new Date()) => {
+            if ((await getSchedulingSuppression()).suppressed) {
+                return {
+                    checked: 0,
+                    enqueued: 0,
+                    skipped: 0,
+                };
+            }
+            const cutoff = await getWorktreeExecutionCutoff();
             const allAgents = await db
                 .select({ ...getTableColumns(agents) })
                 .from(agents)
@@ -11129,6 +12843,16 @@ export function heartbeatService(db, options = {}) {
                 const policy = parseHeartbeatPolicy(agent);
                 if (!policy.enabled || policy.intervalSec <= 0)
                     continue;
+                if (cutoff) {
+                    const eligibleIssue = await db
+                        .select({ id: issues.id })
+                        .from(issues)
+                        .where(and(eq(issues.companyId, agent.companyId), eq(issues.assigneeAgentId, agent.id), inArray(issues.status, ["todo", "in_progress"]), gte(issues.createdAt, cutoff)))
+                        .limit(1)
+                        .then((rows) => rows[0] ?? null);
+                    if (!eligibleIssue)
+                        continue;
+                }
                 checked += 1;
                 const baseline = new Date(agent.lastHeartbeatAt ?? agent.createdAt).getTime();
                 const elapsedMs = now.getTime() - baseline;