@rudderhq/server 0.2.5-canary.8 → 0.2.5

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

@@ -1,1254 +1,36 @@
-import path from "node:path";
-import { and, asc, desc, eq, gt, gte, inArray, lte, sql } from "drizzle-orm";
-import { AGENT_RUN_CONCURRENCY_DEFAULT, AGENT_RUN_CONCURRENCY_MAX, AGENT_RUN_CONCURRENCY_MIN, summarizeTokenUsage, } from "@rudderhq/shared";
-import { agents, agentRuntimeState, agentTaskSessions, agentWakeupRequests, activityLog, authUsers, heartbeatRunEvents, heartbeatRuns, issueComments, issues, organizations, projects, } from "@rudderhq/db";
-import { conflict, notFound } from "../../errors.js";
-import { createExecutionScores, observeExecutionEvent, updateExecutionObservation, updateExecutionTraceIO, updateExecutionTraceName, updateExecutionTraceSession, withExecutionObservation, } from "../../langfuse.js";
-import { emitExecutionTranscriptTree } from "../../langfuse-transcript.js";
+import { and, asc, desc, eq, gt, sql } from "drizzle-orm";
+import { summarizeTokenUsage, } from "@rudderhq/shared";
+import { agents, agentRuntimeState, agentTaskSessions, agentWakeupRequests, heartbeatRunEvents, heartbeatRuns, organizations, } from "@rudderhq/db";
+import { notFound } from "../../errors.js";
+import { createExecutionScores, observeExecutionEvent, } from "../../langfuse.js";
 import { logger } from "../../middleware/logger.js";
 import { publishLiveEvent } from "../live-events.js";
 import { getRunLogStore } from "../run-log-store.js";
-import { findServerAdapter, getServerAdapter, runningProcesses } from "../../agent-runtimes/index.js";
-import { createLocalAgentJwt } from "../../agent-auth-jwt.js";
-import { parseObject, asBoolean, asNumber, appendWithCap, MAX_EXCERPT_BYTES } from "../../agent-runtimes/utils.js";
+import { runningProcesses } from "../../agent-runtimes/index.js";
+import { parseObject } from "../../agent-runtimes/utils.js";
 import { costService } from "../costs.js";
 import { budgetService } from "../budgets.js";
 import { agentRunContextService, } from "../agent-run-context.js";
-import { resolveDefaultAgentWorkspaceDir, } from "../../home-paths.js";
 import { summarizeHeartbeatRunResultJson } from "../heartbeat-run-summary.js";
-import { summarizeRuntimeSkillsForTrace } from "../runtime-trace-metadata.js";
-import { buildWorkspaceReadyComment, cleanupExecutionWorkspaceArtifacts, ensureRuntimeServicesForRun, persistAdapterManagedRuntimeServices, realizeExecutionWorkspace, releaseRuntimeServicesForRun, } from "../workspace-runtime.js";
 import { issueService } from "../issues.js";
 import { documentService } from "../documents.js";
-import { buildIssueConvergenceReviewWakeupOptions, buildIssueReviewCloseoutWakeupOptions, } from "../issue-review-wakeup.js";
 import { executionWorkspaceService } from "../execution-workspaces.js";
 import { buildObservedRunLangfuseScores } from "../run-intelligence.js";
 import { workspaceOperationService } from "../workspace-operations.js";
-import { isManagedWorkspaceConfigurationError, isWorkspacePermissionPreflightError, preflightManagedAgentWorkspace, } from "../managed-workspace-preflight.js";
-import { buildExecutionWorkspaceAdapterConfig, issueExecutionWorkspaceModeForPersistedWorkspace, parseIssueExecutionWorkspaceSettings, parseProjectExecutionWorkspacePolicy, resolveExecutionWorkspaceMode, } from "../execution-workspace-policy.js";
 import { instanceSettingsService } from "../instance-settings.js";
-import { logActivity } from "../activity-log.js";
 import { redactCurrentUserText, redactCurrentUserValue } from "../../log-redaction.js";
-import { hasSessionCompactionThresholds, resolveSessionCompactionPolicy, } from "@rudderhq/agent-runtime-utils";
-import { buildIssueDocumentsPrompt } from "@rudderhq/agent-runtime-utils/server-utils";
+import { hasSessionCompactionThresholds, } from "@rudderhq/agent-runtime-utils";
 import { buildCreateAgentBenchmarkTags, coerceCreateAgentBenchmarkMetadata, extractCreateAgentBenchmarkMetadata, } from "@rudderhq/run-intelligence-core";
-import { executeAdapterWithModelFallbacks } from "./model-fallback.js";
 export { prioritizeProjectWorkspaceCandidatesForRun } from "../agent-run-context.js";
-const MAX_LIVE_LOG_CHUNK_BYTES = 8 * 1024;
-const HEARTBEAT_MAX_CONCURRENT_RUNS_DEFAULT = AGENT_RUN_CONCURRENCY_DEFAULT;
-const HEARTBEAT_MAX_CONCURRENT_RUNS_MIN = AGENT_RUN_CONCURRENCY_MIN;
-const HEARTBEAT_MAX_CONCURRENT_RUNS_MAX = AGENT_RUN_CONCURRENCY_MAX;
-const DEFERRED_WAKE_CONTEXT_KEY = "_paperclipWakeContext";
-const DETACHED_PROCESS_ERROR_CODE = "process_detached";
-const ORPHANED_PROCESS_TERMINATION_GRACE_MS = 2_000;
-const ORPHANED_PROCESS_KILL_WAIT_MS = 500;
-const ORPHANED_PROCESS_POLL_INTERVAL_MS = 100;
-const startLocksByAgent = new Map();
-const MAX_RECOVERY_CHAIN_DEPTH = 8;
-const ISSUE_PASSIVE_FOLLOWUP_REASON = "issue_passive_followup";
-const ISSUE_PASSIVE_FOLLOWUP_WAKE_SOURCE = "passive_issue_followup";
-const ISSUE_PASSIVE_FOLLOWUP_FAILURE_REASON = "missing_closure";
-const ISSUE_PASSIVE_FOLLOWUP_MAX_ATTEMPTS = 2;
-const ISSUE_REVIEW_CLOSEOUT_REASON = "issue_review_closeout_missing";
-const ISSUE_REVIEW_CLOSEOUT_FAILURE_REASON = "missing_review_decision";
-const ISSUE_REVIEW_CLOSEOUT_MAX_ATTEMPTS = 2;
-const ISSUE_PASSIVE_FOLLOWUP_COOLDOWN_MS_BY_ATTEMPT = new Map([
-    [1, 2 * 60 * 1000],
-    [2, 5 * 60 * 1000],
-]);
-const ISSUE_PASSIVE_FOLLOWUP_TIMER_CONTINUITY_MAX_WINDOW_MS = 15 * 60 * 1000;
-const SESSIONED_LOCAL_ADAPTERS = new Set([
-    "claude_local",
-    "codex_local",
-    "cursor",
-    "gemini_local",
-    "opencode_local",
-    "pi_local",
-]);
-const heartbeatRunListColumns = {
-    id: heartbeatRuns.id,
-    orgId: heartbeatRuns.orgId,
-    agentId: heartbeatRuns.agentId,
-    invocationSource: heartbeatRuns.invocationSource,
-    triggerDetail: heartbeatRuns.triggerDetail,
-    status: heartbeatRuns.status,
-    startedAt: heartbeatRuns.startedAt,
-    finishedAt: heartbeatRuns.finishedAt,
-    error: heartbeatRuns.error,
-    wakeupRequestId: heartbeatRuns.wakeupRequestId,
-    exitCode: heartbeatRuns.exitCode,
-    signal: heartbeatRuns.signal,
-    usageJson: heartbeatRuns.usageJson,
-    resultJson: heartbeatRuns.resultJson,
-    sessionIdBefore: heartbeatRuns.sessionIdBefore,
-    sessionIdAfter: heartbeatRuns.sessionIdAfter,
-    logStore: heartbeatRuns.logStore,
-    logRef: heartbeatRuns.logRef,
-    logBytes: heartbeatRuns.logBytes,
-    logSha256: heartbeatRuns.logSha256,
-    logCompressed: heartbeatRuns.logCompressed,
-    stdoutExcerpt: sql `NULL`.as("stdoutExcerpt"),
-    stderrExcerpt: sql `NULL`.as("stderrExcerpt"),
-    errorCode: heartbeatRuns.errorCode,
-    externalRunId: heartbeatRuns.externalRunId,
-    processPid: heartbeatRuns.processPid,
-    processStartedAt: heartbeatRuns.processStartedAt,
-    retryOfRunId: heartbeatRuns.retryOfRunId,
-    processLossRetryCount: heartbeatRuns.processLossRetryCount,
-    contextSnapshot: heartbeatRuns.contextSnapshot,
-    createdAt: heartbeatRuns.createdAt,
-    updatedAt: heartbeatRuns.updatedAt,
-};
-function appendExcerpt(prev, chunk) {
-    return appendWithCap(prev, chunk, MAX_EXCERPT_BYTES);
-}
-function appendTranscriptEntriesFromChunk(input) {
-    const combined = `${input.buffer}${input.chunk}`;
-    const lines = combined.split(/\r?\n/);
-    const trailing = lines.pop() ?? "";
-    const completeLines = input.finalize && trailing ? [...lines, trailing] : lines;
-    for (const line of completeLines) {
-        if (!line.trim())
-            continue;
-        const ts = new Date().toISOString();
-        const parsed = input.parser ? input.parser(line, ts) : [];
-        if (parsed.length > 0) {
-            input.transcript.push(...parsed);
-            continue;
-        }
-        input.transcript.push({
-            kind: input.kind,
-            ts,
-            text: line,
-        });
-    }
-    return input.finalize ? "" : trailing;
-}
-function normalizeMaxConcurrentRuns(value) {
-    const parsed = Math.floor(asNumber(value, HEARTBEAT_MAX_CONCURRENT_RUNS_DEFAULT));
-    if (!Number.isFinite(parsed))
-        return HEARTBEAT_MAX_CONCURRENT_RUNS_DEFAULT;
-    return Math.max(HEARTBEAT_MAX_CONCURRENT_RUNS_MIN, Math.min(HEARTBEAT_MAX_CONCURRENT_RUNS_MAX, parsed));
-}
-async function withAgentStartLock(agentId, fn) {
-    const previous = startLocksByAgent.get(agentId) ?? Promise.resolve();
-    const run = previous.then(fn);
-    const marker = run.then(() => undefined, () => undefined);
-    startLocksByAgent.set(agentId, marker);
-    try {
-        return await run;
-    }
-    finally {
-        if (startLocksByAgent.get(agentId) === marker) {
-            startLocksByAgent.delete(agentId);
-        }
-    }
-}
-function readNonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value : null;
-}
-export function resolveHeartbeatObservabilitySurface(contextSnapshot) {
-    return readNonEmptyString(contextSnapshot?.issueId) ? "issue_run" : "heartbeat_run";
-}
-function buildHeartbeatObservationName(run, agentName) {
-    const contextSnapshot = parseObject(run.contextSnapshot);
-    const issueId = readNonEmptyString(contextSnapshot.issueId);
-    return issueId ? `issue_run:${issueId}` : `heartbeat:${agentName}`;
-}
-function compactTraceText(value, maxLength = 120) {
-    const next = value?.replace(/\s+/g, " ").trim();
-    if (!next)
-        return null;
-    return next.length > maxLength ? `${next.slice(0, maxLength - 1)}…` : next;
-}
-export function buildIssueRunTraceName(input) {
-    const issueTitle = compactTraceText(input.issueTitle);
-    return issueTitle ? `issue_run:${issueTitle} [${input.issueId}]` : `issue_run:[${input.issueId}]`;
-}
-export function buildHeartbeatRuntimeTraceMetadata(input) {
-    const instructionsFilePath = readNonEmptyString(input.runtimeConfig.instructionsFilePath);
-    return {
-        instructionsConfigured: Boolean(instructionsFilePath),
-        instructionsFilePath,
-        ...summarizeRuntimeSkillsForTrace(input.runtimeSkills),
-        ...(input.adapterMeta
-            ? {
-                runtimeAgentType: input.adapterMeta.agentRuntimeType,
-                runtimeCommand: input.adapterMeta.command,
-                runtimeCwd: input.adapterMeta.cwd ?? null,
-                runtimeCommandNotes: input.adapterMeta.commandNotes ?? [],
-                runtimePromptMetrics: input.adapterMeta.promptMetrics ?? null,
-            }
-            : {}),
-    };
-}
-export function buildHeartbeatAdapterInvokePayload(input) {
-    const explicitUsedSkills = Array.isArray(input.meta.usedSkills)
-        ? input.meta.usedSkills
-            .map((entry) => normalizeLoadedSkill(entry))
-            .filter((entry) => Boolean(entry))
-        : [];
-    const promptRequestedSkills = inferUsedSkillsFromPrompt(input.meta.prompt, input.runtimeSkills);
-    const loadedSkills = Array.isArray(input.meta.loadedSkills) && input.meta.loadedSkills.length > 0
-        ? input.meta.loadedSkills
-            .map((entry) => normalizeLoadedSkillForPayload(entry))
-            .filter((entry) => Boolean(entry))
-        : input.runtimeSkills
-            .map((entry) => ({
-            key: entry.key,
-            runtimeName: entry.runtimeName ?? null,
-            name: entry.name ?? null,
-            description: entry.description ?? null,
-        }));
-    const loadedSkillEvidence = loadedSkills
-        .map((entry) => normalizeLoadedSkill(entry))
-        .filter((entry) => Boolean(entry));
-    const skillEvidence = resolveSkillEvidence({
-        usedSkills: explicitUsedSkills,
-        requestedSkills: promptRequestedSkills,
-        loadedSkills: loadedSkillEvidence,
-    });
-    return {
-        ...input.meta,
-        ...summarizeRuntimeSkillsForTrace(input.runtimeSkills),
-        loadedSkillCount: loadedSkills.length,
-        loadedSkillKeys: loadedSkills.map((entry) => entry.key),
-        loadedSkills,
-        usedSkillCount: explicitUsedSkills.length,
-        usedSkillKeys: explicitUsedSkills.map((entry) => entry.key),
-        usedSkills: explicitUsedSkills,
-        promptRequestedSkillCount: promptRequestedSkills.length,
-        promptRequestedSkillKeys: promptRequestedSkills.map((entry) => entry.key),
-        promptRequestedSkills,
-        skillEvidenceType: skillEvidence.evidence,
-        skillEvidenceCount: skillEvidence.skills.length,
-        skillEvidenceKeys: skillEvidence.skills.map((entry) => entry.key),
-        skillEvidenceSkills: skillEvidence.skills,
-    };
-}
-function buildRecentDateKeys(windowDays, now) {
-    return Array.from({ length: windowDays }, (_, index) => {
-        const next = new Date(now);
-        next.setUTCDate(next.getUTCDate() - (windowDays - 1 - index));
-        return next.toISOString().slice(0, 10);
-    });
-}
-function buildDateKeysBetween(startDate, endDate) {
-    const start = new Date(`${startDate}T00:00:00.000Z`);
-    const end = new Date(`${endDate}T00:00:00.000Z`);
-    if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime()) || start.getTime() > end.getTime()) {
-        return [];
-    }
-    const days = [];
-    const cursor = new Date(start);
-    while (cursor.getTime() <= end.getTime()) {
-        days.push(cursor.toISOString().slice(0, 10));
-        cursor.setUTCDate(cursor.getUTCDate() + 1);
-    }
-    return days;
-}
-function fallbackSkillLabel(key) {
-    const trimmed = key.trim();
-    if (!trimmed)
-        return "unknown";
-    const slashSegments = trimmed.split("/").filter(Boolean);
-    const lastSlashSegment = slashSegments.at(-1);
-    if (lastSlashSegment)
-        return lastSlashSegment;
-    const colonSegments = trimmed.split(":").filter(Boolean);
-    return colonSegments.at(-1) ?? trimmed;
-}
-function normalizeLoadedSkill(value) {
-    const skill = parseObject(value);
-    const rawKey = readNonEmptyString(skill.key);
-    const rawRuntimeName = readNonEmptyString(skill.runtimeName);
-    const rawName = readNonEmptyString(skill.name);
-    const key = rawKey ?? rawRuntimeName ?? rawName;
-    if (!key)
-        return null;
-    const label = rawRuntimeName ?? rawName ?? fallbackSkillLabel(key);
-    return { key, label };
-}
-function normalizeLoadedSkillForPayload(value) {
-    const skill = parseObject(value);
-    const rawKey = readNonEmptyString(skill.key);
-    const rawRuntimeName = readNonEmptyString(skill.runtimeName);
-    const rawName = readNonEmptyString(skill.name);
-    const key = rawKey ?? rawRuntimeName ?? rawName;
-    if (!key)
-        return null;
-    return {
-        key,
-        runtimeName: rawRuntimeName ?? null,
-        name: rawName ?? null,
-        description: readNonEmptyString(skill.description) ?? null,
-    };
-}
-function emptySkillEvidenceCounts() {
-    return { used: 0, requested: 0, loaded: 0 };
-}
-function incrementSkillEvidenceCount(counts, evidence) {
-    counts[evidence] += 1;
-}
-function strongestSkillEvidence(left, right) {
-    const rank = {
-        used: 3,
-        requested: 2,
-        loaded: 1,
-    };
-    return rank[right] > rank[left] ? right : left;
-}
-function resolveSkillEvidence(input) {
-    if (input.usedSkills.length > 0)
-        return { evidence: "used", skills: input.usedSkills };
-    if (input.requestedSkills.length > 0)
-        return { evidence: "requested", skills: input.requestedSkills };
-    return { evidence: "loaded", skills: [] };
-}
-function readSkillEvidenceFromPayload(payload) {
-    const loadedSkills = Array.isArray(payload.loadedSkills)
-        ? payload.loadedSkills
-            .map((entry) => normalizeLoadedSkill(entry))
-            .filter((entry) => Boolean(entry))
-        : [];
-    const usedSkills = Array.isArray(payload.usedSkills)
-        ? payload.usedSkills
-            .map((entry) => normalizeLoadedSkill(entry))
-            .filter((entry) => Boolean(entry))
-        : [];
-    const requestedSkills = Array.isArray(payload.promptRequestedSkills)
-        ? payload.promptRequestedSkills
-            .map((entry) => normalizeLoadedSkill(entry))
-            .filter((entry) => Boolean(entry))
-        : inferUsedSkillsFromPrompt(payload.prompt, loadedSkills);
-    return resolveSkillEvidence({ usedSkills, requestedSkills, loadedSkills });
-}
-function extractSkillSlugFromPath(value) {
-    const normalized = value.trim().replace(/\\/g, "/").replace(/[?#].*$/u, "").replace(/\/+$/u, "");
-    if (!normalized.endsWith("/SKILL.md"))
-        return null;
-    const parts = normalized.split("/").filter(Boolean);
-    if (parts.length < 2)
-        return null;
-    const slug = parts.at(-2);
-    if (!slug || slug === "." || slug === "..")
-        return null;
-    return slug;
-}
-function collectSkillPathsFromText(value) {
-    const paths = [];
-    const pattern = /(?:^|[\s"'`(=])((?:\.{1,2}\/|~\/|\/)?(?:[^\s"'`()<>|;&/]+\/)+SKILL\.md(?:[?#][^\s"'`()<>|;&]*)?)(?=$|[\s"'`()<>|;&])/giu;
-    for (const match of value.matchAll(pattern)) {
-        const pathValue = match[1]?.trim();
-        if (pathValue)
-            paths.push(pathValue);
-    }
-    return paths;
-}
-function collectStringValues(value, depth = 0) {
-    if (depth > 4)
-        return [];
-    if (typeof value === "string")
-        return [value];
-    if (Array.isArray(value))
-        return value.flatMap((entry) => collectStringValues(entry, depth + 1));
-    const record = parseObject(value);
-    return Object.values(record).flatMap((entry) => collectStringValues(entry, depth + 1));
-}
-function normalizeSkillUseFromPath(value) {
-    const slug = extractSkillSlugFromPath(value);
-    if (!slug)
-        return null;
-    return { key: slug, label: slug };
-}
-function dedupeSkillUses(skills) {
-    const seen = new Set();
-    const result = [];
-    for (const skill of skills) {
-        const normalized = normalizeLoadedSkill(skill);
-        if (!normalized || seen.has(normalized.key))
-            continue;
-        seen.add(normalized.key);
-        result.push(normalized);
-    }
-    return result;
-}
-function collectSkillUsesFromText(value) {
-    return collectSkillPathsFromText(value)
-        .map((entry) => normalizeSkillUseFromPath(entry))
-        .filter((entry) => Boolean(entry));
-}
-function readToolCommandInput(input) {
-    if (typeof input === "string")
-        return input;
-    const record = parseObject(input);
-    return readNonEmptyString(record.command) ?? readNonEmptyString(record.cmd);
-}
-function isCommandTranscriptTool(name) {
-    const normalized = name.trim().toLowerCase();
-    return ["command_execution", "shell", "shelltoolcall", "bash"].includes(normalized);
-}
-function isReadTranscriptTool(name) {
-    const normalized = name.trim().toLowerCase();
-    if (isCommandTranscriptTool(normalized))
-        return true;
-    if (/(?:^|[_-])(read|fetch|open|cat)(?:$|[_-])/.test(normalized))
-        return true;
-    return false;
-}
-function inferUsedSkillsFromTranscript(transcript) {
-    const skills = [];
-    for (const entry of transcript) {
-        if (entry.kind !== "tool_call")
-            continue;
-        if (!isReadTranscriptTool(entry.name))
-            continue;
-        const command = readToolCommandInput(entry.input);
-        if (command) {
-            skills.push(...collectSkillUsesFromText(command));
-            continue;
-        }
-        for (const value of collectStringValues(entry.input)) {
-            skills.push(...collectSkillUsesFromText(value));
-        }
-    }
-    return dedupeSkillUses(skills);
-}
-function normalizeSkillCandidate(value) {
-    return value
-        ?.trim()
-        .replace(/^\$/u, "")
-        .replace(/[?#].*$/u, "")
-        .replace(/\/+$/u, "")
-        .toLowerCase() || "";
-}
-function addSkillCandidate(candidates, value) {
-    const normalized = normalizeSkillCandidate(value);
-    if (!normalized)
-        return;
-    candidates.add(normalized);
-    const lastSegment = normalized.split(/[/:]/u).filter(Boolean).at(-1);
-    if (lastSegment)
-        candidates.add(lastSegment);
-}
-function readSkillReferenceSlug(href) {
-    const normalized = href.trim().replace(/[?#].*$/u, "").replace(/\/+$/u, "");
-    if (!normalized)
-        return null;
-    if (normalized.endsWith("/SKILL.md")) {
-        return normalized.slice(0, -"/SKILL.md".length).split("/").filter(Boolean).at(-1) ?? null;
-    }
-    if (normalized.toLowerCase().endsWith(".md")) {
-        const fileName = normalized.split("/").filter(Boolean).at(-1) ?? "";
-        return fileName.replace(/\.md$/iu, "") || null;
-    }
-    return null;
-}
-function collectSkillReferences(prompt) {
-    const references = [];
-    const pattern = /\[([^\]\n]+)\]\(([^)\n]+(?:\/SKILL\.md|\.md)(?:[?#][^)\n]*)?)\)/giu;
-    for (const match of prompt.matchAll(pattern)) {
-        const rawLabel = match[1]?.trim() ?? "";
-        const href = match[2]?.trim() ?? "";
-        if (!rawLabel || !href)
-            continue;
-        const labelWithoutPrefix = rawLabel.replace(/^\$/u, "").trim();
-        const slug = readSkillReferenceSlug(href);
-        const isExplicitSkillToken = rawLabel.startsWith("$") || href.replace(/[?#].*$/u, "").endsWith("/SKILL.md");
-        if (!isExplicitSkillToken)
-            continue;
-        const key = labelWithoutPrefix || slug;
-        if (!key)
-            continue;
-        const label = slug ?? fallbackSkillLabel(key);
-        const candidates = new Set();
-        addSkillCandidate(candidates, labelWithoutPrefix);
-        addSkillCandidate(candidates, slug);
-        addSkillCandidate(candidates, href);
-        references.push({ key, label, candidates });
-    }
-    return references;
-}
-function inferUsedSkillsFromPrompt(prompt, loadedSkills) {
-    const promptText = readNonEmptyString(prompt);
-    if (!promptText)
-        return [];
-    const references = collectSkillReferences(promptText);
-    if (references.length === 0)
-        return [];
-    const loaded = loadedSkills
-        .map((entry) => normalizeLoadedSkill(entry))
-        .filter((entry) => Boolean(entry))
-        .map((entry) => {
-        const candidates = new Set();
-        addSkillCandidate(candidates, entry.key);
-        addSkillCandidate(candidates, entry.label);
-        return { ...entry, candidates };
-    });
-    const used = new Map();
-    for (const reference of references) {
-        const matched = loaded.find((entry) => {
-            for (const candidate of reference.candidates) {
-                if (entry.candidates.has(candidate))
-                    return true;
-            }
-            return false;
-        });
-        const normalized = matched ?? { key: reference.key, label: reference.label };
-        if (!used.has(normalized.key))
-            used.set(normalized.key, normalized);
-    }
-    return Array.from(used.values());
-}
-function normalizeLedgerBillingType(value) {
-    const raw = readNonEmptyString(value);
-    switch (raw) {
-        case "api":
-        case "metered_api":
-            return "metered_api";
-        case "subscription":
-        case "subscription_included":
-            return "subscription_included";
-        case "subscription_overage":
-            return "subscription_overage";
-        case "credits":
-            return "credits";
-        case "fixed":
-            return "fixed";
-        default:
-            return "unknown";
-    }
-}
-function resolveLedgerBiller(result) {
-    return readNonEmptyString(result.biller) ?? readNonEmptyString(result.provider) ?? "unknown";
-}
-function normalizeBilledCostCents(costUsd, billingType) {
-    if (billingType === "subscription_included")
-        return 0;
-    if (typeof costUsd !== "number" || !Number.isFinite(costUsd))
-        return 0;
-    return Math.max(0, Math.round(costUsd * 100));
-}
-async function resolveLedgerScopeForRun(db, orgId, run) {
-    const context = parseObject(run.contextSnapshot);
-    const contextIssueId = readNonEmptyString(context.issueId);
-    const contextProjectId = readNonEmptyString(context.projectId);
-    if (!contextIssueId) {
-        return {
-            issueId: null,
-            projectId: contextProjectId,
-        };
-    }
-    const issue = await db
-        .select({
-        id: issues.id,
-        projectId: issues.projectId,
-    })
-        .from(issues)
-        .where(and(eq(issues.id, contextIssueId), eq(issues.orgId, orgId)))
-        .then((rows) => rows[0] ?? null);
-    return {
-        issueId: issue?.id ?? null,
-        projectId: issue?.projectId ?? contextProjectId,
-    };
-}
-export function buildExplicitResumeSessionOverride(input) {
-    const desiredDisplayId = truncateDisplayId(input.resumeRunSessionIdAfter ?? input.resumeRunSessionIdBefore);
-    const taskSessionParams = normalizeSessionParams(input.sessionCodec.deserialize(input.taskSession?.sessionParamsJson ?? null));
-    const taskSessionDisplayId = truncateDisplayId(input.taskSession?.sessionDisplayId ??
-        (input.sessionCodec.getDisplayId ? input.sessionCodec.getDisplayId(taskSessionParams) : null) ??
-        readNonEmptyString(taskSessionParams?.sessionId));
-    const canReuseTaskSessionParams = input.taskSession != null &&
-        (input.taskSession.lastRunId === input.resumeFromRunId ||
-            (!!desiredDisplayId && taskSessionDisplayId === desiredDisplayId));
-    const sessionParams = canReuseTaskSessionParams
-        ? taskSessionParams
-        : desiredDisplayId
-            ? { sessionId: desiredDisplayId }
-            : null;
-    const sessionDisplayId = desiredDisplayId ?? (canReuseTaskSessionParams ? taskSessionDisplayId : null);
-    if (!sessionDisplayId && !sessionParams)
-        return null;
-    return {
-        sessionDisplayId,
-        sessionParams,
-    };
-}
-function normalizeUsageTotals(usage) {
-    if (!usage)
-        return null;
-    return {
-        inputTokens: Math.max(0, Math.floor(asNumber(usage.inputTokens, 0))),
-        cachedInputTokens: Math.max(0, Math.floor(asNumber(usage.cachedInputTokens, 0))),
-        outputTokens: Math.max(0, Math.floor(asNumber(usage.outputTokens, 0))),
-    };
-}
-function readRawUsageTotals(usageJson) {
-    const parsed = parseObject(usageJson);
-    if (Object.keys(parsed).length === 0)
-        return null;
-    const inputTokens = Math.max(0, Math.floor(asNumber(parsed.rawInputTokens, asNumber(parsed.inputTokens, 0))));
-    const cachedInputTokens = Math.max(0, Math.floor(asNumber(parsed.rawCachedInputTokens, asNumber(parsed.cachedInputTokens, 0))));
-    const outputTokens = Math.max(0, Math.floor(asNumber(parsed.rawOutputTokens, asNumber(parsed.outputTokens, 0))));
-    if (inputTokens <= 0 && cachedInputTokens <= 0 && outputTokens <= 0) {
-        return null;
-    }
-    return {
-        inputTokens,
-        cachedInputTokens,
-        outputTokens,
-    };
-}
-function deriveNormalizedUsageDelta(current, previous) {
-    if (!current)
-        return null;
-    if (!previous)
-        return { ...current };
-    const inputTokens = current.inputTokens >= previous.inputTokens
-        ? current.inputTokens - previous.inputTokens
-        : current.inputTokens;
-    const cachedInputTokens = current.cachedInputTokens >= previous.cachedInputTokens
-        ? current.cachedInputTokens - previous.cachedInputTokens
-        : current.cachedInputTokens;
-    const outputTokens = current.outputTokens >= previous.outputTokens
-        ? current.outputTokens - previous.outputTokens
-        : current.outputTokens;
-    return {
-        inputTokens: Math.max(0, inputTokens),
-        cachedInputTokens: Math.max(0, cachedInputTokens),
-        outputTokens: Math.max(0, outputTokens),
-    };
-}
-function formatCount(value) {
-    if (typeof value !== "number" || !Number.isFinite(value))
-        return "0";
-    return value.toLocaleString("en-US");
-}
-export function parseSessionCompactionPolicy(agent) {
-    return resolveSessionCompactionPolicy(agent.agentRuntimeType, agent.runtimeConfig).policy;
-}
-export function resolveRuntimeSessionParamsForWorkspace(input) {
-    const { orgId, agent, previousSessionParams, resolvedWorkspace } = input;
-    const previousSessionId = readNonEmptyString(previousSessionParams?.sessionId);
-    if (!previousSessionId) {
-        return {
-            sessionParams: previousSessionParams,
-            warning: null,
-        };
-    }
-    const canonicalAgentCwd = readNonEmptyString(resolvedWorkspace.cwd) ?? resolveDefaultAgentWorkspaceDir(orgId, agent);
-    if (!canonicalAgentCwd) {
-        return {
-            sessionParams: previousSessionParams,
-            warning: null,
-        };
-    }
-    const previousCwd = readNonEmptyString(previousSessionParams?.cwd);
-    if (previousCwd && path.resolve(previousCwd) === path.resolve(canonicalAgentCwd)) {
-        return {
-            sessionParams: previousSessionParams,
-            warning: null,
-        };
-    }
-    const previousWorkspaceId = readNonEmptyString(previousSessionParams?.workspaceId);
-    const migratedSessionParams = {
-        ...(previousSessionParams ?? {}),
-        cwd: canonicalAgentCwd,
-    };
-    if (!previousWorkspaceId ||
-        !resolvedWorkspace.workspaceId ||
-        previousWorkspaceId === resolvedWorkspace.workspaceId) {
-        if (resolvedWorkspace.workspaceId)
-            migratedSessionParams.workspaceId = resolvedWorkspace.workspaceId;
-        if (resolvedWorkspace.repoUrl)
-            migratedSessionParams.repoUrl = resolvedWorkspace.repoUrl;
-        if (resolvedWorkspace.repoRef)
-            migratedSessionParams.repoRef = resolvedWorkspace.repoRef;
-    }
-    return {
-        sessionParams: migratedSessionParams,
-        warning: previousCwd
-            ? `Agent workspace "${canonicalAgentCwd}" is now the canonical run workspace. ` +
-                `Attempting to resume session "${previousSessionId}" that was previously saved in "${previousCwd}".`
-            : `Agent workspace "${canonicalAgentCwd}" is now the canonical run workspace. ` +
-                `Attempting to resume session "${previousSessionId}" with the canonical agent workspace attached.`,
-    };
-}
-function parseIssueAssigneeAgentRuntimeOverrides(raw) {
-    const parsed = parseObject(raw);
-    const parsedAdapterConfig = parseObject(parsed.agentRuntimeConfig);
-    const agentRuntimeConfig = Object.keys(parsedAdapterConfig).length > 0 ? parsedAdapterConfig : null;
-    const useProjectWorkspace = typeof parsed.useProjectWorkspace === "boolean"
-        ? parsed.useProjectWorkspace
-        : null;
-    if (!agentRuntimeConfig && useProjectWorkspace === null)
-        return null;
-    return {
-        agentRuntimeConfig,
-        useProjectWorkspace,
-    };
-}
-function deriveTaskKey(contextSnapshot, payload) {
-    return (readNonEmptyString(contextSnapshot?.taskKey) ??
-        readNonEmptyString(contextSnapshot?.taskId) ??
-        readNonEmptyString(contextSnapshot?.issueId) ??
-        readNonEmptyString(payload?.taskKey) ??
-        readNonEmptyString(payload?.taskId) ??
-        readNonEmptyString(payload?.issueId) ??
-        null);
-}
-export function shouldResetTaskSessionForWake(contextSnapshot) {
-    if (contextSnapshot?.forceFreshSession === true)
-        return true;
-    const wakeReason = readNonEmptyString(contextSnapshot?.wakeReason);
-    if (wakeReason === "issue_assigned")
-        return true;
-    return false;
-}
-export function formatRuntimeWorkspaceWarningLog(warning) {
-    return {
-        stream: "stdout",
-        chunk: `[rudder] ${warning}\n`,
-    };
-}
-function describeSessionResetReason(contextSnapshot) {
-    if (contextSnapshot?.forceFreshSession === true)
-        return "forceFreshSession was requested";
-    const wakeReason = readNonEmptyString(contextSnapshot?.wakeReason);
-    if (wakeReason === "issue_assigned")
-        return "wake reason is issue_assigned";
-    return null;
-}
-function deriveCommentId(contextSnapshot, payload) {
-    return (readNonEmptyString(contextSnapshot?.wakeCommentId) ??
-        readNonEmptyString(contextSnapshot?.commentId) ??
-        readNonEmptyString(payload?.commentId) ??
-        null);
-}
-function enrichWakeContextSnapshot(input) {
-    const { contextSnapshot, reason, source, triggerDetail, payload } = input;
-    const issueIdFromPayload = readNonEmptyString(payload?.["issueId"]);
-    const commentIdFromPayload = readNonEmptyString(payload?.["commentId"]);
-    const taskKey = deriveTaskKey(contextSnapshot, payload);
-    const wakeCommentId = deriveCommentId(contextSnapshot, payload);
-    if (!readNonEmptyString(contextSnapshot["wakeReason"]) && reason) {
-        contextSnapshot.wakeReason = reason;
-    }
-    if (!readNonEmptyString(contextSnapshot["issueId"]) && issueIdFromPayload) {
-        contextSnapshot.issueId = issueIdFromPayload;
-    }
-    if (!readNonEmptyString(contextSnapshot["taskId"]) && issueIdFromPayload) {
-        contextSnapshot.taskId = issueIdFromPayload;
-    }
-    if (!readNonEmptyString(contextSnapshot["taskKey"]) && taskKey) {
-        contextSnapshot.taskKey = taskKey;
-    }
-    if (!readNonEmptyString(contextSnapshot["commentId"]) && commentIdFromPayload) {
-        contextSnapshot.commentId = commentIdFromPayload;
-    }
-    if (!readNonEmptyString(contextSnapshot["wakeCommentId"]) && wakeCommentId) {
-        contextSnapshot.wakeCommentId = wakeCommentId;
-    }
-    if (!readNonEmptyString(contextSnapshot["wakeSource"]) && source) {
-        contextSnapshot.wakeSource = source;
-    }
-    if (!readNonEmptyString(contextSnapshot["wakeTriggerDetail"]) && triggerDetail) {
-        contextSnapshot.wakeTriggerDetail = triggerDetail;
-    }
-    return {
-        contextSnapshot,
-        issueIdFromPayload,
-        commentIdFromPayload,
-        taskKey,
-        wakeCommentId,
-    };
-}
-function mergeCoalescedContextSnapshot(existingRaw, incoming) {
-    const existing = parseObject(existingRaw);
-    const merged = {
-        ...existing,
-        ...incoming,
-    };
-    const commentId = deriveCommentId(incoming, null);
-    if (commentId) {
-        merged.commentId = commentId;
-        merged.wakeCommentId = commentId;
-    }
-    return merged;
-}
-function issueCommentAuthorKind(comment) {
-    if (comment.authorAgentId)
-        return "agent";
-    if (comment.authorUserId)
-        return "user";
-    return "system";
-}
-function issueCommentAuthorLabel(comment) {
-    if (comment.authorAgentId) {
-        return comment.authorAgentName?.trim() || `Agent ${comment.authorAgentId.slice(0, 8)}`;
-    }
-    if (comment.authorUserId) {
-        return comment.authorUserName?.trim() || `User ${comment.authorUserId.slice(0, 8)}`;
-    }
-    return "System";
-}
-function buildDeferredWakePayload(payload, contextSnapshot, issueId) {
-    const deferredPayload = { ...(payload ?? {}) };
-    if (issueId && !readNonEmptyString(deferredPayload.issueId)) {
-        deferredPayload.issueId = issueId;
-    }
-    deferredPayload[DEFERRED_WAKE_CONTEXT_KEY] = contextSnapshot;
-    return deferredPayload;
-}
-function readDeferredWakeContext(payloadRaw) {
-    const payload = parseObject(payloadRaw);
-    return parseObject(payload[DEFERRED_WAKE_CONTEXT_KEY]);
-}
-function readDeferredWakePayload(payloadRaw) {
-    const payload = parseObject(payloadRaw);
-    delete payload[DEFERRED_WAKE_CONTEXT_KEY];
-    return payload;
-}
-function deriveDeferredWakeTaskKey(payloadRaw) {
-    const payload = readDeferredWakePayload(payloadRaw);
-    const contextSnapshot = readDeferredWakeContext(payloadRaw);
-    return deriveTaskKey(contextSnapshot, payload);
-}
-async function hydrateWakeContextSnapshot(db, orgId, contextSnapshot) {
-    const issueId = readNonEmptyString(contextSnapshot.issueId);
-    const commentId = deriveCommentId(contextSnapshot, null);
-    const issueContext = parseObject(contextSnapshot.issue);
-    const commentContext = parseObject(contextSnapshot.comment);
-    const needsIssueContext = !!issueId &&
-        (!readNonEmptyString(issueContext.id) ||
-            !readNonEmptyString(issueContext.title) ||
-            !readNonEmptyString(issueContext.status) ||
-            !("priority" in issueContext) ||
-            !("description" in issueContext));
-    const needsProjectId = !!issueId && !readNonEmptyString(contextSnapshot.projectId);
-    const needsCommentContext = !!commentId &&
-        (!readNonEmptyString(commentContext.id) ||
-            !readNonEmptyString(commentContext.body) ||
-            !readNonEmptyString(commentContext.authorKind) ||
-            !readNonEmptyString(commentContext.authorLabel) ||
-            !readNonEmptyString(commentContext.createdAt));
-    if (!needsIssueContext && !needsProjectId && !needsCommentContext)
-        return;
-    if (issueId && (needsIssueContext || needsProjectId)) {
-        const issueRow = await db
-            .select({
-            id: issues.id,
-            title: issues.title,
-            description: issues.description,
-            status: issues.status,
-            priority: issues.priority,
-            projectId: issues.projectId,
-        })
-            .from(issues)
-            .where(and(eq(issues.id, issueId), eq(issues.orgId, orgId)))
-            .then((rows) => rows[0] ?? null);
-        if (issueRow) {
-            contextSnapshot.issue = {
-                ...issueContext,
-                id: readNonEmptyString(issueContext.id) ?? issueRow.id,
-                title: readNonEmptyString(issueContext.title) ?? issueRow.title,
-                description: "description" in issueContext ? issueContext.description : issueRow.description,
-                status: readNonEmptyString(issueContext.status) ?? issueRow.status,
-                priority: "priority" in issueContext ? issueContext.priority : issueRow.priority,
-            };
-            if (!readNonEmptyString(contextSnapshot.projectId) && issueRow.projectId) {
-                contextSnapshot.projectId = issueRow.projectId;
-            }
-        }
-    }
-    if (commentId && needsCommentContext) {
-        const commentConditions = [eq(issueComments.id, commentId), eq(issueComments.orgId, orgId)];
-        if (issueId) {
-            commentConditions.push(eq(issueComments.issueId, issueId));
-        }
-        const commentRow = await db
-            .select({
-            id: issueComments.id,
-            body: issueComments.body,
-            authorAgentId: issueComments.authorAgentId,
-            authorUserId: issueComments.authorUserId,
-            authorAgentName: agents.name,
-            authorUserName: authUsers.name,
-            createdAt: issueComments.createdAt,
-        })
-            .from(issueComments)
-            .leftJoin(agents, eq(issueComments.authorAgentId, agents.id))
-            .leftJoin(authUsers, eq(issueComments.authorUserId, authUsers.id))
-            .where(and(...commentConditions))
-            .then((rows) => rows[0] ?? null);
-        if (commentRow) {
-            contextSnapshot.comment = {
-                ...commentContext,
-                id: readNonEmptyString(commentContext.id) ?? commentRow.id,
-                body: readNonEmptyString(commentContext.body) ?? commentRow.body,
-                authorAgentId: "authorAgentId" in commentContext ? commentContext.authorAgentId : commentRow.authorAgentId,
-                authorUserId: "authorUserId" in commentContext ? commentContext.authorUserId : commentRow.authorUserId,
-                authorKind: readNonEmptyString(commentContext.authorKind) ?? issueCommentAuthorKind(commentRow),
-                authorLabel: readNonEmptyString(commentContext.authorLabel) ?? issueCommentAuthorLabel(commentRow),
-                createdAt: readNonEmptyString(commentContext.createdAt) ?? commentRow.createdAt.toISOString(),
-            };
-        }
-    }
-}
-function firstNonEmptyLine(value) {
-    if (typeof value !== "string")
-        return null;
-    const line = value
-        .split("\n")
-        .map((chunk) => chunk.trim())
-        .find(Boolean);
-    return line ?? null;
-}
-function deriveRecoveryFailureKind(run) {
-    return (readNonEmptyString(run.errorCode) ??
-        (run.status === "timed_out" ? "timed_out" : null) ??
-        run.status);
-}
-function deriveRecoveryFailureSummary(run) {
-    return (firstNonEmptyLine(run.error) ??
-        firstNonEmptyLine(run.stderrExcerpt) ??
-        firstNonEmptyLine(run.stdoutExcerpt) ??
-        (run.status === "timed_out" ? "The run timed out before it completed." : null) ??
-        "The previous run failed before it completed.");
-}
-function mergeMissingRecoveryContextFields(target, source) {
-    const keysToBackfill = [
-        "issueId",
-        "taskId",
-        "taskKey",
-        "projectId",
-        "projectWorkspaceId",
-        "commentId",
-        "wakeCommentId",
-        "issue",
-        "comment",
-        "source",
-        "wakeSource",
-        "wakeTriggerDetail",
-    ];
-    for (const key of keysToBackfill) {
-        if (!(key in target) || target[key] === null || target[key] === undefined || target[key] === "") {
-            const value = source[key];
-            if (value !== null && value !== undefined && value !== "") {
-                target[key] = value;
-            }
-        }
-    }
-}
-async function hydrateRecoveryBaseContextSnapshot(run, getRunById) {
-    const mergedContext = { ...parseObject(run.contextSnapshot) };
-    let ancestorRunId = readNonEmptyString(run.retryOfRunId);
-    let depth = 0;
-    while (ancestorRunId && depth < MAX_RECOVERY_CHAIN_DEPTH) {
-        const ancestorRun = await getRunById(ancestorRunId);
-        if (!ancestorRun)
-            break;
-        mergeMissingRecoveryContextFields(mergedContext, parseObject(ancestorRun.contextSnapshot));
-        ancestorRunId = readNonEmptyString(ancestorRun.retryOfRunId);
-        depth += 1;
-    }
-    return mergedContext;
-}
-function buildRecoveryContextSnapshot(input) {
-    const { baseContextSnapshot, run, recoveryTrigger, wakeReason, wakeSource, triggerDetail } = input;
-    const failureKind = deriveRecoveryFailureKind(run);
-    const failureSummary = deriveRecoveryFailureSummary(run);
-    const recovery = {
-        originalRunId: run.id,
-        failureKind,
-        failureSummary,
-        recoveryTrigger,
-        recoveryMode: "continue_preferred",
-    };
-    return {
-        ...baseContextSnapshot,
-        wakeReason,
-        wakeSource,
-        wakeTriggerDetail: triggerDetail,
-        retryOfRunId: run.id,
-        retryReason: failureKind,
-        recovery,
-    };
-}
-function normalizePassiveFollowupContext(raw) {
-    const parsed = parseObject(raw);
-    const originRunId = readNonEmptyString(parsed.originRunId);
-    if (!originRunId)
-        return null;
-    const attempt = Math.max(0, Math.floor(asNumber(parsed.attempt, 0)));
-    return {
-        originRunId,
-        previousRunId: readNonEmptyString(parsed.previousRunId),
-        attempt,
-        maxAttempts: Math.max(1, Math.floor(asNumber(parsed.maxAttempts, ISSUE_PASSIVE_FOLLOWUP_MAX_ATTEMPTS))),
-        reason: ISSUE_PASSIVE_FOLLOWUP_FAILURE_REASON,
-        queuedAt: readNonEmptyString(parsed.queuedAt),
-    };
-}
-function normalizeReviewCloseoutContext(raw) {
-    const parsed = parseObject(raw);
-    const originRunId = readNonEmptyString(parsed.originRunId);
-    if (!originRunId)
-        return null;
-    const attempt = Math.max(0, Math.floor(asNumber(parsed.attempt, 0)));
-    return {
-        originRunId,
-        previousRunId: readNonEmptyString(parsed.previousRunId),
-        attempt,
-        maxAttempts: Math.max(1, Math.floor(asNumber(parsed.maxAttempts, ISSUE_REVIEW_CLOSEOUT_MAX_ATTEMPTS))),
-        reason: ISSUE_REVIEW_CLOSEOUT_FAILURE_REASON,
-    };
-}
-function passiveFollowupCooldownMs(attempt) {
-    return ISSUE_PASSIVE_FOLLOWUP_COOLDOWN_MS_BY_ATTEMPT.get(attempt) ?? 5 * 60 * 1000;
-}
-function issueHasReviewer(issue) {
-    return Boolean(issue.reviewerAgentId || issue.reviewerUserId);
-}
-function isAgentEligibleForTimerContinuation(agent) {
-    return (agent.status !== "paused" &&
-        agent.status !== "terminated" &&
-        agent.status !== "pending_approval");
-}
-function hasCredibleTimerContinuation(input) {
-    if (!input.policy.enabled || input.policy.intervalSec <= 0)
-        return false;
-    if (!isAgentEligibleForTimerContinuation(input.agent))
-        return false;
-    const intervalMs = input.policy.intervalSec * 1000;
-    const nearTermWindowMs = Math.min(intervalMs * 2, ISSUE_PASSIVE_FOLLOWUP_TIMER_CONTINUITY_MAX_WINDOW_MS);
-    const lastHeartbeatMs = input.agent.lastHeartbeatAt
-        ? new Date(input.agent.lastHeartbeatAt).getTime()
-        : new Date(input.agent.createdAt).getTime();
-    const runFinishedMs = input.run.finishedAt
-        ? new Date(input.run.finishedAt).getTime()
-        : input.now.getTime();
-    const baselineMs = Math.max(lastHeartbeatMs, runFinishedMs);
-    const nextTimerMs = baselineMs + intervalMs;
-    return Math.max(0, nextTimerMs - input.now.getTime()) <= nearTermWindowMs;
-}
-function buildPassiveFollowupContextSnapshot(input) {
-    const baseContext = { ...parseObject(input.run.contextSnapshot) };
-    delete baseContext.recovery;
-    delete baseContext.retryOfRunId;
-    delete baseContext.retryReason;
-    const taskKey = deriveTaskKey(baseContext, { issueId: input.issue.id }) ?? input.issue.id;
-    return {
-        ...baseContext,
-        issueId: input.issue.id,
-        taskId: input.issue.id,
-        taskKey,
-        projectId: readNonEmptyString(baseContext.projectId) ?? input.issue.projectId ?? undefined,
-        wakeReason: ISSUE_PASSIVE_FOLLOWUP_REASON,
-        wakeSource: ISSUE_PASSIVE_FOLLOWUP_WAKE_SOURCE,
-        wakeTriggerDetail: "system",
-        issue: {
-            id: input.issue.id,
-            title: input.issue.title,
-            description: input.issue.description,
-            status: input.issue.status,
-            priority: input.issue.priority,
-        },
-        passiveFollowup: {
-            originRunId: input.originRunId,
-            previousRunId: input.run.id,
-            attempt: input.attempt,
-            maxAttempts: ISSUE_PASSIVE_FOLLOWUP_MAX_ATTEMPTS,
-            reason: ISSUE_PASSIVE_FOLLOWUP_FAILURE_REASON,
-            queuedAt: input.now.toISOString(),
-        },
-        ...(issueHasReviewer(input.issue)
-            ? {
-                reviewGate: {
-                    reviewerAgentId: input.issue.reviewerAgentId,
-                    reviewerUserId: input.issue.reviewerUserId,
-                    closeOutRequirement: "Move the issue to in_review when work is ready, or to blocked/cancelled if it cannot proceed.",
-                },
-            }
-            : {}),
-    };
-}
-function runTaskKey(run) {
-    return deriveTaskKey(run.contextSnapshot, null);
-}
-function isSameTaskScope(left, right) {
-    return (left ?? null) === (right ?? null);
-}
-function isTrackedLocalChildProcessAdapter(agentRuntimeType) {
-    return SESSIONED_LOCAL_ADAPTERS.has(agentRuntimeType);
-}
-// A positive liveness check means some process currently owns the PID.
-// On Linux, PIDs can be recycled, so this is a best-effort signal rather
-// than proof that the original child is still alive.
-function isProcessAlive(pid) {
-    if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        const code = error?.code;
-        if (code === "EPERM")
-            return true;
-        if (code === "ESRCH")
-            return false;
-        return false;
-    }
-}
-async function waitForProcessExit(pid, timeoutMs) {
-    const deadline = Date.now() + Math.max(0, timeoutMs);
-    while (Date.now() < deadline) {
-        if (!isProcessAlive(pid))
-            return true;
-        await new Promise((resolve) => setTimeout(resolve, ORPHANED_PROCESS_POLL_INTERVAL_MS));
-    }
-    return !isProcessAlive(pid);
-}
-async function terminateOrphanedProcess(pid) {
-    if (!isProcessAlive(pid)) {
-        return {
-            stillAlive: false,
-            terminationSignal: null,
-            error: null,
-        };
-    }
-    let terminationSignal = null;
-    try {
-        process.kill(pid, "SIGTERM");
-        terminationSignal = "SIGTERM";
-    }
-    catch (error) {
-        const code = error?.code;
-        if (code === "ESRCH") {
-            return {
-                stillAlive: false,
-                terminationSignal: null,
-                error: null,
-            };
-        }
-        return {
-            stillAlive: isProcessAlive(pid),
-            terminationSignal,
-            error: `SIGTERM failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-    if (await waitForProcessExit(pid, ORPHANED_PROCESS_TERMINATION_GRACE_MS)) {
-        return {
-            stillAlive: false,
-            terminationSignal,
-            error: null,
-        };
-    }
-    try {
-        process.kill(pid, "SIGKILL");
-        terminationSignal = "SIGKILL";
-    }
-    catch (error) {
-        const code = error?.code;
-        if (code === "ESRCH") {
-            return {
-                stillAlive: false,
-                terminationSignal,
-                error: null,
-            };
-        }
-        return {
-            stillAlive: isProcessAlive(pid),
-            terminationSignal,
-            error: `SIGKILL failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-    const exitedAfterKill = await waitForProcessExit(pid, ORPHANED_PROCESS_KILL_WAIT_MS);
-    return {
-        stillAlive: !exitedAfterKill,
-        terminationSignal,
-        error: exitedAfterKill ? null : `Timed out waiting for child pid ${pid} to exit after ${terminationSignal}`,
-    };
-}
-function truncateDisplayId(value, max = 128) {
-    if (!value)
-        return null;
-    return value.length > max ? value.slice(0, max) : value;
-}
-function normalizeAgentNameKey(value) {
-    if (typeof value !== "string")
-        return null;
-    const normalized = value.trim().toLowerCase();
-    return normalized.length > 0 ? normalized : null;
-}
-const defaultSessionCodec = {
-    deserialize(raw) {
-        const asObj = parseObject(raw);
-        if (Object.keys(asObj).length > 0)
-            return asObj;
-        const sessionId = readNonEmptyString(raw?.sessionId);
-        if (sessionId)
-            return { sessionId };
-        return null;
-    },
-    serialize(params) {
-        if (!params || Object.keys(params).length === 0)
-            return null;
-        return params;
-    },
-    getDisplayId(params) {
-        return readNonEmptyString(params?.sessionId);
-    },
-};
-function getAgentRuntimeSessionCodec(agentRuntimeType) {
-    const adapter = getServerAdapter(agentRuntimeType);
-    return adapter.sessionCodec ?? defaultSessionCodec;
-}
-function normalizeSessionParams(params) {
-    if (!params)
-        return null;
-    return Object.keys(params).length > 0 ? params : null;
-}
-function resolveNextSessionState(input) {
-    const { codec, adapterResult, previousParams, previousDisplayId, previousLegacySessionId } = input;
-    if (adapterResult.clearSession) {
-        return {
-            params: null,
-            displayId: null,
-            legacySessionId: null,
-        };
-    }
-    const explicitParams = adapterResult.sessionParams;
-    const hasExplicitParams = adapterResult.sessionParams !== undefined;
-    const hasExplicitSessionId = adapterResult.sessionId !== undefined;
-    const explicitSessionId = readNonEmptyString(adapterResult.sessionId);
-    const hasExplicitDisplay = adapterResult.sessionDisplayId !== undefined;
-    const explicitDisplayId = readNonEmptyString(adapterResult.sessionDisplayId);
-    const shouldUsePrevious = !hasExplicitParams && !hasExplicitSessionId && !hasExplicitDisplay;
-    const candidateParams = hasExplicitParams
-        ? explicitParams
-        : hasExplicitSessionId
-            ? (explicitSessionId ? { sessionId: explicitSessionId } : null)
-            : previousParams;
-    const serialized = normalizeSessionParams(codec.serialize(normalizeSessionParams(candidateParams) ?? null));
-    const deserialized = normalizeSessionParams(codec.deserialize(serialized));
-    const displayId = truncateDisplayId(explicitDisplayId ??
-        (codec.getDisplayId ? codec.getDisplayId(deserialized) : null) ??
-        readNonEmptyString(deserialized?.sessionId) ??
-        (shouldUsePrevious ? previousDisplayId : null) ??
-        explicitSessionId ??
-        (shouldUsePrevious ? previousLegacySessionId : null));
-    const legacySessionId = explicitSessionId ??
-        readNonEmptyString(deserialized?.sessionId) ??
-        displayId ??
-        (shouldUsePrevious ? previousLegacySessionId : null);
-    return {
-        params: serialized,
-        displayId,
-        legacySessionId,
-    };
-}
+import * as heartbeatCore from "./heartbeat.core.js";
+import * as heartbeatSessions from "./heartbeat.sessions.js";
+const { MAX_LIVE_LOG_CHUNK_BYTES, HEARTBEAT_MAX_CONCURRENT_RUNS_DEFAULT, HEARTBEAT_MAX_CONCURRENT_RUNS_MIN, HEARTBEAT_MAX_CONCURRENT_RUNS_MAX, DEFERRED_WAKE_CONTEXT_KEY, DETACHED_PROCESS_ERROR_CODE, ORPHANED_PROCESS_TERMINATION_GRACE_MS, ORPHANED_PROCESS_KILL_WAIT_MS, ORPHANED_PROCESS_POLL_INTERVAL_MS, startLocksByAgent, MAX_RECOVERY_CHAIN_DEPTH, ISSUE_PASSIVE_FOLLOWUP_REASON, ISSUE_PASSIVE_FOLLOWUP_WAKE_SOURCE, ISSUE_PASSIVE_FOLLOWUP_FAILURE_REASON, ISSUE_PASSIVE_FOLLOWUP_MAX_ATTEMPTS, ISSUE_REVIEW_CLOSEOUT_REASON, ISSUE_REVIEW_CLOSEOUT_FAILURE_REASON, ISSUE_REVIEW_CLOSEOUT_MAX_ATTEMPTS, ISSUE_PASSIVE_FOLLOWUP_COOLDOWN_MS_BY_ATTEMPT, ISSUE_PASSIVE_FOLLOWUP_TIMER_CONTINUITY_MAX_WINDOW_MS, SESSIONED_LOCAL_ADAPTERS, heartbeatRunListColumns, appendExcerpt, appendTranscriptEntriesFromChunk, normalizeMaxConcurrentRuns, withAgentStartLock, readNonEmptyString, resolveHeartbeatObservabilitySurface, buildHeartbeatObservationName, compactTraceText, buildIssueRunTraceName, buildHeartbeatRuntimeTraceMetadata, buildHeartbeatAdapterInvokePayload, buildRecentDateKeys, buildDateKeysBetween, fallbackSkillLabel, normalizeLoadedSkill, normalizeLoadedSkillForPayload, emptySkillEvidenceCounts, incrementSkillEvidenceCount, strongestSkillEvidence, resolveSkillEvidence, readSkillEvidenceFromPayload, extractSkillSlugFromPath, collectSkillPathsFromText, collectStringValues, normalizeSkillUseFromPath, dedupeSkillUses, collectSkillUsesFromText, readToolCommandInput, isCommandTranscriptTool, isReadTranscriptTool, inferUsedSkillsFromTranscript, normalizeSkillCandidate, addSkillCandidate, readSkillReferenceSlug, collectSkillReferences, inferUsedSkillsFromPrompt, normalizeLedgerBillingType, resolveLedgerBiller, normalizeBilledCostCents, resolveLedgerScopeForRun } = heartbeatCore;
+const { buildExplicitResumeSessionOverride, normalizeUsageTotals, readRawUsageTotals, deriveNormalizedUsageDelta, formatCount, parseSessionCompactionPolicy, resolveRuntimeSessionParamsForWorkspace, parseIssueAssigneeAgentRuntimeOverrides, deriveTaskKey, shouldResetTaskSessionForWake, formatRuntimeWorkspaceWarningLog, describeSessionResetReason, deriveCommentId, enrichWakeContextSnapshot, mergeCoalescedContextSnapshot, issueCommentAuthorKind, issueCommentAuthorLabel, buildDeferredWakePayload, readDeferredWakeContext, readDeferredWakePayload, deriveDeferredWakeTaskKey, hydrateWakeContextSnapshot, firstNonEmptyLine, deriveRecoveryFailureKind, deriveRecoveryFailureSummary, mergeMissingRecoveryContextFields, hydrateRecoveryBaseContextSnapshot, buildRecoveryContextSnapshot, normalizePassiveFollowupContext, normalizeReviewCloseoutContext, passiveFollowupCooldownMs, issueHasReviewer, isAgentEligibleForTimerContinuation, hasCredibleTimerContinuation, buildPassiveFollowupContextSnapshot, runTaskKey, isSameTaskScope, isTrackedLocalChildProcessAdapter, isProcessAlive, waitForProcessExit, terminateOrphanedProcess, truncateDisplayId, normalizeAgentNameKey, defaultSessionCodec, getAgentRuntimeSessionCodec, normalizeSessionParams, resolveNextSessionState } = heartbeatSessions;
+import { createHeartbeatExecuteHandlers } from "./heartbeat.execute.js";
+import { createHeartbeatMiscHandlers } from "./heartbeat.misc.js";
+import { createHeartbeatRecoveryHandlers } from "./heartbeat.recovery.js";
+import { createHeartbeatReleaseHandlers } from "./heartbeat.release.js";
+import { createHeartbeatWakeupHandlers } from "./heartbeat.wakeup.js";
 export function heartbeatService(db) {
     const instanceSettings = instanceSettingsService(db);
     const getCurrentUserRedactionOptions = async () => ({
@@ -1262,7 +44,7 @@ export function heartbeatService(db) {
     const workspaceOperationsSvc = workspaceOperationService(db);
     const activeRunExecutions = new Set();
     const budgetHooks = {
-        cancelWorkForScope: cancelBudgetScopeWork,
+        cancelWorkForScope: (scope) => cancelBudgetScopeWork(scope),
     };
     const budgets = budgetService(db, budgetHooks);
     async function getAgent(agentId) {
@@ -1794,508 +576,24 @@ export function heartbeatService(db) {
         });
         return updated;
     }
-    async function enqueueRecoveryRun(run, agent, opts) {
-        /**
-         * Recovery runs intentionally clone the prior run's task context and then
-         * layer explicit recovery metadata on top. This keeps retries visible and
-         * auditable while preserving "continue preferred" semantics for issue work.
-         *
-         * Reasoning:
-         * - Manual retry and automatic process-loss retry must assemble the same
-         *   recovery contract so prompts/runtime behavior stay aligned.
-         * - We backfill missing context from the retry chain to recover from older
-         *   lossy retry runs without mutating the historical source run rows.
-         *
-         * Traceability:
-         * - doc/developing/RUN-RECOVERY.md
-         * - doc/DEVELOPING.md
-         */
-        const baseContextSnapshot = await hydrateRecoveryBaseContextSnapshot(run, getRun);
-        const recoveryContextSnapshot = buildRecoveryContextSnapshot({
-            baseContextSnapshot,
-            run,
-            recoveryTrigger: opts.recoveryTrigger,
-            wakeReason: opts.wakeReason,
-            wakeSource: `recovery.${opts.recoveryTrigger}`,
-            triggerDetail: opts.triggerDetail,
-        });
-        const issueId = readNonEmptyString(recoveryContextSnapshot.issueId);
-        const taskKey = deriveTaskKey(recoveryContextSnapshot, null);
-        const sessionBefore = await resolveSessionBeforeForWakeup(agent, taskKey);
-        const recovery = recoveryContextSnapshot.recovery;
-        const requestPayload = {
-            originalRunId: run.id,
-            failureKind: recovery.failureKind,
-            recoveryTrigger: recovery.recoveryTrigger,
-            ...(issueId ? { issueId } : {}),
-        };
-        const outcome = await db.transaction(async (tx) => {
-            let issueRow = null;
-            if (issueId) {
-                await tx.execute(sql `select id from issues where id = ${issueId} and org_id = ${run.orgId} for update`);
-                issueRow = await tx
-                    .select({
-                    id: issues.id,
-                    orgId: issues.orgId,
-                    executionRunId: issues.executionRunId,
-                    executionAgentNameKey: issues.executionAgentNameKey,
-                })
-                    .from(issues)
-                    .where(and(eq(issues.id, issueId), eq(issues.orgId, run.orgId)))
-                    .then((rows) => rows[0] ?? null);
-            }
-            if (issueRow?.executionRunId) {
-                const activeExecutionRun = await tx
-                    .select()
-                    .from(heartbeatRuns)
-                    .where(eq(heartbeatRuns.id, issueRow.executionRunId))
-                    .then((rows) => rows[0] ?? null);
-                const isActiveExecutionRun = activeExecutionRun &&
-                    (activeExecutionRun.status === "queued" || activeExecutionRun.status === "running");
-                if (!isActiveExecutionRun) {
-                    await tx
-                        .update(issues)
-                        .set({
-                        executionRunId: null,
-                        executionAgentNameKey: null,
-                        executionLockedAt: null,
-                        updatedAt: opts.now,
-                    })
-                        .where(eq(issues.id, issueRow.id));
-                    issueRow = {
-                        ...issueRow,
-                        executionRunId: null,
-                        executionAgentNameKey: null,
-                    };
-                }
-                else if (activeExecutionRun) {
-                    const activeContext = parseObject(activeExecutionRun.contextSnapshot);
-                    const activeRecovery = parseObject(activeContext.recovery);
-                    if (activeExecutionRun.agentId === run.agentId &&
-                        (activeExecutionRun.retryOfRunId === run.id ||
-                            readNonEmptyString(activeRecovery.originalRunId) === run.id)) {
-                        return { kind: "existing", run: activeExecutionRun };
-                    }
-                    throw conflict("Issue already has an active execution run", {
-                        issueId: issueRow.id,
-                        executionRunId: activeExecutionRun.id,
-                    });
-                }
-            }
-            const wakeupRequest = await tx
-                .insert(agentWakeupRequests)
-                .values({
-                orgId: run.orgId,
-                agentId: run.agentId,
-                source: opts.source,
-                triggerDetail: opts.triggerDetail,
-                reason: opts.wakeReason,
-                payload: requestPayload,
-                status: "queued",
-                requestedByActorType: opts.requestedByActorType ?? null,
-                requestedByActorId: opts.requestedByActorId ?? null,
-                updatedAt: opts.now,
-            })
-                .returning()
-                .then((rows) => rows[0]);
-            const recoveryRun = await tx
-                .insert(heartbeatRuns)
-                .values({
-                orgId: run.orgId,
-                agentId: run.agentId,
-                invocationSource: opts.source,
-                triggerDetail: opts.triggerDetail,
-                status: "queued",
-                wakeupRequestId: wakeupRequest.id,
-                contextSnapshot: recoveryContextSnapshot,
-                sessionIdBefore: sessionBefore,
-                retryOfRunId: run.id,
-                processLossRetryCount: opts.recoveryTrigger === "automatic"
-                    ? (run.processLossRetryCount ?? 0) + 1
-                    : (run.processLossRetryCount ?? 0),
-                updatedAt: opts.now,
-            })
-                .returning()
-                .then((rows) => rows[0]);
-            await tx
-                .update(agentWakeupRequests)
-                .set({
-                runId: recoveryRun.id,
-                updatedAt: opts.now,
-            })
-                .where(eq(agentWakeupRequests.id, wakeupRequest.id));
-            if (issueRow) {
-                await tx
-                    .update(issues)
-                    .set({
-                    executionRunId: recoveryRun.id,
-                    executionAgentNameKey: normalizeAgentNameKey(agent.name),
-                    executionLockedAt: opts.now,
-                    updatedAt: opts.now,
-                })
-                    .where(eq(issues.id, issueRow.id));
-            }
-            return { kind: "queued", run: recoveryRun };
-        });
-        if (outcome.kind === "existing")
-            return outcome.run;
-        const recoveryRun = outcome.run;
-        await appendRunEvent(recoveryRun, await nextRunEventSeq(recoveryRun.id), {
-            eventType: "lifecycle",
-            stream: "system",
-            level: opts.recoveryTrigger === "automatic" ? "warn" : "info",
-            message: `Recovery queued from run ${run.id}`,
-            payload: {
-                originalRunId: run.id,
-                failureKind: recovery.failureKind,
-                failureSummary: recovery.failureSummary,
-                recoveryTrigger: recovery.recoveryTrigger,
-                recoveryMode: recovery.recoveryMode,
-            },
-        });
-        publishLiveEvent({
-            orgId: recoveryRun.orgId,
-            type: "heartbeat.run.queued",
-            payload: {
-                runId: recoveryRun.id,
-                agentId: recoveryRun.agentId,
-                invocationSource: recoveryRun.invocationSource,
-                triggerDetail: recoveryRun.triggerDetail,
-                wakeupRequestId: recoveryRun.wakeupRequestId,
-            },
-        });
-        if (opts.startImmediately !== false) {
-            await startNextQueuedRunForAgent(agent.id);
-        }
-        return recoveryRun;
-    }
-    async function enqueueProcessLossRetry(run, agent, now) {
-        return enqueueRecoveryRun(run, agent, {
-            recoveryTrigger: "automatic",
-            source: "automation",
-            triggerDetail: "system",
-            wakeReason: "process_lost_retry",
-            requestedByActorType: "system",
-            requestedByActorId: null,
-            startImmediately: false,
-            now,
-        });
-    }
-    function parseHeartbeatPolicy(agent) {
-        const runtimeConfig = parseObject(agent.runtimeConfig);
-        const heartbeat = parseObject(runtimeConfig.heartbeat);
-        return {
-            enabled: asBoolean(heartbeat.enabled, true),
-            intervalSec: Math.max(0, asNumber(heartbeat.intervalSec, 0)),
-            wakeOnDemand: asBoolean(heartbeat.wakeOnDemand ?? heartbeat.wakeOnAssignment ?? heartbeat.wakeOnOnDemand ?? heartbeat.wakeOnAutomation, true),
-            maxConcurrentRuns: normalizeMaxConcurrentRuns(heartbeat.maxConcurrentRuns),
-        };
-    }
-    async function runHasIssueClosureComment(tx, run, issueId) {
-        const commentActivity = await tx
-            .select({ id: activityLog.id })
-            .from(activityLog)
-            .where(and(eq(activityLog.orgId, run.orgId), eq(activityLog.action, "issue.comment_added"), eq(activityLog.entityType, "issue"), eq(activityLog.entityId, issueId), eq(activityLog.runId, run.id)))
-            .limit(1)
-            .then((rows) => rows[0] ?? null);
-        return Boolean(commentActivity);
-    }
-    async function runHasIssueReviewDecision(tx, run, issueId) {
-        const decisionActivity = await tx
-            .select({ id: activityLog.id })
-            .from(activityLog)
-            .where(and(eq(activityLog.orgId, run.orgId), eq(activityLog.action, "issue.review_decision_recorded"), eq(activityLog.entityType, "issue"), eq(activityLog.entityId, issueId), eq(activityLog.runId, run.id)))
-            .limit(1)
-            .then((rows) => rows[0] ?? null);
-        return Boolean(decisionActivity);
-    }
-    async function issueHasDeferredWake(tx, orgId, issueId) {
-        const deferred = await tx
-            .select({ id: agentWakeupRequests.id })
-            .from(agentWakeupRequests)
-            .where(and(eq(agentWakeupRequests.orgId, orgId), eq(agentWakeupRequests.status, "deferred_issue_execution"), sql `${agentWakeupRequests.payload} ->> 'issueId' = ${issueId}`))
-            .limit(1)
-            .then((rows) => rows[0] ?? null);
-        return Boolean(deferred);
-    }
-    async function passiveFollowupAlreadyRecorded(tx, runId) {
-        const idempotencyKey = `${ISSUE_PASSIVE_FOLLOWUP_REASON}:${runId}`;
-        const existingWake = await tx
-            .select({ id: agentWakeupRequests.id })
-            .from(agentWakeupRequests)
-            .where(eq(agentWakeupRequests.idempotencyKey, idempotencyKey))
-            .limit(1)
-            .then((rows) => rows[0] ?? null);
-        if (existingWake)
-            return true;
-        const existingReview = await tx
-            .select({ id: activityLog.id })
-            .from(activityLog)
-            .where(and(eq(activityLog.runId, runId), inArray(activityLog.action, [
-            "issue.closure_needs_operator_review",
-            "issue.convergence_review_requested",
-        ])))
-            .limit(1)
-            .then((rows) => rows[0] ?? null);
-        return Boolean(existingReview);
-    }
-    async function reviewerCloseoutAlreadyRecorded(tx, runId) {
-        const existingWake = await tx
-            .select({ id: agentWakeupRequests.id })
-            .from(agentWakeupRequests)
-            .where(eq(agentWakeupRequests.idempotencyKey, `${ISSUE_REVIEW_CLOSEOUT_REASON}:${runId}`))
-            .limit(1)
-            .then((rows) => rows[0] ?? null);
-        if (existingWake)
-            return true;
-        const existingReview = await tx
-            .select({ id: activityLog.id })
-            .from(activityLog)
-            .where(and(eq(activityLog.runId, runId), eq(activityLog.action, "issue.review_closure_needs_operator_review")))
-            .limit(1)
-            .then((rows) => rows[0] ?? null);
-        return Boolean(existingReview);
-    }
-    async function issueHasConfirmedBlockedReviewerHandoff(tx, issue, reviewerAgentId) {
-        if (issue.status !== "blocked")
-            return false;
-        const existingHandoff = await tx
-            .select({ id: activityLog.id })
-            .from(activityLog)
-            .where(and(eq(activityLog.orgId, issue.orgId), eq(activityLog.action, "issue.review_decision_recorded"), eq(activityLog.entityType, "issue"), sql `${activityLog.entityId} = ${issue.id}::text`, eq(activityLog.actorType, "agent"), sql `${activityLog.actorId} = ${reviewerAgentId}::text`, sql `${activityLog.details} ->> 'decision' = 'blocked'`, sql `${activityLog.createdAt} >= COALESCE((
-            SELECT MAX(material_activity.created_at)
-            FROM activity_log material_activity
-            WHERE material_activity.org_id = ${issue.orgId}
-              AND material_activity.entity_type = 'issue'
-              AND material_activity.entity_id = ${issue.id}::text
-              AND (
-                (
-                  material_activity.action = 'issue.updated'
-                  AND jsonb_typeof(material_activity.details) = 'object'
-                  AND EXISTS (
-                    SELECT 1
-                    FROM jsonb_object_keys(material_activity.details) AS detail_key(key)
-                    WHERE detail_key.key NOT IN (
-                      'identifier',
-                      'issueIdentifier',
-                      '_previous',
-                      'source',
-                      'reopened',
-                      'reopenedFrom',
-                      'normalizedFromStatus',
-                      'normalizedReason'
-                    )
-                  )
-                )
-                OR (
-                  material_activity.action = 'issue.comment_added'
-                  AND NOT (
-                    material_activity.actor_type = 'agent'
-                    AND material_activity.actor_id = ${reviewerAgentId}::text
-                  )
-                )
-              )
-          ), to_timestamp(0))`))
-            .limit(1)
-            .then((rows) => rows[0] ?? null);
-        return Boolean(existingHandoff);
-    }
-    async function evaluatePassiveIssueClosureForLockedIssue(input) {
-        const { tx, run, issue, now } = input;
-        const context = parseObject(run.contextSnapshot);
-        const runIssueId = readNonEmptyString(context.issueId);
-        if (!runIssueId || runIssueId !== issue.id)
-            return { kind: "none", reason: "run_not_issue_backed" };
-        if (run.status !== "succeeded")
-            return { kind: "none", reason: "run_not_successful" };
-        const reviewerRun = (issue.status === "in_review" || issue.status === "blocked") &&
-            issue.reviewerAgentId === run.agentId &&
-            (run.invocationSource === "review" ||
-                readNonEmptyString(context.role) === "reviewer" ||
-                readNonEmptyString(context.wakeSource) === "review");
-        if (reviewerRun) {
-            if (await runHasIssueReviewDecision(tx, run, issue.id)) {
-                return { kind: "none", reason: "review_decision_recorded" };
-            }
-            if (await issueHasConfirmedBlockedReviewerHandoff(tx, issue, run.agentId)) {
-                return { kind: "none", reason: "blocked_reviewer_handoff_confirmed" };
-            }
-            if (await issueHasDeferredWake(tx, issue.orgId, issue.id)) {
-                return { kind: "none", reason: "deferred_issue_wake_exists" };
-            }
-            if (await reviewerCloseoutAlreadyRecorded(tx, run.id)) {
-                return { kind: "none", reason: "reviewer_closeout_already_recorded" };
-            }
-            const reviewCloseout = normalizeReviewCloseoutContext(context.reviewCloseout);
-            const currentAttempt = reviewCloseout?.attempt ?? 0;
-            const maxAttempts = reviewCloseout?.maxAttempts ?? ISSUE_REVIEW_CLOSEOUT_MAX_ATTEMPTS;
-            const originRunId = reviewCloseout?.originRunId ?? run.id;
-            if (currentAttempt >= maxAttempts) {
-                return {
-                    kind: "reviewer_closeout_operator_review",
-                    issue,
-                    originRunId,
-                    previousRunId: run.id,
-                    attempts: currentAttempt,
-                    maxAttempts,
-                    reason: ISSUE_REVIEW_CLOSEOUT_FAILURE_REASON,
-                };
-            }
-            return {
-                kind: "reviewer_closeout",
-                issue,
-                originRunId,
-                previousRunId: run.id,
-                attempts: currentAttempt + 1,
-                maxAttempts,
-                reason: ISSUE_REVIEW_CLOSEOUT_FAILURE_REASON,
-            };
-        }
-        if (issue.status !== "todo" && issue.status !== "in_progress") {
-            return { kind: "none", reason: "issue_has_closure_status" };
-        }
-        if (issue.assigneeAgentId !== run.agentId) {
-            return { kind: "none", reason: "issue_no_longer_assigned_to_run_agent" };
-        }
-        if (!issueHasReviewer(issue) && await runHasIssueClosureComment(tx, run, issue.id)) {
-            return { kind: "none", reason: "run_authored_issue_comment" };
-        }
-        if (await issueHasDeferredWake(tx, issue.orgId, issue.id)) {
-            return { kind: "none", reason: "deferred_issue_wake_exists" };
-        }
-        if (await passiveFollowupAlreadyRecorded(tx, run.id)) {
-            return { kind: "none", reason: "passive_followup_already_recorded" };
-        }
-        const agent = await tx
-            .select()
-            .from(agents)
-            .where(eq(agents.id, run.agentId))
-            .then((rows) => rows[0] ?? null);
-        if (!agent || agent.orgId !== run.orgId) {
-            return { kind: "none", reason: "agent_not_found" };
-        }
-        const policy = parseHeartbeatPolicy(agent);
-        if (hasCredibleTimerContinuation({ agent, policy, run, now })) {
-            return { kind: "none", reason: "timer_continuity_expected" };
-        }
-        const passiveContext = normalizePassiveFollowupContext(context.passiveFollowup);
-        const currentAttempt = passiveContext?.attempt ?? 0;
-        const originRunId = passiveContext?.originRunId ?? run.id;
-        if (currentAttempt >= ISSUE_PASSIVE_FOLLOWUP_MAX_ATTEMPTS) {
-            if (issueHasReviewer(issue)) {
-                return {
-                    kind: "reviewer_convergence",
-                    issue,
-                    originRunId,
-                    previousRunId: run.id,
-                    attempts: currentAttempt,
-                    reason: ISSUE_PASSIVE_FOLLOWUP_FAILURE_REASON,
-                };
-            }
-            return {
-                kind: "operator_review",
-                issue,
-                originRunId,
-                previousRunId: run.id,
-                attempts: currentAttempt,
-                reason: ISSUE_PASSIVE_FOLLOWUP_FAILURE_REASON,
-            };
-        }
-        const nextAttempt = currentAttempt + 1;
-        const requestedAt = new Date(now.getTime() + passiveFollowupCooldownMs(nextAttempt));
-        const contextSnapshot = buildPassiveFollowupContextSnapshot({
-            run,
-            issue,
-            originRunId,
-            attempt: nextAttempt,
-            now,
-        });
-        const taskKey = deriveTaskKey(contextSnapshot, { issueId: issue.id });
-        const sessionBefore = await resolveSessionBeforeForWakeup(agent, taskKey);
-        const requestPayload = {
-            issueId: issue.id,
-            originRunId,
-            previousRunId: run.id,
-            attempt: nextAttempt,
-            reason: ISSUE_PASSIVE_FOLLOWUP_FAILURE_REASON,
-        };
-        const wakeupRequest = await tx
-            .insert(agentWakeupRequests)
-            .values({
-            orgId: run.orgId,
-            agentId: run.agentId,
-            source: "automation",
-            triggerDetail: "system",
-            reason: ISSUE_PASSIVE_FOLLOWUP_REASON,
-            payload: requestPayload,
-            status: "queued",
-            requestedByActorType: "system",
-            requestedByActorId: "issue_closure_governance",
-            idempotencyKey: `${ISSUE_PASSIVE_FOLLOWUP_REASON}:${run.id}`,
-            requestedAt,
-            updatedAt: now,
-        })
-            .returning()
-            .then((rows) => rows[0]);
-        const followupRun = await tx
-            .insert(heartbeatRuns)
-            .values({
-            orgId: run.orgId,
-            agentId: run.agentId,
-            invocationSource: "automation",
-            triggerDetail: "system",
-            status: "queued",
-            wakeupRequestId: wakeupRequest.id,
-            contextSnapshot,
-            sessionIdBefore: sessionBefore,
-            updatedAt: now,
-        })
-            .returning()
-            .then((rows) => rows[0]);
-        await tx
-            .update(agentWakeupRequests)
-            .set({
-            runId: followupRun.id,
-            updatedAt: now,
-        })
-            .where(eq(agentWakeupRequests.id, wakeupRequest.id));
-        await tx
-            .update(issues)
-            .set({
-            executionRunId: followupRun.id,
-            executionAgentNameKey: normalizeAgentNameKey(agent.name),
-            executionLockedAt: now,
-            updatedAt: now,
-        })
-            .where(eq(issues.id, issue.id));
-        return {
-            kind: "queued",
-            run: followupRun,
-            issue,
-            originRunId,
-            previousRunId: run.id,
-            attempt: nextAttempt,
-            requestedAt,
-        };
-    }
-    async function countRunningRunsForAgent(agentId) {
-        const [{ count }] = await db
-            .select({ count: sql `count(*)` })
-            .from(heartbeatRuns)
-            .where(and(eq(heartbeatRuns.agentId, agentId), eq(heartbeatRuns.status, "running")));
-        return Number(count ?? 0);
-    }
-    async function claimQueuedRun(run) {
-        if (run.status !== "queued")
-            return run;
-        if (run.wakeupRequestId) {
-            const wakeup = await db
-                .select({ requestedAt: agentWakeupRequests.requestedAt })
-                .from(agentWakeupRequests)
-                .where(eq(agentWakeupRequests.id, run.wakeupRequestId))
-                .then((rows) => rows[0] ?? null);
-            if (wakeup && new Date(wakeup.requestedAt).getTime() > Date.now()) {
-                return null;
+    async function countRunningRunsForAgent(agentId) {
+        const [{ count }] = await db
+            .select({ count: sql `count(*)` })
+            .from(heartbeatRuns)
+            .where(and(eq(heartbeatRuns.agentId, agentId), eq(heartbeatRuns.status, "running")));
+        return Number(count ?? 0);
+    }
+    async function claimQueuedRun(run) {
+        if (run.status !== "queued")
+            return run;
+        if (run.wakeupRequestId) {
+            const wakeup = await db
+                .select({ requestedAt: agentWakeupRequests.requestedAt })
+                .from(agentWakeupRequests)
+                .where(eq(agentWakeupRequests.id, run.wakeupRequestId))
+                .then((rows) => rows[0] ?? null);
+            if (wakeup && new Date(wakeup.requestedAt).getTime() > Date.now()) {
+                return null;
             }
         }
         const agent = await getAgent(run.agentId);
@@ -2603,2410 +901,20 @@ export function heartbeatService(db) {
             return claimedRuns;
         });
     }
-    async function executeRun(runId) {
-        let run = await getRun(runId);
-        if (!run)
-            return;
-        if (run.status !== "queued" && run.status !== "running")
-            return;
-        if (run.status === "queued") {
-            const claimed = await claimQueuedRun(run);
-            if (!claimed) {
-                // Another worker has already claimed or finalized this run.
-                return;
-            }
-            run = claimed;
-        }
-        activeRunExecutions.add(run.id);
-        try {
-            const agent = await getAgent(run.agentId);
-            if (!agent) {
-                await setRunStatus(runId, "failed", {
-                    error: "Agent not found",
-                    errorCode: "agent_not_found",
-                    finishedAt: new Date(),
-                });
-                await setWakeupStatus(run.wakeupRequestId, "failed", {
-                    finishedAt: new Date(),
-                    error: "Agent not found",
-                });
-                const failedRun = await getRun(runId);
-                if (failedRun)
-                    await releaseIssueExecutionAndPromote(failedRun);
-                return;
-            }
-            const heartbeatObservationContext = buildHeartbeatObservabilityContext(run, {
-                runtime: agent.agentRuntimeType,
-                metadata: {
-                    agentName: agent.name,
-                    invocationSource: run.invocationSource,
-                    triggerDetail: run.triggerDetail,
-                },
-            });
-            await withExecutionObservation(heartbeatObservationContext, {
-                name: buildHeartbeatObservationName(run, agent.name),
-                asType: "agent",
-                input: {
-                    agentId: agent.id,
-                    agentName: agent.name,
-                    invocationSource: run.invocationSource,
-                    triggerDetail: run.triggerDetail,
-                    issueId: readNonEmptyString(parseObject(run.contextSnapshot).issueId),
-                },
-            }, async (observation) => {
-                const executionTranscript = [];
-                let stdoutTranscriptBuffer = "";
-                let stderrTranscriptBuffer = "";
-                let stdoutTranscriptParser = null;
-                let transcriptFallbackResult = null;
-                let modelTurnInput;
-                let finalObservationOutput = null;
-                let finalObservationStatus = run.status;
-                let finalObservationSessionId = heartbeatObservationContext.sessionKey ?? null;
-                const runtime = await ensureRuntimeState(agent);
-                const context = parseObject(run.contextSnapshot);
-                delete context.rudderGitIdentity;
-                const taskKey = deriveTaskKey(context, null);
-                const sessionCodec = getAgentRuntimeSessionCodec(agent.agentRuntimeType);
-                const issueId = readNonEmptyString(context.issueId);
-                const issueContext = issueId
-                    ? await db
-                        .select({
-                        id: issues.id,
-                        identifier: issues.identifier,
-                        title: issues.title,
-                        description: issues.description,
-                        projectId: issues.projectId,
-                        projectWorkspaceId: issues.projectWorkspaceId,
-                        executionWorkspaceId: issues.executionWorkspaceId,
-                        executionWorkspacePreference: issues.executionWorkspacePreference,
-                        assigneeAgentId: issues.assigneeAgentId,
-                        assigneeAgentRuntimeOverrides: issues.assigneeAgentRuntimeOverrides,
-                        executionWorkspaceSettings: issues.executionWorkspaceSettings,
-                    })
-                        .from(issues)
-                        .where(and(eq(issues.id, issueId), eq(issues.orgId, agent.orgId)))
-                        .then((rows) => rows[0] ?? null)
-                    : null;
-                const issueAssigneeOverrides = issueContext && issueContext.assigneeAgentId === agent.id
-                    ? parseIssueAssigneeAgentRuntimeOverrides(issueContext.assigneeAgentRuntimeOverrides)
-                    : null;
-                const issueExecutionWorkspaceSettings = parseIssueExecutionWorkspaceSettings(issueContext?.executionWorkspaceSettings);
-                const contextProjectId = readNonEmptyString(context.projectId);
-                const executionProjectId = issueContext?.projectId ?? contextProjectId;
-                const projectExecutionWorkspacePolicy = executionProjectId
-                    ? await db
-                        .select({ executionWorkspacePolicy: projects.executionWorkspacePolicy })
-                        .from(projects)
-                        .where(and(eq(projects.id, executionProjectId), eq(projects.orgId, agent.orgId)))
-                        .then((rows) => parseProjectExecutionWorkspacePolicy(rows[0]?.executionWorkspacePolicy))
-                    : null;
-                const taskSession = taskKey
-                    ? await getTaskSession(agent.orgId, agent.id, agent.agentRuntimeType, taskKey)
-                    : null;
-                const resetTaskSession = shouldResetTaskSessionForWake(context);
-                const sessionResetReason = describeSessionResetReason(context);
-                const taskSessionForRun = resetTaskSession ? null : taskSession;
-                const explicitResumeSessionParams = normalizeSessionParams(sessionCodec.deserialize(parseObject(context.resumeSessionParams)));
-                const explicitResumeSessionDisplayId = truncateDisplayId(readNonEmptyString(context.resumeSessionDisplayId) ??
-                    (sessionCodec.getDisplayId ? sessionCodec.getDisplayId(explicitResumeSessionParams) : null) ??
-                    readNonEmptyString(explicitResumeSessionParams?.sessionId));
-                const previousSessionParams = explicitResumeSessionParams ??
-                    (explicitResumeSessionDisplayId ? { sessionId: explicitResumeSessionDisplayId } : null) ??
-                    normalizeSessionParams(sessionCodec.deserialize(taskSessionForRun?.sessionParamsJson ?? null));
-                const config = parseObject(agent.agentRuntimeConfig);
-                const executionWorkspaceMode = resolveExecutionWorkspaceMode({
-                    projectPolicy: projectExecutionWorkspacePolicy,
-                    issueSettings: issueExecutionWorkspaceSettings,
-                    legacyUseProjectWorkspace: issueAssigneeOverrides?.useProjectWorkspace ?? null,
-                });
-                const resolvedWorkspace = await runContextSvc.resolveWorkspaceForRun(agent, context, previousSessionParams, { useProjectWorkspace: executionWorkspaceMode !== "agent_default" });
-                const workspaceManagedConfig = buildExecutionWorkspaceAdapterConfig({
-                    agentConfig: config,
-                    projectPolicy: projectExecutionWorkspacePolicy,
-                    issueSettings: issueExecutionWorkspaceSettings,
-                    mode: executionWorkspaceMode,
-                    legacyUseProjectWorkspace: issueAssigneeOverrides?.useProjectWorkspace ?? null,
-                });
-                const mergedConfig = issueAssigneeOverrides?.agentRuntimeConfig
-                    ? { ...workspaceManagedConfig, ...issueAssigneeOverrides.agentRuntimeConfig }
-                    : workspaceManagedConfig;
-                const { resolvedConfig, runtimeConfig, runtimeSkillEntries, secretKeys } = await runContextSvc.prepareRuntimeConfig({
-                    scene: "heartbeat",
-                    agent,
-                    baseConfig: mergedConfig,
-                });
-                heartbeatObservationContext.metadata = {
-                    ...(heartbeatObservationContext.metadata ?? {}),
-                    ...buildHeartbeatRuntimeTraceMetadata({
-                        runtimeConfig,
-                        runtimeSkills: runtimeSkillEntries,
-                    }),
-                };
-                const issueRef = issueContext
-                    ? {
-                        id: issueContext.id,
-                        identifier: issueContext.identifier,
-                        title: issueContext.title,
-                        projectId: issueContext.projectId,
-                        projectWorkspaceId: issueContext.projectWorkspaceId,
-                        executionWorkspaceId: issueContext.executionWorkspaceId,
-                        executionWorkspacePreference: issueContext.executionWorkspacePreference,
-                    }
-                    : null;
-                const rootObservationInput = {
-                    agentId: agent.id,
-                    agentName: agent.name,
-                    invocationSource: run.invocationSource,
-                    triggerDetail: run.triggerDetail,
-                    issue: issueRef
-                        ? {
-                            id: issueRef.id,
-                            identifier: issueRef.identifier ?? null,
-                            title: issueRef.title ?? null,
-                        }
-                        : null,
-                };
-                updateExecutionObservation(observation, heartbeatObservationContext, {
-                    input: rootObservationInput,
-                });
-                updateExecutionTraceIO(observation, { input: rootObservationInput });
-                if (issueRef) {
-                    updateExecutionTraceName(observation, buildIssueRunTraceName({
-                        issueTitle: issueRef.title,
-                        issueId: issueRef.id,
-                    }));
-                }
-                const existingExecutionWorkspace = issueRef?.executionWorkspaceId ? await executionWorkspacesSvc.getById(issueRef.executionWorkspaceId) : null;
-                const workspaceOperationRecorder = workspaceOperationsSvc.createRecorder({
-                    orgId: agent.orgId,
-                    heartbeatRunId: run.id,
-                    executionWorkspaceId: existingExecutionWorkspace?.id ?? null,
-                });
-                const executionWorkspace = await realizeExecutionWorkspace({
-                    base: {
-                        baseCwd: resolvedWorkspace.cwd,
-                        source: resolvedWorkspace.source,
-                        projectId: resolvedWorkspace.projectId,
-                        workspaceId: resolvedWorkspace.workspaceId,
-                        repoUrl: resolvedWorkspace.repoUrl,
-                        repoRef: resolvedWorkspace.repoRef,
-                    },
-                    config: runtimeConfig,
-                    issue: issueRef,
-                    agent: {
-                        id: agent.id,
-                        name: agent.name,
-                        orgId: agent.orgId,
-                    },
-                    recorder: workspaceOperationRecorder,
-                });
-                const resolvedProjectId = executionWorkspace.projectId ?? issueRef?.projectId ?? executionProjectId ?? null;
-                const resolvedProjectWorkspaceId = issueRef?.projectWorkspaceId ?? resolvedWorkspace.workspaceId ?? null;
-                const shouldReuseExisting = issueRef?.executionWorkspacePreference === "reuse_existing" &&
-                    existingExecutionWorkspace &&
-                    existingExecutionWorkspace.status !== "archived";
-                let persistedExecutionWorkspace = null;
-                try {
-                    persistedExecutionWorkspace = shouldReuseExisting && existingExecutionWorkspace
-                        ? await executionWorkspacesSvc.update(existingExecutionWorkspace.id, {
-                            cwd: executionWorkspace.cwd,
-                            repoUrl: executionWorkspace.repoUrl,
-                            baseRef: executionWorkspace.repoRef,
-                            branchName: executionWorkspace.branchName,
-                            providerType: executionWorkspace.strategy === "git_worktree" ? "git_worktree" : "local_fs",
-                            providerRef: executionWorkspace.worktreePath,
-                            status: "active",
-                            lastUsedAt: new Date(),
-                            metadata: {
-                                ...(existingExecutionWorkspace.metadata ?? {}),
-                                source: executionWorkspace.source,
-                                createdByRuntime: executionWorkspace.created,
-                            },
-                        })
-                        : resolvedProjectId
-                            ? await executionWorkspacesSvc.create({
-                                orgId: agent.orgId,
-                                projectId: resolvedProjectId,
-                                projectWorkspaceId: resolvedProjectWorkspaceId,
-                                sourceIssueId: issueRef?.id ?? null,
-                                mode: executionWorkspaceMode === "isolated_workspace"
-                                    ? "isolated_workspace"
-                                    : executionWorkspaceMode === "operator_branch"
-                                        ? "operator_branch"
-                                        : executionWorkspaceMode === "agent_default"
-                                            ? "adapter_managed"
-                                            : "shared_workspace",
-                                strategyType: executionWorkspace.strategy === "git_worktree" ? "git_worktree" : "project_primary",
-                                name: executionWorkspace.branchName ?? issueRef?.identifier ?? `workspace-${agent.id.slice(0, 8)}`,
-                                status: "active",
-                                cwd: executionWorkspace.cwd,
-                                repoUrl: executionWorkspace.repoUrl,
-                                baseRef: executionWorkspace.repoRef,
-                                branchName: executionWorkspace.branchName,
-                                providerType: executionWorkspace.strategy === "git_worktree" ? "git_worktree" : "local_fs",
-                                providerRef: executionWorkspace.worktreePath,
-                                lastUsedAt: new Date(),
-                                openedAt: new Date(),
-                                metadata: {
-                                    source: executionWorkspace.source,
-                                    createdByRuntime: executionWorkspace.created,
-                                },
-                            })
-                            : null;
-                }
-                catch (error) {
-                    if (executionWorkspace.created) {
-                        try {
-                            await cleanupExecutionWorkspaceArtifacts({
-                                workspace: {
-                                    id: existingExecutionWorkspace?.id ?? `transient-${run.id}`,
-                                    cwd: executionWorkspace.cwd,
-                                    providerType: executionWorkspace.strategy === "git_worktree" ? "git_worktree" : "local_fs",
-                                    providerRef: executionWorkspace.worktreePath,
-                                    branchName: executionWorkspace.branchName,
-                                    repoUrl: executionWorkspace.repoUrl,
-                                    baseRef: executionWorkspace.repoRef,
-                                    projectId: resolvedProjectId,
-                                    projectWorkspaceId: resolvedProjectWorkspaceId,
-                                    sourceIssueId: issueRef?.id ?? null,
-                                    metadata: {
-                                        createdByRuntime: true,
-                                        source: executionWorkspace.source,
-                                    },
-                                },
-                                projectWorkspace: {
-                                    cwd: resolvedWorkspace.cwd,
-                                    cleanupCommand: null,
-                                },
-                                teardownCommand: projectExecutionWorkspacePolicy?.workspaceStrategy?.teardownCommand ?? null,
-                                recorder: workspaceOperationRecorder,
-                            });
-                        }
-                        catch (cleanupError) {
-                            logger.warn({
-                                runId: run.id,
-                                issueId,
-                                executionWorkspaceCwd: executionWorkspace.cwd,
-                                cleanupError: cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
-                            }, "Failed to cleanup realized execution workspace after persistence failure");
-                        }
-                    }
-                    throw error;
-                }
-                await workspaceOperationRecorder.attachExecutionWorkspaceId(persistedExecutionWorkspace?.id ?? null);
-                if (existingExecutionWorkspace &&
-                    persistedExecutionWorkspace &&
-                    existingExecutionWorkspace.id !== persistedExecutionWorkspace.id &&
-                    existingExecutionWorkspace.status === "active") {
-                    await executionWorkspacesSvc.update(existingExecutionWorkspace.id, {
-                        status: "idle",
-                        cleanupReason: null,
-                    });
-                }
-                if (issueId && persistedExecutionWorkspace) {
-                    const nextIssueWorkspaceMode = issueExecutionWorkspaceModeForPersistedWorkspace(persistedExecutionWorkspace.mode);
-                    const shouldSwitchIssueToExistingWorkspace = issueRef?.executionWorkspacePreference === "reuse_existing" ||
-                        executionWorkspaceMode === "isolated_workspace" ||
-                        executionWorkspaceMode === "operator_branch";
-                    const nextIssuePatch = {};
-                    if (issueRef?.executionWorkspaceId !== persistedExecutionWorkspace.id) {
-                        nextIssuePatch.executionWorkspaceId = persistedExecutionWorkspace.id;
-                    }
-                    if (resolvedProjectWorkspaceId && issueRef?.projectWorkspaceId !== resolvedProjectWorkspaceId) {
-                        nextIssuePatch.projectWorkspaceId = resolvedProjectWorkspaceId;
-                    }
-                    if (shouldSwitchIssueToExistingWorkspace) {
-                        nextIssuePatch.executionWorkspacePreference = "reuse_existing";
-                        nextIssuePatch.executionWorkspaceSettings = {
-                            ...(issueExecutionWorkspaceSettings ?? {}),
-                            mode: nextIssueWorkspaceMode,
-                        };
-                    }
-                    if (Object.keys(nextIssuePatch).length > 0) {
-                        await issuesSvc.update(issueId, nextIssuePatch);
-                    }
-                }
-                if (persistedExecutionWorkspace) {
-                    context.executionWorkspaceId = persistedExecutionWorkspace.id;
-                    await db
-                        .update(heartbeatRuns)
-                        .set({
-                        contextSnapshot: context,
-                        updatedAt: new Date(),
-                    })
-                        .where(eq(heartbeatRuns.id, run.id));
-                }
-                const runtimeSessionResolution = resolveRuntimeSessionParamsForWorkspace({
-                    orgId: agent.orgId,
-                    agent,
-                    previousSessionParams,
-                    resolvedWorkspace: {
-                        ...resolvedWorkspace,
-                        cwd: resolveDefaultAgentWorkspaceDir(agent.orgId, agent),
-                        source: "agent_home",
-                    },
-                });
-                const runtimeSessionParams = runtimeSessionResolution.sessionParams;
-                const runtimeWorkspaceWarnings = [
-                    ...resolvedWorkspace.warnings,
-                    ...executionWorkspace.warnings,
-                    ...(runtimeSessionResolution.warning ? [runtimeSessionResolution.warning] : []),
-                    ...(resetTaskSession && sessionResetReason
-                        ? [
-                            taskKey
-                                ? `Skipping saved session resume for task "${taskKey}" because ${sessionResetReason}.`
-                                : `Skipping saved session resume because ${sessionResetReason}.`,
-                        ]
-                        : []),
-                ];
-                const runtimeSceneContext = await runContextSvc.buildSceneContext({
-                    scene: "heartbeat",
-                    agent,
-                    resolvedWorkspace,
-                    runtimeConfig,
-                    executionWorkspaceMode,
-                    executionWorkspace: {
-                        cwd: executionWorkspace.cwd,
-                        source: executionWorkspace.source,
-                        strategy: executionWorkspace.strategy,
-                        projectId: executionWorkspace.projectId,
-                        workspaceId: executionWorkspace.workspaceId,
-                        repoUrl: executionWorkspace.repoUrl,
-                        repoRef: executionWorkspace.repoRef,
-                        branchName: executionWorkspace.branchName,
-                        worktreePath: executionWorkspace.worktreePath,
-                    },
-                });
-                context.rudderScene = runtimeSceneContext.rudderScene;
-                context.rudderWorkspace = runtimeSceneContext.rudderWorkspace;
-                context.rudderWorkspaces = runtimeSceneContext.rudderWorkspaces;
-                if (runtimeSceneContext.rudderRuntimeServiceIntents) {
-                    context.rudderRuntimeServiceIntents = runtimeSceneContext.rudderRuntimeServiceIntents;
-                }
-                else {
-                    delete context.rudderRuntimeServiceIntents;
-                }
-                if (executionWorkspace.projectId && !readNonEmptyString(context.projectId)) {
-                    context.projectId = executionWorkspace.projectId;
-                }
-                if (issueContext) {
-                    const issueDocumentPayload = await documentsSvc.getIssueDocumentPayload({
-                        id: issueContext.id,
-                        description: issueContext.description,
-                    });
-                    const issueDocumentsPrompt = buildIssueDocumentsPrompt(issueDocumentPayload);
-                    if (issueDocumentsPrompt) {
-                        context.issueDocumentsPrompt = issueDocumentsPrompt;
-                    }
-                    else {
-                        delete context.issueDocumentsPrompt;
-                    }
-                }
-                const runtimeSessionFallback = taskKey || resetTaskSession ? null : runtime.sessionId;
-                let previousSessionDisplayId = truncateDisplayId(explicitResumeSessionDisplayId ??
-                    taskSessionForRun?.sessionDisplayId ??
-                    (sessionCodec.getDisplayId ? sessionCodec.getDisplayId(runtimeSessionParams) : null) ??
-                    readNonEmptyString(runtimeSessionParams?.sessionId) ??
-                    runtimeSessionFallback);
-                let runtimeSessionIdForAdapter = readNonEmptyString(runtimeSessionParams?.sessionId) ?? runtimeSessionFallback;
-                let runtimeSessionParamsForAdapter = runtimeSessionParams;
-                const sessionCompaction = await evaluateSessionCompaction({
-                    agent,
-                    sessionId: previousSessionDisplayId ?? runtimeSessionIdForAdapter,
-                    issueId,
-                });
-                if (sessionCompaction.rotate) {
-                    context.rudderSessionHandoffMarkdown = sessionCompaction.handoffMarkdown;
-                    context.rudderSessionRotationReason = sessionCompaction.reason;
-                    context.rudderPreviousSessionId = previousSessionDisplayId ?? runtimeSessionIdForAdapter;
-                    runtimeSessionIdForAdapter = null;
-                    runtimeSessionParamsForAdapter = null;
-                    previousSessionDisplayId = null;
-                    if (sessionCompaction.reason) {
-                        runtimeWorkspaceWarnings.push(`Starting a fresh session because ${sessionCompaction.reason}.`);
-                    }
-                }
-                else {
-                    delete context.rudderSessionHandoffMarkdown;
-                    delete context.rudderSessionRotationReason;
-                    delete context.rudderPreviousSessionId;
-                }
-                const runtimeForAdapter = {
-                    sessionId: runtimeSessionIdForAdapter,
-                    sessionParams: runtimeSessionParamsForAdapter,
-                    sessionDisplayId: previousSessionDisplayId,
-                    taskKey,
-                };
-                let seq = 1;
-                let handle = null;
-                let stdoutExcerpt = "";
-                let stderrExcerpt = "";
-                try {
-                    await preflightManagedAgentWorkspace({
-                        agentHome: readNonEmptyString(runtimeSceneContext.rudderWorkspace.agentHome) ?? "",
-                        instructionsDir: readNonEmptyString(runtimeSceneContext.rudderWorkspace.instructionsDir) ?? "",
-                        memoryDir: readNonEmptyString(runtimeSceneContext.rudderWorkspace.memoryDir) ?? "",
-                        lifeDir: readNonEmptyString(runtimeSceneContext.rudderWorkspace.lifeDir) ?? "",
-                        skillsDir: readNonEmptyString(runtimeSceneContext.rudderWorkspace.agentSkillsDir) ?? "",
-                    });
-                    const startedAt = run.startedAt ?? new Date();
-                    const runningWithSession = await db
-                        .update(heartbeatRuns)
-                        .set({
-                        startedAt,
-                        sessionIdBefore: runtimeForAdapter.sessionDisplayId ?? runtimeForAdapter.sessionId,
-                        contextSnapshot: context,
-                        updatedAt: new Date(),
-                    })
-                        .where(eq(heartbeatRuns.id, run.id))
-                        .returning()
-                        .then((rows) => rows[0] ?? null);
-                    if (runningWithSession)
-                        run = runningWithSession;
-                    const runningAgent = await db
-                        .update(agents)
-                        .set({ status: "running", updatedAt: new Date() })
-                        .where(eq(agents.id, agent.id))
-                        .returning()
-                        .then((rows) => rows[0] ?? null);
-                    if (runningAgent) {
-                        publishLiveEvent({
-                            orgId: runningAgent.orgId,
-                            type: "agent.status",
-                            payload: {
-                                agentId: runningAgent.id,
-                                status: runningAgent.status,
-                                outcome: "running",
-                            },
-                        });
-                    }
-                    const currentRun = run;
-                    await appendRunEvent(currentRun, seq++, {
-                        eventType: "lifecycle",
-                        stream: "system",
-                        level: "info",
-                        message: "run started",
-                    });
-                    handle = await runLogStore.begin({
-                        orgId: run.orgId,
-                        agentId: run.agentId,
-                        runId,
-                    });
-                    await db
-                        .update(heartbeatRuns)
-                        .set({
-                        logStore: handle.store,
-                        logRef: handle.logRef,
-                        updatedAt: new Date(),
-                    })
-                        .where(eq(heartbeatRuns.id, runId));
-                    const adapter = getServerAdapter(agent.agentRuntimeType);
-                    stdoutTranscriptParser = adapter.parseStdoutLine ?? null;
-                    const currentUserRedactionOptions = await getCurrentUserRedactionOptions();
-                    const onLog = async (stream, chunk) => {
-                        const sanitizedChunk = redactCurrentUserText(chunk, currentUserRedactionOptions);
-                        if (stream === "stdout")
-                            stdoutExcerpt = appendExcerpt(stdoutExcerpt, sanitizedChunk);
-                        if (stream === "stderr")
-                            stderrExcerpt = appendExcerpt(stderrExcerpt, sanitizedChunk);
-                        const ts = new Date().toISOString();
-                        if (handle) {
-                            await runLogStore.append(handle, {
-                                stream,
-                                chunk: sanitizedChunk,
-                                ts,
-                            });
-                        }
-                        const payloadChunk = sanitizedChunk.length > MAX_LIVE_LOG_CHUNK_BYTES
-                            ? sanitizedChunk.slice(sanitizedChunk.length - MAX_LIVE_LOG_CHUNK_BYTES)
-                            : sanitizedChunk;
-                        publishLiveEvent({
-                            orgId: run.orgId,
-                            type: "heartbeat.run.log",
-                            payload: {
-                                runId: run.id,
-                                agentId: run.agentId,
-                                ts,
-                                stream,
-                                chunk: payloadChunk,
-                                truncated: payloadChunk.length !== sanitizedChunk.length,
-                            },
-                        });
-                        if (stream === "stdout") {
-                            stdoutTranscriptBuffer = appendTranscriptEntriesFromChunk({
-                                buffer: stdoutTranscriptBuffer,
-                                chunk: sanitizedChunk,
-                                transcript: executionTranscript,
-                                parser: stdoutTranscriptParser,
-                                kind: "stdout",
-                            });
-                            return;
-                        }
-                        stderrTranscriptBuffer = appendTranscriptEntriesFromChunk({
-                            buffer: stderrTranscriptBuffer,
-                            chunk: sanitizedChunk,
-                            transcript: executionTranscript,
-                            kind: "stderr",
-                        });
-                    };
-                    for (const warning of runtimeWorkspaceWarnings) {
-                        const logEntry = formatRuntimeWorkspaceWarningLog(warning);
-                        await onLog(logEntry.stream, logEntry.chunk);
-                    }
-                    const adapterEnv = Object.fromEntries(Object.entries(parseObject(resolvedConfig.env)).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string"));
-                    const runtimeServices = await ensureRuntimeServicesForRun({
-                        db,
-                        runId: run.id,
-                        agent: {
-                            id: agent.id,
-                            name: agent.name,
-                            orgId: agent.orgId,
-                        },
-                        issue: issueRef,
-                        workspace: executionWorkspace,
-                        executionWorkspaceId: persistedExecutionWorkspace?.id ?? issueRef?.executionWorkspaceId ?? null,
-                        config: resolvedConfig,
-                        adapterEnv,
-                        onLog,
-                    });
-                    if (runtimeServices.length > 0) {
-                        context.rudderRuntimeServices = runtimeServices;
-                        context.rudderRuntimePrimaryUrl =
-                            runtimeServices.find((service) => readNonEmptyString(service.url))?.url ?? null;
-                        await db
-                            .update(heartbeatRuns)
-                            .set({
-                            contextSnapshot: context,
-                            updatedAt: new Date(),
-                        })
-                            .where(eq(heartbeatRuns.id, run.id));
-                    }
-                    if (issueId && (executionWorkspace.created || runtimeServices.some((service) => !service.reused))) {
-                        try {
-                            await issuesSvc.addComment(issueId, buildWorkspaceReadyComment({
-                                workspace: executionWorkspace,
-                                runtimeServices,
-                            }), { agentId: agent.id });
-                        }
-                        catch (err) {
-                            await onLog("stderr", `[rudder] Failed to post workspace-ready comment: ${err instanceof Error ? err.message : String(err)}\n`);
-                        }
-                    }
-                    const onAdapterMeta = async (meta) => {
-                        if (meta.env && secretKeys.size > 0) {
-                            for (const key of secretKeys) {
-                                if (key in meta.env)
-                                    meta.env[key] = "***REDACTED***";
-                            }
-                        }
-                        modelTurnInput = meta.prompt;
-                        heartbeatObservationContext.metadata = {
-                            ...(heartbeatObservationContext.metadata ?? {}),
-                            ...buildHeartbeatRuntimeTraceMetadata({
-                                runtimeConfig,
-                                runtimeSkills: runtimeSkillEntries,
-                                adapterMeta: meta,
-                            }),
-                        };
-                        updateExecutionObservation(observation, heartbeatObservationContext, {
-                            input: rootObservationInput,
-                        });
-                        await appendRunEvent(currentRun, seq++, {
-                            eventType: "adapter.invoke",
-                            stream: "system",
-                            level: "info",
-                            message: "adapter invocation",
-                            payload: buildHeartbeatAdapterInvokePayload({
-                                meta,
-                                runtimeSkills: runtimeSkillEntries,
-                            }),
-                        });
-                    };
-                    const authToken = adapter.supportsLocalAgentJwt
-                        ? createLocalAgentJwt(agent.id, agent.orgId, agent.agentRuntimeType, run.id)
-                        : null;
-                    if (adapter.supportsLocalAgentJwt && !authToken) {
-                        logger.warn({
-                            orgId: agent.orgId,
-                            agentId: agent.id,
-                            runId: run.id,
-                            agentRuntimeType: agent.agentRuntimeType,
-                        }, "local agent jwt secret missing or invalid; running without injected RUDDER_API_KEY");
-                    }
-                    const adapterResult = await executeAdapterWithModelFallbacks(adapter, {
-                        runId: run.id,
-                        agent,
-                        runtime: runtimeForAdapter,
-                        config: runtimeConfig,
-                        context,
-                        onLog,
-                        onMeta: onAdapterMeta,
-                        onSpawn: async (meta) => {
-                            await persistRunProcessMetadata(run.id, meta);
-                        },
-                        authToken: authToken ?? undefined,
-                    }, {
-                        resolveAdapter: findServerAdapter,
-                        createAuthToken: (agentRuntimeType) => createLocalAgentJwt(agent.id, agent.orgId, agentRuntimeType, run.id) ?? undefined,
-                        onAttemptStart: (_attempt, attemptAdapter) => {
-                            stdoutTranscriptParser = attemptAdapter.parseStdoutLine ?? null;
-                        },
-                    });
-                    const adapterManagedRuntimeServices = adapterResult.runtimeServices
-                        ? await persistAdapterManagedRuntimeServices({
-                            db,
-                            agentRuntimeType: agent.agentRuntimeType,
-                            runId: run.id,
-                            agent: {
-                                id: agent.id,
-                                name: agent.name,
-                                orgId: agent.orgId,
-                            },
-                            issue: issueRef,
-                            workspace: executionWorkspace,
-                            reports: adapterResult.runtimeServices,
-                        })
-                        : [];
-                    if (adapterManagedRuntimeServices.length > 0) {
-                        const combinedRuntimeServices = [
-                            ...runtimeServices,
-                            ...adapterManagedRuntimeServices,
-                        ];
-                        context.rudderRuntimeServices = combinedRuntimeServices;
-                        context.rudderRuntimePrimaryUrl =
-                            combinedRuntimeServices.find((service) => readNonEmptyString(service.url))?.url ?? null;
-                        await db
-                            .update(heartbeatRuns)
-                            .set({
-                            contextSnapshot: context,
-                            updatedAt: new Date(),
-                        })
-                            .where(eq(heartbeatRuns.id, run.id));
-                        if (issueId) {
-                            try {
-                                await issuesSvc.addComment(issueId, buildWorkspaceReadyComment({
-                                    workspace: executionWorkspace,
-                                    runtimeServices: adapterManagedRuntimeServices,
-                                }), { agentId: agent.id });
-                            }
-                            catch (err) {
-                                await onLog("stderr", `[rudder] Failed to post adapter-managed runtime comment: ${err instanceof Error ? err.message : String(err)}\n`);
-                            }
-                        }
-                    }
-                    const nextSessionState = resolveNextSessionState({
-                        codec: sessionCodec,
-                        adapterResult,
-                        previousParams: previousSessionParams,
-                        previousDisplayId: runtimeForAdapter.sessionDisplayId,
-                        previousLegacySessionId: runtimeForAdapter.sessionId,
-                    });
-                    const rawUsage = normalizeUsageTotals(adapterResult.usage);
-                    const sessionUsageResolution = await resolveNormalizedUsageForSession({
-                        agentId: agent.id,
-                        runId: run.id,
-                        sessionId: nextSessionState.displayId ?? nextSessionState.legacySessionId,
-                        rawUsage,
-                    });
-                    const normalizedUsage = sessionUsageResolution.normalizedUsage;
-                    let outcome;
-                    const latestRun = await getRun(run.id);
-                    if (latestRun?.status === "cancelled") {
-                        outcome = "cancelled";
-                    }
-                    else if (adapterResult.timedOut) {
-                        outcome = "timed_out";
-                    }
-                    else if ((adapterResult.exitCode ?? 0) === 0 && !adapterResult.errorMessage) {
-                        outcome = "succeeded";
-                    }
-                    else {
-                        outcome = "failed";
-                    }
-                    let logSummary = null;
-                    if (handle) {
-                        logSummary = await runLogStore.finalize(handle);
-                    }
-                    const status = outcome === "succeeded"
-                        ? "succeeded"
-                        : outcome === "cancelled"
-                            ? "cancelled"
-                            : outcome === "timed_out"
-                                ? "timed_out"
-                                : "failed";
-                    heartbeatObservationContext.status = status;
-                    finalObservationStatus = status;
-                    finalObservationSessionId = nextSessionState.displayId ?? nextSessionState.legacySessionId ?? finalObservationSessionId;
-                    const adapterResultSummary = summarizeHeartbeatRunResultJson(adapterResult.resultJson);
-                    transcriptFallbackResult = {
-                        ts: new Date().toISOString(),
-                        model: readNonEmptyString(adapterResult.model),
-                        output: readNonEmptyString(adapterResult.summary)
-                            ?? readNonEmptyString(adapterResultSummary?.result)
-                            ?? readNonEmptyString(adapterResultSummary?.summary)
-                            ?? readNonEmptyString(adapterResultSummary?.message)
-                            ?? null,
-                        usage: adapterResult.usage ?? null,
-                        costUsd: typeof adapterResult.costUsd === "number" ? adapterResult.costUsd : null,
-                        subtype: status,
-                        isError: outcome !== "succeeded",
-                        errors: adapterResult.errorMessage ? [adapterResult.errorMessage] : [],
-                    };
-                    const usageJson = normalizedUsage || adapterResult.costUsd != null
-                        ? {
-                            ...(normalizedUsage ?? {}),
-                            ...(rawUsage ? {
-                                rawInputTokens: rawUsage.inputTokens,
-                                rawCachedInputTokens: rawUsage.cachedInputTokens,
-                                rawOutputTokens: rawUsage.outputTokens,
-                            } : {}),
-                            ...(sessionUsageResolution.derivedFromSessionTotals ? { usageSource: "session_delta" } : {}),
-                            ...((nextSessionState.displayId ?? nextSessionState.legacySessionId)
-                                ? { persistedSessionId: nextSessionState.displayId ?? nextSessionState.legacySessionId }
-                                : {}),
-                            sessionReused: runtimeForAdapter.sessionId != null || runtimeForAdapter.sessionDisplayId != null,
-                            taskSessionReused: taskSessionForRun != null,
-                            freshSession: runtimeForAdapter.sessionId == null && runtimeForAdapter.sessionDisplayId == null,
-                            sessionRotated: sessionCompaction.rotate,
-                            sessionRotationReason: sessionCompaction.reason,
-                            provider: readNonEmptyString(adapterResult.provider) ?? "unknown",
-                            biller: resolveLedgerBiller(adapterResult),
-                            model: readNonEmptyString(adapterResult.model) ?? "unknown",
-                            ...(adapterResult.costUsd != null ? { costUsd: adapterResult.costUsd } : {}),
-                            billingType: normalizeLedgerBillingType(adapterResult.billingType),
-                        }
-                        : null;
-                    await setRunStatus(run.id, status, {
-                        finishedAt: new Date(),
-                        error: outcome === "succeeded"
-                            ? null
-                            : redactCurrentUserText(adapterResult.errorMessage ?? (outcome === "timed_out" ? "Timed out" : "Adapter failed"), currentUserRedactionOptions),
-                        errorCode: outcome === "timed_out"
-                            ? "timeout"
-                            : outcome === "cancelled"
-                                ? "cancelled"
-                                : outcome === "failed"
-                                    ? (adapterResult.errorCode ?? "adapter_failed")
-                                    : null,
-                        exitCode: adapterResult.exitCode,
-                        signal: adapterResult.signal,
-                        usageJson,
-                        resultJson: adapterResult.resultJson ?? null,
-                        sessionIdAfter: nextSessionState.displayId ?? nextSessionState.legacySessionId,
-                        stdoutExcerpt,
-                        stderrExcerpt,
-                        logBytes: logSummary?.bytes,
-                        logSha256: logSummary?.sha256,
-                        logCompressed: logSummary?.compressed ?? false,
-                    });
-                    await setWakeupStatus(run.wakeupRequestId, outcome === "succeeded" ? "completed" : status, {
-                        finishedAt: new Date(),
-                        error: adapterResult.errorMessage ?? null,
-                    });
-                    const finalizedRun = await getRun(run.id);
-                    if (finalizedRun) {
-                        const transcriptUsedSkills = inferUsedSkillsFromTranscript(executionTranscript);
-                        if (transcriptUsedSkills.length > 0) {
-                            await appendRunEvent(finalizedRun, seq++, {
-                                eventType: "adapter.skill_usage",
-                                stream: "system",
-                                level: "info",
-                                message: "skill usage inferred from transcript",
-                                payload: {
-                                    source: "transcript.skill_file_read",
-                                    usedSkillCount: transcriptUsedSkills.length,
-                                    usedSkillKeys: transcriptUsedSkills.map((entry) => entry.key),
-                                    usedSkills: transcriptUsedSkills,
-                                    skillEvidenceType: "used",
-                                    skillEvidenceCount: transcriptUsedSkills.length,
-                                    skillEvidenceKeys: transcriptUsedSkills.map((entry) => entry.key),
-                                    skillEvidenceSkills: transcriptUsedSkills,
-                                },
-                            });
-                        }
-                        await appendRunEvent(finalizedRun, seq++, {
-                            eventType: "lifecycle",
-                            stream: "system",
-                            level: outcome === "succeeded" ? "info" : "error",
-                            message: `run ${outcome}`,
-                            payload: {
-                                status,
-                                exitCode: adapterResult.exitCode,
-                            },
-                        });
-                        await releaseIssueExecutionAndPromote(finalizedRun);
-                    }
-                    if (finalizedRun) {
-                        await updateRuntimeState(agent, finalizedRun, adapterResult, {
-                            legacySessionId: nextSessionState.legacySessionId,
-                        }, normalizedUsage);
-                        if (taskKey) {
-                            if (adapterResult.clearSession || (!nextSessionState.params && !nextSessionState.displayId)) {
-                                await clearTaskSessions(agent.orgId, agent.id, {
-                                    taskKey,
-                                    agentRuntimeType: agent.agentRuntimeType,
-                                });
-                            }
-                            else {
-                                await upsertTaskSession({
-                                    orgId: agent.orgId,
-                                    agentId: agent.id,
-                                    agentRuntimeType: agent.agentRuntimeType,
-                                    taskKey,
-                                    sessionParamsJson: nextSessionState.params,
-                                    sessionDisplayId: nextSessionState.displayId,
-                                    lastRunId: finalizedRun.id,
-                                    lastError: outcome === "succeeded" ? null : (adapterResult.errorMessage ?? "run_failed"),
-                                });
-                            }
-                        }
-                        await emitHeartbeatLiveEval(finalizedRun.id);
-                    }
-                    await finalizeAgentStatus(agent.id, outcome);
-                }
-                catch (err) {
-                    const isWorkspacePreflightFailure = isWorkspacePermissionPreflightError(err) ||
-                        isManagedWorkspaceConfigurationError(err);
-                    const message = redactCurrentUserText(err instanceof Error ? err.message : "Unknown adapter failure", await getCurrentUserRedactionOptions());
-                    heartbeatObservationContext.status = "failed";
-                    finalObservationStatus = "failed";
-                    transcriptFallbackResult = {
-                        ts: new Date().toISOString(),
-                        output: message,
-                        subtype: "failed",
-                        isError: true,
-                        errors: [message],
-                    };
-                    logger.error({ err, runId }, "heartbeat execution failed");
-                    let logSummary = null;
-                    if (handle) {
-                        try {
-                            logSummary = await runLogStore.finalize(handle);
-                        }
-                        catch (finalizeErr) {
-                            logger.warn({ err: finalizeErr, runId }, "failed to finalize run log after error");
-                        }
-                    }
-                    const failedRun = await setRunStatus(run.id, "failed", {
-                        error: message,
-                        errorCode: isWorkspacePreflightFailure ? err.errorCode : "adapter_failed",
-                        finishedAt: new Date(),
-                        stdoutExcerpt,
-                        stderrExcerpt,
-                        logBytes: logSummary?.bytes,
-                        logSha256: logSummary?.sha256,
-                        logCompressed: logSummary?.compressed ?? false,
-                    });
-                    await setWakeupStatus(run.wakeupRequestId, "failed", {
-                        finishedAt: new Date(),
-                        error: message,
-                    });
-                    if (failedRun) {
-                        await appendRunEvent(failedRun, seq++, {
-                            eventType: isWorkspacePreflightFailure ? "runtime.workspace_preflight_failed" : "error",
-                            stream: "system",
-                            level: "error",
-                            message,
-                            ...(isWorkspacePreflightFailure
-                                ? {
-                                    payload: {
-                                        errorCode: err.errorCode,
-                                        failure: err.failure,
-                                    },
-                                }
-                                : {}),
-                        });
-                        await releaseIssueExecutionAndPromote(failedRun);
-                        if (!isWorkspacePreflightFailure) {
-                            await updateRuntimeState(agent, failedRun, {
-                                exitCode: null,
-                                signal: null,
-                                timedOut: false,
-                                errorMessage: message,
-                            }, {
-                                legacySessionId: runtimeForAdapter.sessionId,
-                            });
-                            if (taskKey && (previousSessionParams || previousSessionDisplayId || taskSession)) {
-                                await upsertTaskSession({
-                                    orgId: agent.orgId,
-                                    agentId: agent.id,
-                                    agentRuntimeType: agent.agentRuntimeType,
-                                    taskKey,
-                                    sessionParamsJson: previousSessionParams,
-                                    sessionDisplayId: previousSessionDisplayId,
-                                    lastRunId: failedRun.id,
-                                    lastError: message,
-                                });
-                            }
-                        }
-                        await emitHeartbeatLiveEval(failedRun.id);
-                    }
-                    await finalizeAgentStatus(agent.id, "failed");
-                }
-                finally {
-                    stdoutTranscriptBuffer = appendTranscriptEntriesFromChunk({
-                        buffer: stdoutTranscriptBuffer,
-                        chunk: "",
-                        transcript: executionTranscript,
-                        parser: stdoutTranscriptParser,
-                        finalize: true,
-                        kind: "stdout",
-                    });
-                    stderrTranscriptBuffer = appendTranscriptEntriesFromChunk({
-                        buffer: stderrTranscriptBuffer,
-                        chunk: "",
-                        transcript: executionTranscript,
-                        finalize: true,
-                        kind: "stderr",
-                    });
-                    try {
-                        const transcriptStats = emitExecutionTranscriptTree({
-                            context: heartbeatObservationContext,
-                            parentObservation: observation,
-                            transcript: executionTranscript,
-                            initialTurnInput: modelTurnInput,
-                            fallbackResult: transcriptFallbackResult,
-                        });
-                        finalObservationOutput = transcriptStats.finalOutput ?? transcriptFallbackResult?.output ?? null;
-                        finalObservationSessionId = transcriptStats.finalSessionId ?? finalObservationSessionId;
-                    }
-                    catch (error) {
-                        logger.warn({
-                            runId: run.id,
-                            err: error instanceof Error ? error.message : String(error),
-                        }, "Failed to export heartbeat transcript tree to Langfuse");
-                    }
-                    updateExecutionObservation(observation, heartbeatObservationContext, {
-                        input: rootObservationInput,
-                        output: finalObservationOutput,
-                        level: finalObservationStatus === "failed" || finalObservationStatus === "timed_out" ? "ERROR" : "DEFAULT",
-                        statusMessage: finalObservationStatus ?? undefined,
-                    });
-                    updateExecutionTraceIO(observation, {
-                        input: rootObservationInput,
-                        output: finalObservationOutput,
-                    });
-                    updateExecutionTraceSession(observation, finalObservationSessionId);
-                }
-            });
-        }
-        catch (outerErr) {
-            // Setup code before adapter.execute threw (e.g. ensureRuntimeState, resolveWorkspaceForRun).
-            // The inner catch did not fire, so we must record the failure here.
-            const message = outerErr instanceof Error ? outerErr.message : "Unknown setup failure";
-            logger.error({ err: outerErr, runId }, "heartbeat execution setup failed");
-            await setRunStatus(runId, "failed", {
-                error: message,
-                errorCode: "adapter_failed",
-                finishedAt: new Date(),
-            }).catch(() => undefined);
-            await setWakeupStatus(run.wakeupRequestId, "failed", {
-                finishedAt: new Date(),
-                error: message,
-            }).catch(() => undefined);
-            const failedRun = await getRun(runId).catch(() => null);
-            if (failedRun) {
-                // Emit a run-log event so the failure is visible in the run timeline,
-                // consistent with what the inner catch block does for adapter failures.
-                await appendRunEvent(failedRun, 1, {
-                    eventType: "error",
-                    stream: "system",
-                    level: "error",
-                    message,
-                }).catch(() => undefined);
-                await emitHeartbeatLiveEval(failedRun.id).catch(() => undefined);
-                await releaseIssueExecutionAndPromote(failedRun).catch(() => undefined);
-            }
-            // Ensure the agent is not left stuck in "running" if the inner catch handler's
-            // DB calls threw (e.g. a transient DB error in finalizeAgentStatus).
-            await finalizeAgentStatus(run.agentId, "failed").catch(() => undefined);
-        }
-        finally {
-            await releaseRuntimeServicesForRun(run.id).catch(() => undefined);
-            activeRunExecutions.delete(run.id);
-            await startNextQueuedRunForAgent(run.agentId);
-        }
-    }
-    async function releaseIssueExecutionAndPromote(run) {
-        const outcome = await db.transaction(async (tx) => {
-            await tx.execute(sql `select id from issues where org_id = ${run.orgId} and execution_run_id = ${run.id} for update`);
-            const issue = await tx
-                .select({
-                id: issues.id,
-                orgId: issues.orgId,
-                identifier: issues.identifier,
-                title: issues.title,
-                description: issues.description,
-                status: issues.status,
-                priority: issues.priority,
-                projectId: issues.projectId,
-                assigneeAgentId: issues.assigneeAgentId,
-                reviewerAgentId: issues.reviewerAgentId,
-                reviewerUserId: issues.reviewerUserId,
-            })
-                .from(issues)
-                .where(and(eq(issues.orgId, run.orgId), eq(issues.executionRunId, run.id)))
-                .then((rows) => rows[0] ?? null);
-            if (!issue)
-                return { promotedRun: null, passiveClosure: null };
-            const now = new Date();
-            const passiveClosure = await evaluatePassiveIssueClosureForLockedIssue({
-                tx,
-                run,
-                issue,
-                now,
-            });
-            if (passiveClosure.kind === "queued") {
-                return { promotedRun: passiveClosure.run, passiveClosure };
-            }
-            await tx
-                .update(issues)
-                .set({
-                executionRunId: null,
-                executionAgentNameKey: null,
-                executionLockedAt: null,
-                updatedAt: now,
-            })
-                .where(eq(issues.id, issue.id));
-            while (true) {
-                const deferred = await tx
-                    .select()
-                    .from(agentWakeupRequests)
-                    .where(and(eq(agentWakeupRequests.orgId, issue.orgId), eq(agentWakeupRequests.status, "deferred_issue_execution"), sql `${agentWakeupRequests.payload} ->> 'issueId' = ${issue.id}`))
-                    .orderBy(asc(agentWakeupRequests.requestedAt))
-                    .limit(1)
-                    .then((rows) => rows[0] ?? null);
-                if (!deferred)
-                    return { promotedRun: null, passiveClosure };
-                const deferredAgent = await tx
-                    .select()
-                    .from(agents)
-                    .where(eq(agents.id, deferred.agentId))
-                    .then((rows) => rows[0] ?? null);
-                if (!deferredAgent ||
-                    deferredAgent.orgId !== issue.orgId ||
-                    deferredAgent.status === "paused" ||
-                    deferredAgent.status === "terminated" ||
-                    deferredAgent.status === "pending_approval") {
-                    await tx
-                        .update(agentWakeupRequests)
-                        .set({
-                        status: "failed",
-                        finishedAt: new Date(),
-                        error: "Deferred wake could not be promoted: agent is not invokable",
-                        updatedAt: new Date(),
-                    })
-                        .where(eq(agentWakeupRequests.id, deferred.id));
-                    continue;
-                }
-                const deferredPayload = parseObject(deferred.payload);
-                const deferredContextSeed = parseObject(deferredPayload[DEFERRED_WAKE_CONTEXT_KEY]);
-                const promotedContextSeed = { ...deferredContextSeed };
-                const promotedReason = readNonEmptyString(deferred.reason) ?? "issue_execution_promoted";
-                const promotedSource = readNonEmptyString(deferred.source) ?? "automation";
-                const promotedTriggerDetail = readNonEmptyString(deferred.triggerDetail) ?? null;
-                const promotedPayload = deferredPayload;
-                delete promotedPayload[DEFERRED_WAKE_CONTEXT_KEY];
-                const { contextSnapshot: promotedContextSnapshot, taskKey: promotedTaskKey, } = enrichWakeContextSnapshot({
-                    contextSnapshot: promotedContextSeed,
-                    reason: promotedReason,
-                    source: promotedSource,
-                    triggerDetail: promotedTriggerDetail,
-                    payload: promotedPayload,
-                });
-                const sessionBefore = readNonEmptyString(promotedContextSnapshot.resumeSessionDisplayId) ??
-                    await resolveSessionBeforeForWakeup(deferredAgent, promotedTaskKey);
-                const now = new Date();
-                const newRun = await tx
-                    .insert(heartbeatRuns)
-                    .values({
-                    orgId: deferredAgent.orgId,
-                    agentId: deferredAgent.id,
-                    invocationSource: promotedSource,
-                    triggerDetail: promotedTriggerDetail,
-                    status: "queued",
-                    wakeupRequestId: deferred.id,
-                    contextSnapshot: promotedContextSnapshot,
-                    sessionIdBefore: sessionBefore,
-                })
-                    .returning()
-                    .then((rows) => rows[0]);
-                await tx
-                    .update(agentWakeupRequests)
-                    .set({
-                    status: "queued",
-                    reason: "issue_execution_promoted",
-                    runId: newRun.id,
-                    claimedAt: null,
-                    finishedAt: null,
-                    error: null,
-                    updatedAt: now,
-                })
-                    .where(eq(agentWakeupRequests.id, deferred.id));
-                await tx
-                    .update(issues)
-                    .set({
-                    executionRunId: newRun.id,
-                    executionAgentNameKey: normalizeAgentNameKey(deferredAgent.name),
-                    executionLockedAt: now,
-                    updatedAt: now,
-                })
-                    .where(eq(issues.id, issue.id));
-                return { promotedRun: newRun, passiveClosure };
-            }
-        });
-        const passiveClosure = outcome.passiveClosure;
-        if (passiveClosure?.kind === "queued") {
-            await appendRunEvent(run, await nextRunEventSeq(run.id), {
-                eventType: "issue.passive_followup_queued",
-                stream: "system",
-                level: "warn",
-                message: `Queued passive issue follow-up ${passiveClosure.run.id}`,
-                payload: {
-                    issueId: passiveClosure.issue.id,
-                    followupRunId: passiveClosure.run.id,
-                    originRunId: passiveClosure.originRunId,
-                    previousRunId: passiveClosure.previousRunId,
-                    attempt: passiveClosure.attempt,
-                    maxAttempts: ISSUE_PASSIVE_FOLLOWUP_MAX_ATTEMPTS,
-                    reason: ISSUE_PASSIVE_FOLLOWUP_FAILURE_REASON,
-                    requestedAt: passiveClosure.requestedAt.toISOString(),
-                },
-            });
-            await appendRunEvent(passiveClosure.run, await nextRunEventSeq(passiveClosure.run.id), {
-                eventType: "issue.passive_followup_queued",
-                stream: "system",
-                level: "warn",
-                message: `Passive follow-up queued because run ${run.id} ended without issue close-out`,
-                payload: {
-                    issueId: passiveClosure.issue.id,
-                    originRunId: passiveClosure.originRunId,
-                    previousRunId: passiveClosure.previousRunId,
-                    attempt: passiveClosure.attempt,
-                    maxAttempts: ISSUE_PASSIVE_FOLLOWUP_MAX_ATTEMPTS,
-                    reason: ISSUE_PASSIVE_FOLLOWUP_FAILURE_REASON,
-                    requestedAt: passiveClosure.requestedAt.toISOString(),
-                },
-            });
-            await logActivity(db, {
-                orgId: passiveClosure.issue.orgId,
-                actorType: "system",
-                actorId: "issue_closure_governance",
-                action: "issue.passive_followup_queued",
-                entityType: "issue",
-                entityId: passiveClosure.issue.id,
-                agentId: run.agentId,
-                runId: run.id,
-                details: {
-                    issueId: passiveClosure.issue.id,
-                    issueTitle: passiveClosure.issue.title,
-                    followupRunId: passiveClosure.run.id,
-                    originRunId: passiveClosure.originRunId,
-                    previousRunId: passiveClosure.previousRunId,
-                    attempt: passiveClosure.attempt,
-                    maxAttempts: ISSUE_PASSIVE_FOLLOWUP_MAX_ATTEMPTS,
-                    reason: ISSUE_PASSIVE_FOLLOWUP_FAILURE_REASON,
-                    requestedAt: passiveClosure.requestedAt.toISOString(),
-                },
-            });
-        }
-        else if (passiveClosure?.kind === "operator_review") {
-            await appendRunEvent(run, await nextRunEventSeq(run.id), {
-                eventType: "issue.closure_needs_operator_review",
-                stream: "system",
-                level: "warn",
-                message: "Passive issue follow-up stopped and needs operator review",
-                payload: {
-                    issueId: passiveClosure.issue.id,
-                    originRunId: passiveClosure.originRunId,
-                    previousRunId: passiveClosure.previousRunId,
-                    attempts: passiveClosure.attempts,
-                    maxAttempts: ISSUE_PASSIVE_FOLLOWUP_MAX_ATTEMPTS,
-                    reason: passiveClosure.reason,
-                },
-            });
-            await logActivity(db, {
-                orgId: passiveClosure.issue.orgId,
-                actorType: "system",
-                actorId: "issue_closure_governance",
-                action: "issue.closure_needs_operator_review",
-                entityType: "issue",
-                entityId: passiveClosure.issue.id,
-                agentId: run.agentId,
-                runId: run.id,
-                details: {
-                    issueId: passiveClosure.issue.id,
-                    issueTitle: passiveClosure.issue.title,
-                    originRunId: passiveClosure.originRunId,
-                    previousRunId: passiveClosure.previousRunId,
-                    attempts: passiveClosure.attempts,
-                    maxAttempts: ISSUE_PASSIVE_FOLLOWUP_MAX_ATTEMPTS,
-                    reason: passiveClosure.reason,
-                },
-            });
-        }
-        else if (passiveClosure?.kind === "reviewer_convergence") {
-            await appendRunEvent(run, await nextRunEventSeq(run.id), {
-                eventType: "issue.convergence_review_requested",
-                stream: "system",
-                level: "warn",
-                message: "Passive issue follow-up stopped and needs reviewer convergence",
-                payload: {
-                    issueId: passiveClosure.issue.id,
-                    reviewerAgentId: passiveClosure.issue.reviewerAgentId,
-                    reviewerUserId: passiveClosure.issue.reviewerUserId,
-                    originRunId: passiveClosure.originRunId,
-                    previousRunId: passiveClosure.previousRunId,
-                    attempts: passiveClosure.attempts,
-                    maxAttempts: ISSUE_PASSIVE_FOLLOWUP_MAX_ATTEMPTS,
-                    reason: passiveClosure.reason,
-                },
-            });
-            await logActivity(db, {
-                orgId: passiveClosure.issue.orgId,
-                actorType: "system",
-                actorId: "issue_closure_governance",
-                action: "issue.convergence_review_requested",
-                entityType: "issue",
-                entityId: passiveClosure.issue.id,
-                agentId: run.agentId,
-                runId: run.id,
-                details: {
-                    issueId: passiveClosure.issue.id,
-                    issueTitle: passiveClosure.issue.title,
-                    reviewerAgentId: passiveClosure.issue.reviewerAgentId,
-                    reviewerUserId: passiveClosure.issue.reviewerUserId,
-                    originRunId: passiveClosure.originRunId,
-                    previousRunId: passiveClosure.previousRunId,
-                    attempts: passiveClosure.attempts,
-                    maxAttempts: ISSUE_PASSIVE_FOLLOWUP_MAX_ATTEMPTS,
-                    reason: passiveClosure.reason,
-                },
-            });
-            if (passiveClosure.issue.reviewerAgentId) {
-                await enqueueWakeup(passiveClosure.issue.reviewerAgentId, {
-                    ...buildIssueConvergenceReviewWakeupOptions({
-                        issue: passiveClosure.issue,
-                        contextSource: "issue.passive_followup_exhausted",
-                        originRunId: passiveClosure.originRunId,
-                        previousRunId: passiveClosure.previousRunId,
-                        attempts: passiveClosure.attempts,
-                        maxAttempts: ISSUE_PASSIVE_FOLLOWUP_MAX_ATTEMPTS,
-                        requestedByActorType: "system",
-                        requestedByActorId: "issue_closure_governance",
-                    }),
-                    idempotencyKey: `issue_convergence_review_requested:${passiveClosure.originRunId}`,
-                }).catch((err) => {
-                    logger.warn({ err, issueId: passiveClosure.issue.id }, "failed to wake reviewer after passive issue close-out exhaustion");
-                    return null;
-                });
-            }
-        }
-        else if (passiveClosure?.kind === "reviewer_closeout") {
-            await appendRunEvent(run, await nextRunEventSeq(run.id), {
-                eventType: "issue.review_closeout_missing",
-                stream: "system",
-                level: "warn",
-                message: "Reviewer run finished without a structured review decision",
-                payload: {
-                    issueId: passiveClosure.issue.id,
-                    originRunId: passiveClosure.originRunId,
-                    previousRunId: passiveClosure.previousRunId,
-                    attempts: passiveClosure.attempts,
-                    maxAttempts: passiveClosure.maxAttempts,
-                    reason: passiveClosure.reason,
-                },
-            });
-            await logActivity(db, {
-                orgId: passiveClosure.issue.orgId,
-                actorType: "system",
-                actorId: "issue_review_closeout_governance",
-                action: "issue.review_closeout_missing",
-                entityType: "issue",
-                entityId: passiveClosure.issue.id,
-                agentId: run.agentId,
-                runId: run.id,
-                details: {
-                    issueId: passiveClosure.issue.id,
-                    issueTitle: passiveClosure.issue.title,
-                    reviewerAgentId: passiveClosure.issue.reviewerAgentId,
-                    originRunId: passiveClosure.originRunId,
-                    previousRunId: passiveClosure.previousRunId,
-                    attempts: passiveClosure.attempts,
-                    maxAttempts: passiveClosure.maxAttempts,
-                    reason: passiveClosure.reason,
-                },
-            });
-            if (passiveClosure.issue.reviewerAgentId) {
-                await enqueueWakeup(passiveClosure.issue.reviewerAgentId, {
-                    ...buildIssueReviewCloseoutWakeupOptions({
-                        issue: passiveClosure.issue,
-                        contextSource: "issue.review_closeout_missing",
-                        originRunId: passiveClosure.originRunId,
-                        previousRunId: passiveClosure.previousRunId,
-                        attempts: passiveClosure.attempts,
-                        maxAttempts: passiveClosure.maxAttempts,
-                        requestedByActorType: "system",
-                        requestedByActorId: "issue_review_closeout_governance",
-                    }),
-                    idempotencyKey: `${ISSUE_REVIEW_CLOSEOUT_REASON}:${run.id}`,
-                }).catch((err) => {
-                    logger.warn({ err, issueId: passiveClosure.issue.id }, "failed to wake reviewer after missing review close-out");
-                    return null;
-                });
-            }
-        }
-        else if (passiveClosure?.kind === "reviewer_closeout_operator_review") {
-            await appendRunEvent(run, await nextRunEventSeq(run.id), {
-                eventType: "issue.review_closure_needs_operator_review",
-                stream: "system",
-                level: "warn",
-                message: "Reviewer close-out attempts stopped and need operator review",
-                payload: {
-                    issueId: passiveClosure.issue.id,
-                    originRunId: passiveClosure.originRunId,
-                    previousRunId: passiveClosure.previousRunId,
-                    attempts: passiveClosure.attempts,
-                    maxAttempts: passiveClosure.maxAttempts,
-                    reason: passiveClosure.reason,
-                },
-            });
-            await logActivity(db, {
-                orgId: passiveClosure.issue.orgId,
-                actorType: "system",
-                actorId: "issue_review_closeout_governance",
-                action: "issue.review_closure_needs_operator_review",
-                entityType: "issue",
-                entityId: passiveClosure.issue.id,
-                agentId: run.agentId,
-                runId: run.id,
-                details: {
-                    issueId: passiveClosure.issue.id,
-                    issueTitle: passiveClosure.issue.title,
-                    reviewerAgentId: passiveClosure.issue.reviewerAgentId,
-                    originRunId: passiveClosure.originRunId,
-                    previousRunId: passiveClosure.previousRunId,
-                    attempts: passiveClosure.attempts,
-                    maxAttempts: passiveClosure.maxAttempts,
-                    reason: passiveClosure.reason,
-                },
-            });
-        }
-        const promotedRun = outcome.promotedRun;
-        if (!promotedRun)
-            return;
-        publishLiveEvent({
-            orgId: promotedRun.orgId,
-            type: "heartbeat.run.queued",
-            payload: {
-                runId: promotedRun.id,
-                agentId: promotedRun.agentId,
-                invocationSource: promotedRun.invocationSource,
-                triggerDetail: promotedRun.triggerDetail,
-                wakeupRequestId: promotedRun.wakeupRequestId,
-            },
-        });
-        await startNextQueuedRunForAgent(promotedRun.agentId);
-    }
-    async function enqueueWakeup(agentId, opts = {}) {
-        const source = opts.source ?? "on_demand";
-        const triggerDetail = opts.triggerDetail ?? null;
-        const contextSnapshot = { ...(opts.contextSnapshot ?? {}) };
-        const reason = opts.reason ?? null;
-        const payload = opts.payload ?? null;
-        const existingWakeupRequestId = readNonEmptyString(opts.existingWakeupRequestId);
-        const { contextSnapshot: enrichedContextSnapshot, issueIdFromPayload, taskKey, wakeCommentId, } = enrichWakeContextSnapshot({
-            contextSnapshot,
-            reason,
-            source,
-            triggerDetail,
-            payload,
-        });
-        let issueId = readNonEmptyString(enrichedContextSnapshot.issueId) ?? issueIdFromPayload;
-        const agent = await getAgent(agentId);
-        if (!agent)
-            throw notFound("Agent not found");
-        const explicitResumeSession = await resolveExplicitResumeSessionOverride(agent, payload, taskKey);
-        if (explicitResumeSession) {
-            enrichedContextSnapshot.resumeFromRunId = explicitResumeSession.resumeFromRunId;
-            enrichedContextSnapshot.resumeSessionDisplayId = explicitResumeSession.sessionDisplayId;
-            enrichedContextSnapshot.resumeSessionParams = explicitResumeSession.sessionParams;
-            if (!readNonEmptyString(enrichedContextSnapshot.issueId) && explicitResumeSession.issueId) {
-                enrichedContextSnapshot.issueId = explicitResumeSession.issueId;
-            }
-            if (!readNonEmptyString(enrichedContextSnapshot.taskId) && explicitResumeSession.taskId) {
-                enrichedContextSnapshot.taskId = explicitResumeSession.taskId;
-            }
-            if (!readNonEmptyString(enrichedContextSnapshot.taskKey) && explicitResumeSession.taskKey) {
-                enrichedContextSnapshot.taskKey = explicitResumeSession.taskKey;
-            }
-            issueId = readNonEmptyString(enrichedContextSnapshot.issueId) ?? issueId;
-        }
-        await hydrateWakeContextSnapshot(db, agent.orgId, enrichedContextSnapshot);
-        const effectiveTaskKey = readNonEmptyString(enrichedContextSnapshot.taskKey) ?? taskKey;
-        const sessionBefore = explicitResumeSession?.sessionDisplayId ??
-            await resolveSessionBeforeForWakeup(agent, effectiveTaskKey);
-        const writeSkippedRequest = async (skipReason) => {
-            if (existingWakeupRequestId) {
-                await setWakeupStatus(existingWakeupRequestId, "skipped", {
-                    reason: skipReason,
-                    finishedAt: new Date(),
-                    runId: null,
-                    claimedAt: null,
-                    error: null,
-                });
-                return;
-            }
-            await db.insert(agentWakeupRequests).values({
-                orgId: agent.orgId,
-                agentId,
-                source,
-                triggerDetail,
-                reason: skipReason,
-                payload,
-                status: "skipped",
-                requestedByActorType: opts.requestedByActorType ?? null,
-                requestedByActorId: opts.requestedByActorId ?? null,
-                idempotencyKey: opts.idempotencyKey ?? null,
-                finishedAt: new Date(),
-            });
-        };
-        let projectId = readNonEmptyString(enrichedContextSnapshot.projectId);
-        if (!projectId && issueId) {
-            projectId = await db
-                .select({ projectId: issues.projectId })
-                .from(issues)
-                .where(and(eq(issues.id, issueId), eq(issues.orgId, agent.orgId)))
-                .then((rows) => rows[0]?.projectId ?? null);
-        }
-        const budgetBlock = await budgets.getInvocationBlock(agent.orgId, agentId, {
-            issueId,
-            projectId,
-        });
-        if (budgetBlock) {
-            await writeSkippedRequest("budget.blocked");
-            throw conflict(budgetBlock.reason, {
-                scopeType: budgetBlock.scopeType,
-                scopeId: budgetBlock.scopeId,
-            });
-        }
-        if (agent.status === "paused") {
-            const deferredPayload = buildDeferredWakePayload(payload, enrichedContextSnapshot, issueId);
-            if (existingWakeupRequestId) {
-                await setWakeupStatus(existingWakeupRequestId, "deferred_agent_paused", {
-                    reason,
-                    payload: deferredPayload,
-                    runId: null,
-                    claimedAt: null,
-                    finishedAt: null,
-                    error: null,
-                });
-                return null;
-            }
-            await db.transaction(async (tx) => {
-                const deferredRows = await tx
-                    .select()
-                    .from(agentWakeupRequests)
-                    .where(and(eq(agentWakeupRequests.orgId, agent.orgId), eq(agentWakeupRequests.agentId, agentId), eq(agentWakeupRequests.status, "deferred_agent_paused"), sql `${agentWakeupRequests.runId} is null`))
-                    .orderBy(asc(agentWakeupRequests.requestedAt));
-                const existingDeferred = deferredRows.find((candidate) => isSameTaskScope(deriveDeferredWakeTaskKey(candidate.payload), effectiveTaskKey));
-                if (existingDeferred) {
-                    const mergedDeferredContext = mergeCoalescedContextSnapshot(readDeferredWakeContext(existingDeferred.payload), enrichedContextSnapshot);
-                    await updateWakeupRequestRecord(tx, existingDeferred.id, {
-                        payload: buildDeferredWakePayload({
-                            ...readDeferredWakePayload(existingDeferred.payload),
-                            ...(payload ?? {}),
-                        }, mergedDeferredContext, issueId),
-                        coalescedCount: (existingDeferred.coalescedCount ?? 0) + 1,
-                        error: null,
-                        finishedAt: null,
-                        claimedAt: null,
-                        runId: null,
-                    });
-                    return;
-                }
-                await insertWakeupRequestRecord(tx, {
-                    orgId: agent.orgId,
-                    agentId,
-                    source,
-                    triggerDetail,
-                    reason,
-                    payload: deferredPayload,
-                    status: "deferred_agent_paused",
-                    requestedByActorType: opts.requestedByActorType ?? null,
-                    requestedByActorId: opts.requestedByActorId ?? null,
-                    idempotencyKey: opts.idempotencyKey ?? null,
-                });
-            });
-            return null;
-        }
-        if (agent.status === "terminated" || agent.status === "pending_approval") {
-            throw conflict("Agent is not invokable in its current state", { status: agent.status });
-        }
-        const policy = parseHeartbeatPolicy(agent);
-        if (source === "timer" && !policy.enabled) {
-            await writeSkippedRequest("heartbeat.disabled");
-            return null;
-        }
-        if (source !== "timer" && !policy.wakeOnDemand) {
-            await writeSkippedRequest("heartbeat.wakeOnDemand.disabled");
-            return null;
-        }
-        const bypassIssueExecutionLock = reason === "issue_comment_mentioned" ||
-            readNonEmptyString(enrichedContextSnapshot.wakeReason) === "issue_comment_mentioned";
-        if (issueId && !bypassIssueExecutionLock) {
-            const agentNameKey = normalizeAgentNameKey(agent.name);
-            const outcome = await db.transaction(async (tx) => {
-                await tx.execute(sql `select id from issues where id = ${issueId} and org_id = ${agent.orgId} for update`);
-                const issue = await tx
-                    .select({
-                    id: issues.id,
-                    orgId: issues.orgId,
-                    executionRunId: issues.executionRunId,
-                    executionAgentNameKey: issues.executionAgentNameKey,
-                })
-                    .from(issues)
-                    .where(and(eq(issues.id, issueId), eq(issues.orgId, agent.orgId)))
-                    .then((rows) => rows[0] ?? null);
-                if (!issue) {
-                    if (existingWakeupRequestId) {
-                        await updateWakeupRequestRecord(tx, existingWakeupRequestId, {
-                            status: "skipped",
-                            reason: "issue_execution_issue_not_found",
-                            runId: null,
-                            claimedAt: null,
-                            finishedAt: new Date(),
-                            error: null,
-                        });
-                    }
-                    else {
-                        await insertWakeupRequestRecord(tx, {
-                            orgId: agent.orgId,
-                            agentId,
-                            source,
-                            triggerDetail,
-                            reason: "issue_execution_issue_not_found",
-                            payload,
-                            status: "skipped",
-                            requestedByActorType: opts.requestedByActorType ?? null,
-                            requestedByActorId: opts.requestedByActorId ?? null,
-                            idempotencyKey: opts.idempotencyKey ?? null,
-                            finishedAt: new Date(),
-                        });
-                    }
-                    return { kind: "skipped" };
-                }
-                let activeExecutionRun = issue.executionRunId
-                    ? await tx
-                        .select()
-                        .from(heartbeatRuns)
-                        .where(eq(heartbeatRuns.id, issue.executionRunId))
-                        .then((rows) => rows[0] ?? null)
-                    : null;
-                if (activeExecutionRun && activeExecutionRun.status !== "queued" && activeExecutionRun.status !== "running") {
-                    activeExecutionRun = null;
-                }
-                if (!activeExecutionRun && issue.executionRunId) {
-                    await tx
-                        .update(issues)
-                        .set({
-                        executionRunId: null,
-                        executionAgentNameKey: null,
-                        executionLockedAt: null,
-                        updatedAt: new Date(),
-                    })
-                        .where(eq(issues.id, issue.id));
-                }
-                if (!activeExecutionRun) {
-                    const legacyRun = await tx
-                        .select()
-                        .from(heartbeatRuns)
-                        .where(and(eq(heartbeatRuns.orgId, issue.orgId), inArray(heartbeatRuns.status, ["queued", "running"]), sql `${heartbeatRuns.contextSnapshot} ->> 'issueId' = ${issue.id}`))
-                        .orderBy(sql `case when ${heartbeatRuns.status} = 'running' then 0 else 1 end`, asc(heartbeatRuns.createdAt))
-                        .limit(1)
-                        .then((rows) => rows[0] ?? null);
-                    if (legacyRun) {
-                        activeExecutionRun = legacyRun;
-                        const legacyAgent = await tx
-                            .select({ name: agents.name })
-                            .from(agents)
-                            .where(eq(agents.id, legacyRun.agentId))
-                            .then((rows) => rows[0] ?? null);
-                        await tx
-                            .update(issues)
-                            .set({
-                            executionRunId: legacyRun.id,
-                            executionAgentNameKey: normalizeAgentNameKey(legacyAgent?.name),
-                            executionLockedAt: new Date(),
-                            updatedAt: new Date(),
-                        })
-                            .where(eq(issues.id, issue.id));
-                    }
-                }
-                if (activeExecutionRun) {
-                    const executionAgent = await tx
-                        .select({ name: agents.name })
-                        .from(agents)
-                        .where(eq(agents.id, activeExecutionRun.agentId))
-                        .then((rows) => rows[0] ?? null);
-                    const executionAgentNameKey = normalizeAgentNameKey(issue.executionAgentNameKey) ??
-                        normalizeAgentNameKey(executionAgent?.name);
-                    const isSameExecutionAgent = Boolean(executionAgentNameKey) && executionAgentNameKey === agentNameKey;
-                    const shouldQueueFollowupForCommentWake = Boolean(wakeCommentId) &&
-                        activeExecutionRun.status === "running" &&
-                        isSameExecutionAgent;
-                    if (isSameExecutionAgent && !shouldQueueFollowupForCommentWake) {
-                        const mergedContextSnapshot = mergeCoalescedContextSnapshot(activeExecutionRun.contextSnapshot, enrichedContextSnapshot);
-                        const mergedRun = await tx
-                            .update(heartbeatRuns)
-                            .set({
-                            contextSnapshot: mergedContextSnapshot,
-                            updatedAt: new Date(),
-                        })
-                            .where(eq(heartbeatRuns.id, activeExecutionRun.id))
-                            .returning()
-                            .then((rows) => rows[0] ?? activeExecutionRun);
-                        if (existingWakeupRequestId) {
-                            await updateWakeupRequestRecord(tx, existingWakeupRequestId, {
-                                status: "coalesced",
-                                reason: "issue_execution_same_name",
-                                runId: mergedRun.id,
-                                claimedAt: null,
-                                finishedAt: new Date(),
-                                error: null,
-                            });
-                        }
-                        else {
-                            await insertWakeupRequestRecord(tx, {
-                                orgId: agent.orgId,
-                                agentId,
-                                source,
-                                triggerDetail,
-                                reason: "issue_execution_same_name",
-                                payload,
-                                status: "coalesced",
-                                coalescedCount: 1,
-                                requestedByActorType: opts.requestedByActorType ?? null,
-                                requestedByActorId: opts.requestedByActorId ?? null,
-                                idempotencyKey: opts.idempotencyKey ?? null,
-                                runId: mergedRun.id,
-                                finishedAt: new Date(),
-                            });
-                        }
-                        return { kind: "coalesced", run: mergedRun };
-                    }
-                    const deferredPayload = buildDeferredWakePayload(payload, enrichedContextSnapshot, issueId);
-                    const existingDeferred = await tx
-                        .select()
-                        .from(agentWakeupRequests)
-                        .where(and(eq(agentWakeupRequests.orgId, agent.orgId), eq(agentWakeupRequests.agentId, agentId), eq(agentWakeupRequests.status, "deferred_issue_execution"), sql `${agentWakeupRequests.payload} ->> 'issueId' = ${issue.id}`))
-                        .orderBy(asc(agentWakeupRequests.requestedAt))
-                        .limit(1)
-                        .then((rows) => rows[0] ?? null);
-                    if (existingDeferred) {
-                        const mergedDeferredContext = mergeCoalescedContextSnapshot(readDeferredWakeContext(existingDeferred.payload), enrichedContextSnapshot);
-                        const mergedDeferredPayload = buildDeferredWakePayload({
-                            ...readDeferredWakePayload(existingDeferred.payload),
-                            ...(payload ?? {}),
-                        }, mergedDeferredContext, issueId);
-                        if (existingWakeupRequestId && existingDeferred.id !== existingWakeupRequestId) {
-                            await updateWakeupRequestRecord(tx, existingDeferred.id, {
-                                payload: mergedDeferredPayload,
-                                coalescedCount: (existingDeferred.coalescedCount ?? 0) + 1,
-                            });
-                            await updateWakeupRequestRecord(tx, existingWakeupRequestId, {
-                                status: "coalesced",
-                                reason: "issue_execution_deferred",
-                                runId: null,
-                                claimedAt: null,
-                                finishedAt: new Date(),
-                                error: null,
-                            });
-                        }
-                        else {
-                            await updateWakeupRequestRecord(tx, existingDeferred.id, {
-                                payload: mergedDeferredPayload,
-                                coalescedCount: (existingDeferred.coalescedCount ?? 0) + 1,
-                                status: "deferred_issue_execution",
-                                reason: "issue_execution_deferred",
-                                runId: null,
-                                claimedAt: null,
-                                finishedAt: null,
-                                error: null,
-                            });
-                        }
-                        return { kind: "deferred" };
-                    }
-                    if (existingWakeupRequestId) {
-                        await updateWakeupRequestRecord(tx, existingWakeupRequestId, {
-                            status: "deferred_issue_execution",
-                            reason: "issue_execution_deferred",
-                            payload: deferredPayload,
-                            runId: null,
-                            claimedAt: null,
-                            finishedAt: null,
-                            error: null,
-                        });
-                    }
-                    else {
-                        await insertWakeupRequestRecord(tx, {
-                            orgId: agent.orgId,
-                            agentId,
-                            source,
-                            triggerDetail,
-                            reason: "issue_execution_deferred",
-                            payload: deferredPayload,
-                            status: "deferred_issue_execution",
-                            requestedByActorType: opts.requestedByActorType ?? null,
-                            requestedByActorId: opts.requestedByActorId ?? null,
-                            idempotencyKey: opts.idempotencyKey ?? null,
-                        });
-                    }
-                    return { kind: "deferred" };
-                }
-                const wakeupRequest = existingWakeupRequestId
-                    ? await updateWakeupRequestRecord(tx, existingWakeupRequestId, {
-                        status: "queued",
-                        runId: null,
-                        claimedAt: null,
-                        finishedAt: null,
-                        error: null,
-                    })
-                    : await insertWakeupRequestRecord(tx, {
-                        orgId: agent.orgId,
-                        agentId,
-                        source,
-                        triggerDetail,
-                        reason,
-                        payload,
-                        status: "queued",
-                        requestedByActorType: opts.requestedByActorType ?? null,
-                        requestedByActorId: opts.requestedByActorId ?? null,
-                        idempotencyKey: opts.idempotencyKey ?? null,
-                    });
-                const newRun = await tx
-                    .insert(heartbeatRuns)
-                    .values({
-                    orgId: agent.orgId,
-                    agentId,
-                    invocationSource: source,
-                    triggerDetail,
-                    status: "queued",
-                    wakeupRequestId: wakeupRequest.id,
-                    contextSnapshot: enrichedContextSnapshot,
-                    sessionIdBefore: sessionBefore,
-                })
-                    .returning()
-                    .then((rows) => rows[0]);
-                await updateWakeupRequestRecord(tx, wakeupRequest.id, {
-                    runId: newRun.id,
-                    status: "queued",
-                    claimedAt: null,
-                    finishedAt: null,
-                    error: null,
-                });
-                await tx
-                    .update(issues)
-                    .set({
-                    executionRunId: newRun.id,
-                    executionAgentNameKey: agentNameKey,
-                    executionLockedAt: new Date(),
-                    updatedAt: new Date(),
-                })
-                    .where(eq(issues.id, issue.id));
-                return { kind: "queued", run: newRun };
-            });
-            if (outcome.kind === "deferred" || outcome.kind === "skipped")
-                return null;
-            if (outcome.kind === "coalesced")
-                return outcome.run;
-            const newRun = outcome.run;
-            publishLiveEvent({
-                orgId: newRun.orgId,
-                type: "heartbeat.run.queued",
-                payload: {
-                    runId: newRun.id,
-                    agentId: newRun.agentId,
-                    invocationSource: newRun.invocationSource,
-                    triggerDetail: newRun.triggerDetail,
-                    wakeupRequestId: newRun.wakeupRequestId,
-                },
-            });
-            await startNextQueuedRunForAgent(agent.id);
-            return newRun;
-        }
-        const activeRuns = await db
-            .select()
-            .from(heartbeatRuns)
-            .where(and(eq(heartbeatRuns.agentId, agentId), inArray(heartbeatRuns.status, ["queued", "running"])))
-            .orderBy(desc(heartbeatRuns.createdAt));
-        const sameScopeQueuedRun = activeRuns.find((candidate) => candidate.status === "queued" && isSameTaskScope(runTaskKey(candidate), taskKey));
-        const sameScopeRunningRun = activeRuns.find((candidate) => candidate.status === "running" && isSameTaskScope(runTaskKey(candidate), taskKey));
-        const shouldQueueFollowupForCommentWake = Boolean(wakeCommentId) && Boolean(sameScopeRunningRun) && !sameScopeQueuedRun;
-        const coalescedTargetRun = sameScopeQueuedRun ??
-            (shouldQueueFollowupForCommentWake ? null : sameScopeRunningRun ?? null);
-        if (coalescedTargetRun) {
-            const mergedContextSnapshot = mergeCoalescedContextSnapshot(coalescedTargetRun.contextSnapshot, contextSnapshot);
-            const mergedRun = await db
-                .update(heartbeatRuns)
-                .set({
-                contextSnapshot: mergedContextSnapshot,
-                updatedAt: new Date(),
-            })
-                .where(eq(heartbeatRuns.id, coalescedTargetRun.id))
-                .returning()
-                .then((rows) => rows[0] ?? coalescedTargetRun);
-            if (existingWakeupRequestId) {
-                await setWakeupStatus(existingWakeupRequestId, "coalesced", {
-                    runId: mergedRun.id,
-                    claimedAt: null,
-                    finishedAt: new Date(),
-                    error: null,
-                });
-            }
-            else {
-                await db.insert(agentWakeupRequests).values({
-                    orgId: agent.orgId,
-                    agentId,
-                    source,
-                    triggerDetail,
-                    reason,
-                    payload,
-                    status: "coalesced",
-                    coalescedCount: 1,
-                    requestedByActorType: opts.requestedByActorType ?? null,
-                    requestedByActorId: opts.requestedByActorId ?? null,
-                    idempotencyKey: opts.idempotencyKey ?? null,
-                    runId: mergedRun.id,
-                    finishedAt: new Date(),
-                });
-            }
-            return mergedRun;
-        }
-        const wakeupRequest = existingWakeupRequestId
-            ? await updateWakeupRequestRecord(db, existingWakeupRequestId, {
-                status: "queued",
-                runId: null,
-                claimedAt: null,
-                finishedAt: null,
-                error: null,
-            })
-            : await insertWakeupRequestRecord(db, {
-                orgId: agent.orgId,
-                agentId,
-                source,
-                triggerDetail,
-                reason,
-                payload,
-                status: "queued",
-                requestedByActorType: opts.requestedByActorType ?? null,
-                requestedByActorId: opts.requestedByActorId ?? null,
-                idempotencyKey: opts.idempotencyKey ?? null,
-            });
-        const newRun = await db
-            .insert(heartbeatRuns)
-            .values({
-            orgId: agent.orgId,
-            agentId,
-            invocationSource: source,
-            triggerDetail,
-            status: "queued",
-            wakeupRequestId: wakeupRequest.id,
-            contextSnapshot: enrichedContextSnapshot,
-            sessionIdBefore: sessionBefore,
-        })
-            .returning()
-            .then((rows) => rows[0]);
-        await updateWakeupRequestRecord(db, wakeupRequest.id, {
-            status: "queued",
-            runId: newRun.id,
-            claimedAt: null,
-            finishedAt: null,
-            error: null,
-        });
-        publishLiveEvent({
-            orgId: newRun.orgId,
-            type: "heartbeat.run.queued",
-            payload: {
-                runId: newRun.id,
-                agentId: newRun.agentId,
-                invocationSource: newRun.invocationSource,
-                triggerDetail: newRun.triggerDetail,
-                wakeupRequestId: newRun.wakeupRequestId,
-            },
-        });
-        await startNextQueuedRunForAgent(agent.id);
-        return newRun;
-    }
-    async function resumeDeferredWakeupsForAgent(agentId) {
-        const agent = await getAgent(agentId);
-        if (!agent)
-            throw notFound("Agent not found");
-        const replayedRequestIds = [];
-        while (true) {
-            const deferred = await db
-                .select()
-                .from(agentWakeupRequests)
-                .where(and(eq(agentWakeupRequests.orgId, agent.orgId), eq(agentWakeupRequests.agentId, agentId), eq(agentWakeupRequests.status, "deferred_agent_paused"), sql `${agentWakeupRequests.runId} is null`))
-                .orderBy(asc(agentWakeupRequests.requestedAt))
-                .limit(1)
-                .then((rows) => rows[0] ?? null);
-            if (!deferred)
-                break;
-            const replayPayload = readDeferredWakePayload(deferred.payload);
-            const replayContextSnapshot = readDeferredWakeContext(deferred.payload);
-            try {
-                await enqueueWakeup(agentId, {
-                    source: readNonEmptyString(deferred.source) ?? "on_demand",
-                    triggerDetail: readNonEmptyString(deferred.triggerDetail) ?? undefined,
-                    reason: readNonEmptyString(deferred.reason) ?? null,
-                    payload: replayPayload,
-                    idempotencyKey: deferred.idempotencyKey,
-                    requestedByActorType: deferred.requestedByActorType ?? undefined,
-                    requestedByActorId: deferred.requestedByActorId,
-                    contextSnapshot: replayContextSnapshot,
-                    existingWakeupRequestId: deferred.id,
-                });
-            }
-            catch (error) {
-                const current = await db
-                    .select({ status: agentWakeupRequests.status })
-                    .from(agentWakeupRequests)
-                    .where(eq(agentWakeupRequests.id, deferred.id))
-                    .then((rows) => rows[0] ?? null);
-                if (current?.status === "deferred_agent_paused") {
-                    await setWakeupStatus(deferred.id, "failed", {
-                        finishedAt: new Date(),
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            }
-            replayedRequestIds.push(deferred.id);
-            const current = await db
-                .select({ status: agentWakeupRequests.status })
-                .from(agentWakeupRequests)
-                .where(eq(agentWakeupRequests.id, deferred.id))
-                .then((rows) => rows[0] ?? null);
-            if (current?.status === "deferred_agent_paused")
-                break;
-        }
-        return {
-            replayed: replayedRequestIds.length,
-            wakeupRequestIds: replayedRequestIds,
-        };
-    }
-    async function listProjectScopedRunIds(orgId, projectId) {
-        const runIssueId = sql `${heartbeatRuns.contextSnapshot} ->> 'issueId'`;
-        const effectiveProjectId = sql `coalesce(${heartbeatRuns.contextSnapshot} ->> 'projectId', ${issues.projectId}::text)`;
-        const rows = await db
-            .selectDistinctOn([heartbeatRuns.id], { id: heartbeatRuns.id })
-            .from(heartbeatRuns)
-            .leftJoin(issues, and(eq(issues.orgId, orgId), sql `${issues.id}::text = ${runIssueId}`))
-            .where(and(eq(heartbeatRuns.orgId, orgId), inArray(heartbeatRuns.status, ["queued", "running"]), sql `${effectiveProjectId} = ${projectId}`));
-        return rows.map((row) => row.id);
-    }
-    async function listProjectScopedWakeupIds(orgId, projectId) {
-        const wakeIssueId = sql `${agentWakeupRequests.payload} ->> 'issueId'`;
-        const effectiveProjectId = sql `coalesce(${agentWakeupRequests.payload} ->> 'projectId', ${issues.projectId}::text)`;
-        const rows = await db
-            .selectDistinctOn([agentWakeupRequests.id], { id: agentWakeupRequests.id })
-            .from(agentWakeupRequests)
-            .leftJoin(issues, and(eq(issues.orgId, orgId), sql `${issues.id}::text = ${wakeIssueId}`))
-            .where(and(eq(agentWakeupRequests.orgId, orgId), inArray(agentWakeupRequests.status, ["queued", "deferred_issue_execution"]), sql `${agentWakeupRequests.runId} is null`, sql `${effectiveProjectId} = ${projectId}`));
-        return rows.map((row) => row.id);
-    }
-    async function cancelPendingWakeupsForBudgetScope(scope) {
-        const now = new Date();
-        let wakeupIds = [];
-        if (scope.scopeType === "organization") {
-            wakeupIds = await db
-                .select({ id: agentWakeupRequests.id })
-                .from(agentWakeupRequests)
-                .where(and(eq(agentWakeupRequests.orgId, scope.orgId), inArray(agentWakeupRequests.status, ["queued", "deferred_issue_execution"]), sql `${agentWakeupRequests.runId} is null`))
-                .then((rows) => rows.map((row) => row.id));
-        }
-        else if (scope.scopeType === "agent") {
-            wakeupIds = await db
-                .select({ id: agentWakeupRequests.id })
-                .from(agentWakeupRequests)
-                .where(and(eq(agentWakeupRequests.orgId, scope.orgId), eq(agentWakeupRequests.agentId, scope.scopeId), inArray(agentWakeupRequests.status, ["queued", "deferred_issue_execution"]), sql `${agentWakeupRequests.runId} is null`))
-                .then((rows) => rows.map((row) => row.id));
-        }
-        else {
-            wakeupIds = await listProjectScopedWakeupIds(scope.orgId, scope.scopeId);
-        }
-        if (wakeupIds.length === 0)
-            return 0;
-        await db
-            .update(agentWakeupRequests)
-            .set({
-            status: "cancelled",
-            finishedAt: now,
-            error: "Cancelled due to budget pause",
-            updatedAt: now,
-        })
-            .where(inArray(agentWakeupRequests.id, wakeupIds));
-        return wakeupIds.length;
-    }
-    async function cancelRunInternal(runId, reason = "Cancelled by control plane") {
-        const run = await getRun(runId);
-        if (!run)
-            throw notFound("Heartbeat run not found");
-        if (run.status !== "running" && run.status !== "queued")
-            return run;
-        const running = runningProcesses.get(run.id);
-        if (running) {
-            running.child.kill("SIGTERM");
-            const graceMs = Math.max(1, running.graceSec) * 1000;
-            setTimeout(() => {
-                if (!running.child.killed) {
-                    running.child.kill("SIGKILL");
-                }
-            }, graceMs);
-        }
-        const cancelled = await setRunStatus(run.id, "cancelled", {
-            finishedAt: new Date(),
-            error: reason,
-            errorCode: "cancelled",
-        });
-        await setWakeupStatus(run.wakeupRequestId, "cancelled", {
-            finishedAt: new Date(),
-            error: reason,
-        });
-        if (cancelled) {
-            await appendRunEvent(cancelled, 1, {
-                eventType: "lifecycle",
-                stream: "system",
-                level: "warn",
-                message: "run cancelled",
-            });
-            await releaseIssueExecutionAndPromote(cancelled);
-        }
-        runningProcesses.delete(run.id);
-        await finalizeAgentStatus(run.agentId, "cancelled");
-        await startNextQueuedRunForAgent(run.agentId);
-        return cancelled;
-    }
-    async function cancelActiveForAgentInternal(agentId, reason = "Cancelled due to agent pause") {
-        const runs = await db
-            .select()
-            .from(heartbeatRuns)
-            .where(and(eq(heartbeatRuns.agentId, agentId), inArray(heartbeatRuns.status, ["queued", "running"])));
-        for (const run of runs) {
-            await setRunStatus(run.id, "cancelled", {
-                finishedAt: new Date(),
-                error: reason,
-                errorCode: "cancelled",
-            });
-            await setWakeupStatus(run.wakeupRequestId, "cancelled", {
-                finishedAt: new Date(),
-                error: reason,
-            });
-            const running = runningProcesses.get(run.id);
-            if (running) {
-                running.child.kill("SIGTERM");
-                runningProcesses.delete(run.id);
-            }
-            await releaseIssueExecutionAndPromote(run);
-        }
-        return runs.length;
-    }
-    async function cancelBudgetScopeWork(scope) {
-        if (scope.scopeType === "agent") {
-            await cancelActiveForAgentInternal(scope.scopeId, "Cancelled due to budget pause");
-            await cancelPendingWakeupsForBudgetScope(scope);
-            return;
-        }
-        const runIds = scope.scopeType === "organization"
-            ? await db
-                .select({ id: heartbeatRuns.id })
-                .from(heartbeatRuns)
-                .where(and(eq(heartbeatRuns.orgId, scope.orgId), inArray(heartbeatRuns.status, ["queued", "running"])))
-                .then((rows) => rows.map((row) => row.id))
-            : await listProjectScopedRunIds(scope.orgId, scope.scopeId);
-        for (const runId of runIds) {
-            await cancelRunInternal(runId, "Cancelled due to budget pause");
-        }
-        await cancelPendingWakeupsForBudgetScope(scope);
-    }
-    async function retryRunInternal(runId, opts) {
-        const run = await getRun(runId);
-        if (!run)
-            throw notFound("Heartbeat run not found");
-        if (run.status !== "failed" && run.status !== "timed_out" && run.status !== "cancelled") {
-            throw conflict("Only failed, timed out, or cancelled runs can be retried", {
-                status: run.status,
-            });
-        }
-        const agent = await getAgent(run.agentId);
-        if (!agent)
-            throw notFound("Agent not found");
-        if (agent.status === "paused" ||
-            agent.status === "terminated" ||
-            agent.status === "pending_approval") {
-            throw conflict("Agent is not invokable in its current state", { status: agent.status });
-        }
-        const policy = parseHeartbeatPolicy(agent);
-        if (!policy.wakeOnDemand) {
-            throw conflict("Agent is not configured for on-demand wakeups");
-        }
-        const context = parseObject(run.contextSnapshot);
-        const issueId = readNonEmptyString(context.issueId);
-        let projectId = readNonEmptyString(context.projectId);
-        if (!projectId && issueId) {
-            projectId = await db
-                .select({ projectId: issues.projectId })
-                .from(issues)
-                .where(and(eq(issues.id, issueId), eq(issues.orgId, agent.orgId)))
-                .then((rows) => rows[0]?.projectId ?? null);
-        }
-        const budgetBlock = await budgets.getInvocationBlock(agent.orgId, agent.id, {
-            issueId,
-            projectId,
-        });
-        if (budgetBlock) {
-            throw conflict(budgetBlock.reason, {
-                scopeType: budgetBlock.scopeType,
-                scopeId: budgetBlock.scopeId,
-            });
-        }
-        return enqueueRecoveryRun(run, agent, {
-            recoveryTrigger: "manual",
-            source: "on_demand",
-            triggerDetail: "manual",
-            wakeReason: "retry_failed_run",
-            requestedByActorType: opts?.requestedByActorType ?? "user",
-            requestedByActorId: opts?.requestedByActorId ?? null,
-            now: opts?.now ?? new Date(),
-        });
-    }
-    async function buildSkillAnalytics(scope, opts) {
-        const now = opts?.now ?? new Date();
-        const customDateKeys = opts?.startDate && opts?.endDate
-            ? buildDateKeysBetween(opts.startDate, opts.endDate).slice(0, 120)
-            : [];
-        const windowDays = customDateKeys.length > 0
-            ? customDateKeys.length
-            : Math.max(1, Math.min(opts?.windowDays ?? 30, 90));
-        const dateKeys = customDateKeys.length > 0
-            ? customDateKeys
-            : buildRecentDateKeys(windowDays, now);
-        const startDate = dateKeys[0];
-        const endDate = dateKeys.at(-1);
-        const windowStart = new Date(`${startDate}T00:00:00.000Z`);
-        const windowEnd = new Date(`${endDate}T23:59:59.999Z`);
-        const rows = await db
-            .select({
-            runId: heartbeatRunEvents.runId,
-            createdAt: heartbeatRunEvents.createdAt,
-            eventType: heartbeatRunEvents.eventType,
-            payload: heartbeatRunEvents.payload,
-        })
-            .from(heartbeatRunEvents)
-            .where(and(eq(heartbeatRunEvents.orgId, scope.orgId), ...(scope.agentId ? [eq(heartbeatRunEvents.agentId, scope.agentId)] : []), inArray(heartbeatRunEvents.eventType, ["adapter.invoke", "adapter.skill_usage"]), gte(heartbeatRunEvents.createdAt, windowStart), lte(heartbeatRunEvents.createdAt, windowEnd)))
-            .orderBy(asc(heartbeatRunEvents.createdAt), asc(heartbeatRunEvents.id));
-        const days = new Map();
-        for (const date of dateKeys) {
-            days.set(date, { totalCount: 0, runCount: 0, evidenceCounts: emptySkillEvidenceCounts(), skills: new Map() });
-        }
-        const overallSkills = new Map();
-        const runEvidence = new Map();
-        let totalCount = 0;
-        let totalRunsWithSkills = 0;
-        const evidenceCounts = emptySkillEvidenceCounts();
-        function addRunSkillEvidence(runId, date, evidence) {
-            if (!days.has(date))
-                return;
-            if (evidence.evidence !== "used")
-                return;
-            if (evidence.skills.length === 0)
-                return;
-            const runBucket = runEvidence.get(runId) ?? { date, skills: new Map() };
-            for (const entry of evidence.skills) {
-                const normalized = normalizeLoadedSkill(entry);
-                if (!normalized)
-                    continue;
-                const existing = runBucket.skills.get(normalized.key);
-                if (existing) {
-                    existing.evidence = strongestSkillEvidence(existing.evidence, evidence.evidence);
-                    if (existing.label === fallbackSkillLabel(existing.key) && normalized.label !== fallbackSkillLabel(normalized.key)) {
-                        existing.label = normalized.label;
-                    }
-                }
-                else {
-                    runBucket.skills.set(normalized.key, {
-                        key: normalized.key,
-                        label: normalized.label,
-                        evidence: evidence.evidence,
-                    });
-                }
-            }
-            if (runBucket.skills.size > 0)
-                runEvidence.set(runId, runBucket);
-        }
-        async function inferUsedSkillsFromStoredRunLog(row) {
-            if (row.logStore !== "local_file" || !row.logRef)
-                return [];
-            const adapter = (() => {
-                try {
-                    return getServerAdapter(row.agentRuntimeType);
-                }
-                catch {
-                    return null;
-                }
-            })();
-            if (!adapter)
-                return [];
-            const parser = adapter.parseStdoutLine ?? null;
-            if (!parser)
-                return [];
-            const limitBytes = Math.min(Math.max(row.logBytes ?? 0, 256_000), 2_000_000);
-            const read = await runLogStore
-                .read({ store: "local_file", logRef: row.logRef }, { limitBytes })
-                .catch(() => null);
-            if (!read?.content)
-                return [];
-            const transcript = [];
-            let stdoutBuffer = "";
-            let stderrBuffer = "";
-            for (const line of read.content.split("\n")) {
-                if (!line.trim())
-                    continue;
-                let raw;
-                try {
-                    raw = JSON.parse(line);
-                }
-                catch {
-                    continue;
-                }
-                const parsed = parseObject(raw);
-                const stream = parsed.stream === "stderr" ? "stderr" : parsed.stream === "stdout" ? "stdout" : null;
-                const chunk = typeof parsed.chunk === "string" ? parsed.chunk : "";
-                if (!stream || !chunk)
-                    continue;
-                if (stream === "stdout") {
-                    stdoutBuffer = appendTranscriptEntriesFromChunk({
-                        buffer: stdoutBuffer,
-                        chunk,
-                        transcript,
-                        parser,
-                        kind: "stdout",
-                    });
-                }
-                else {
-                    stderrBuffer = appendTranscriptEntriesFromChunk({
-                        buffer: stderrBuffer,
-                        chunk,
-                        transcript,
-                        kind: "stderr",
-                    });
-                }
-            }
-            appendTranscriptEntriesFromChunk({
-                buffer: stdoutBuffer,
-                chunk: "",
-                transcript,
-                parser,
-                kind: "stdout",
-                finalize: true,
-            });
-            appendTranscriptEntriesFromChunk({
-                buffer: stderrBuffer,
-                chunk: "",
-                transcript,
-                kind: "stderr",
-                finalize: true,
-            });
-            return inferUsedSkillsFromTranscript(transcript);
-        }
-        for (const row of rows) {
-            const date = new Date(row.createdAt).toISOString().slice(0, 10);
-            const payload = parseObject(row.payload);
-            addRunSkillEvidence(row.runId, date, readSkillEvidenceFromPayload(payload));
-        }
-        const runRows = await db
-            .select({
-            id: heartbeatRuns.id,
-            agentRuntimeType: agents.agentRuntimeType,
-            createdAt: heartbeatRuns.createdAt,
-            logStore: heartbeatRuns.logStore,
-            logRef: heartbeatRuns.logRef,
-            logBytes: heartbeatRuns.logBytes,
-        })
-            .from(heartbeatRuns)
-            .innerJoin(agents, eq(agents.id, heartbeatRuns.agentId))
-            .where(and(eq(heartbeatRuns.orgId, scope.orgId), ...(scope.agentId ? [eq(heartbeatRuns.agentId, scope.agentId)] : []), gte(heartbeatRuns.createdAt, windowStart), lte(heartbeatRuns.createdAt, windowEnd)));
-        for (const row of runRows) {
-            const usedSkills = await inferUsedSkillsFromStoredRunLog(row);
-            if (usedSkills.length === 0)
-                continue;
-            addRunSkillEvidence(row.id, new Date(row.createdAt).toISOString().slice(0, 10), {
-                evidence: "used",
-                skills: usedSkills,
-            });
-        }
-        for (const runBucket of runEvidence.values()) {
-            const bucket = days.get(runBucket.date);
-            if (!bucket || runBucket.skills.size === 0)
-                continue;
-            bucket.runCount += 1;
-            totalRunsWithSkills += 1;
-            for (const { key, label, evidence } of runBucket.skills.values()) {
-                bucket.totalCount += 1;
-                totalCount += 1;
-                incrementSkillEvidenceCount(bucket.evidenceCounts, evidence);
-                incrementSkillEvidenceCount(evidenceCounts, evidence);
-                const existingDaySkill = bucket.skills.get(key);
-                if (existingDaySkill) {
-                    existingDaySkill.count += 1;
-                    existingDaySkill.evidence = strongestSkillEvidence(existingDaySkill.evidence, evidence);
-                    incrementSkillEvidenceCount(existingDaySkill.evidenceCounts, evidence);
-                }
-                else {
-                    const skillEvidenceCounts = emptySkillEvidenceCounts();
-                    incrementSkillEvidenceCount(skillEvidenceCounts, evidence);
-                    bucket.skills.set(key, { key, label, count: 1, evidence, evidenceCounts: skillEvidenceCounts });
-                }
-                const existingOverallSkill = overallSkills.get(key);
-                if (existingOverallSkill) {
-                    existingOverallSkill.count += 1;
-                    existingOverallSkill.evidence = strongestSkillEvidence(existingOverallSkill.evidence, evidence);
-                    incrementSkillEvidenceCount(existingOverallSkill.evidenceCounts, evidence);
-                }
-                else {
-                    const skillEvidenceCounts = emptySkillEvidenceCounts();
-                    incrementSkillEvidenceCount(skillEvidenceCounts, evidence);
-                    overallSkills.set(key, { key, label, count: 1, evidence, evidenceCounts: skillEvidenceCounts });
-                }
-            }
-        }
-        return {
-            agentId: scope.agentId ?? "__all__",
-            orgId: scope.orgId,
-            windowDays,
-            startDate,
-            endDate,
-            totalCount,
-            totalRunsWithSkills,
-            evidenceCounts,
-            skills: Array.from(overallSkills.values()).sort((left, right) => (right.count - left.count
-                || left.label.localeCompare(right.label)
-                || left.key.localeCompare(right.key))),
-            days: dateKeys.map((date) => {
-                const bucket = days.get(date);
-                return {
-                    date,
-                    totalCount: bucket.totalCount,
-                    runCount: bucket.runCount,
-                    evidenceCounts: bucket.evidenceCounts,
-                    skills: Array.from(bucket.skills.values()).sort((left, right) => (right.count - left.count
-                        || left.label.localeCompare(right.label)
-                        || left.key.localeCompare(right.key))),
-                };
-            }),
-        };
-    }
+    const baseContext = {
+        db, instanceSettings, getCurrentUserRedactionOptions, runLogStore, runContextSvc, issuesSvc, documentsSvc, executionWorkspacesSvc, workspaceOperationsSvc, activeRunExecutions, budgetHooks, budgets,
+        getAgent, getRun, getRuntimeState, getTaskSession, getLatestRunForSession, getOldestRunForSession, resolveNormalizedUsageForSession, evaluateSessionCompaction, resolveSessionBeforeForWakeup, resolveExplicitResumeSessionOverride, upsertTaskSession, clearTaskSessions, ensureRuntimeState, buildHeartbeatObservabilityContext, emitHeartbeatObservationEvent, emitHeartbeatLiveEval, setRunStatus, setWakeupStatus, updateWakeupRequestRecord, insertWakeupRequestRecord, appendRunEvent, nextRunEventSeq, persistRunProcessMetadata, clearDetachedRunWarning, countRunningRunsForAgent, claimQueuedRun, finalizeAgentStatus, reapOrphanedRuns, resumeQueuedRuns, updateRuntimeState, startNextQueuedRunForAgent,
+    };
+    const recoveryHandlers = createHeartbeatRecoveryHandlers({ ...baseContext, startNextQueuedRunForAgent });
+    const wakeupHandlers = createHeartbeatWakeupHandlers({ ...baseContext, ...recoveryHandlers, startNextQueuedRunForAgent });
+    const releaseHandlers = createHeartbeatReleaseHandlers({ ...baseContext, ...recoveryHandlers, ...wakeupHandlers });
+    const executeHandlers = createHeartbeatExecuteHandlers({ ...baseContext, ...recoveryHandlers, ...releaseHandlers, ...wakeupHandlers });
+    const miscHandlers = createHeartbeatMiscHandlers({ ...baseContext, ...recoveryHandlers, ...releaseHandlers, ...wakeupHandlers, ...executeHandlers });
+    const { enqueueRecoveryRun, enqueueProcessLossRetry, evaluatePassiveIssueClosureForLockedIssue, parseHeartbeatPolicy } = recoveryHandlers;
+    const { enqueueWakeup } = wakeupHandlers;
+    const { releaseIssueExecutionAndPromote } = releaseHandlers;
+    const { executeRun } = executeHandlers;
+    const { resumeDeferredWakeupsForAgent, listProjectScopedRunIds, listProjectScopedWakeupIds, cancelPendingWakeupsForBudgetScope, cancelRunInternal, cancelActiveForAgentInternal, cancelBudgetScopeWork, retryRunInternal, buildSkillAnalytics } = miscHandlers;
     return {
         list: async (orgId, agentId, limit) => {
             const query = db