@desplega.ai/agent-swarm 1.157.0 → 1.159.0

package/dist/{cli-tpv97m71.js → cli-20035trh.js}

@@ -1,6 +1,7 @@
 import {
   REBOOT_RETRY_PIN_TAG,
   agentsWithLiveRuntime,
+  cancelApprovalRequestAndRun,
   countActiveRuntimeInstancesForAgent,
   createPoolStarvationDecisionTask,
   createRerouteDecisionTask,
@@ -15,15 +16,19 @@ import {
   recoverIncompleteRuns,
   repointTrackerSyncBySwarmId,
   resolveLeadOnlyRecoveryAssignment
-} from "./cli-01vfmq8c.js";
+} from "./cli-79aq9cgb.js";
 import {
   isMultiRuntimeEnabled
 } from "./cli-re8z5p8p.js";
+import {
+  createApprovalFollowUpTask
+} from "./cli-fjtp3463.js";
 import {
   MAX_EMPTY_POLLS,
   assignUnassignedTaskPending,
   backfillSupersedeTaskResumeTaskId,
   buildRoutingAffinityFromAgent,
+  cascadeFailDependents,
   cleanupStaleSessions,
   createLogEntry,
   createTaskExtended,
@@ -34,15 +39,20 @@ import {
   getActiveTaskCount,
   getAllAgents,
   getDbClient,
+  getDependentTasks,
+  getExpiredPendingApprovals,
   getIdleWorkersWithCapacity,
   getLeadAgent,
   getPendingSteeringForTask,
   getRecentCompletedCount,
   getRecentFailedCount,
   getRecentFailedTasks,
+  getStaleApprovalRequests,
   getStalePinnedResumes,
   getStaleUnassignedAffinityTasks,
   getStalledInProgressTasks,
+  getSupersededTasksWithUnsettledDependents,
+  getSupersededTasksWithoutResume,
   getTaskById,
   getTaskStats,
   getTasksByStatus,
@@ -59,24 +69,98 @@ import {
   releaseStaleOfferedTasksForOfflineAgents,
   releaseStaleProcessingInbox,
   releaseStaleReviewingTasks,
+  resolveApprovalRequest,
+  settleSupersededTaskDependents,
   supersedeTask,
   updateAgentStatus
-} from "./cli-awwphhcs.js";
+} from "./cli-g9df2m37.js";
 import {
   init_registry,
   init_resolver,
   registerTemplate,
   resolveTemplate
-} from "./cli-ggm92wcn.js";
+} from "./cli-rgjprct3.js";
+import {
+  init_env_flag,
+  isEnvFlagEnabled
+} from "./cli-ej6gbxfb.js";
 import {
   init_secret_scrubber,
   scrubSecrets
 } from "./cli-r2ap2czm.js";
 
+// src/be/approval-sweeps.ts
+init_db();
+var DEFAULT_APPROVAL_REQUEST_AUTO_CANCELLATION_DAYS = 7;
+function approvalRequestAutoCancellationDays() {
+  const raw = process.env.APPROVAL_REQUEST_AUTO_CANCELLATION_DAYS;
+  if (raw != null && /^\d+$/.test(raw.trim())) {
+    return Number.parseInt(raw.trim(), 10);
+  }
+  return DEFAULT_APPROVAL_REQUEST_AUTO_CANCELLATION_DAYS;
+}
+async function autoCancelStaleApprovalRequests(now = new Date) {
+  const days = approvalRequestAutoCancellationDays();
+  if (days === 0)
+    return { cancelled: [], runsCancelled: [] };
+  const cutoff = new Date(now.getTime() - days * 86400000).toISOString();
+  const stale = await getStaleApprovalRequests({ cutoff });
+  const reason = `Auto-cancelled by the approval sweep after ${days} days with no response`;
+  const cancelled = [];
+  const runsCancelled = [];
+  for (const row of stale) {
+    try {
+      const result = await cancelApprovalRequestAndRun(row.id, {
+        reason,
+        resolvedBy: null,
+        slackReason: "auto-cancelled with no response"
+      });
+      if (!result || "timedOut" in result)
+        continue;
+      cancelled.push(result.request);
+      if (result.runCancelled && result.request.workflowRunId) {
+        runsCancelled.push(result.request.workflowRunId);
+      }
+    } catch (err) {
+      console.error(`[approval-sweep] could not cancel approval request ${row.id}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (cancelled.length > 0) {
+    console.log(`[approval-sweep] auto-cancelled ${cancelled.length} stale approval requests and ${runsCancelled.length} workflow runs`);
+  }
+  return { cancelled, runsCancelled };
+}
+async function timeoutExpiredApprovalRequests(now = new Date) {
+  const expired = await getExpiredPendingApprovals({ now: now.toISOString() });
+  const timedOut = [];
+  for (const row of expired) {
+    try {
+      const updated = await getDbClient().transaction(async () => {
+        const request = await resolveApprovalRequest(row.id, {
+          status: "timeout",
+          resolutionReason: `Timed out by the approval sweep: no answer before ${row.expiresAt}`
+        });
+        if (request)
+          await createApprovalFollowUpTask(request, "hitl.timeout");
+        return request;
+      });
+      if (updated)
+        timedOut.push(updated);
+    } catch (err) {
+      console.error(`[approval-sweep] could not time out approval request ${row.id}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (timedOut.length > 0) {
+    console.log(`[approval-sweep] timed out ${timedOut.length} expired approval requests`);
+  }
+  return { timedOut };
+}
+
 // src/heartbeat/heartbeat.ts
 init_db();
 init_steering();
 init_resolver();
+init_env_flag();
 init_secret_scrubber();
 
 // src/heartbeat/templates.ts
@@ -98,8 +182,8 @@ Goal: Review system status and your standing orders, take action if needed.
 ## Instructions
 1. **Read your HEARTBEAT.md** — run \`read /workspace/HEARTBEAT.md\` to get the latest standing orders (the snapshot above may be slightly stale).
 2. **Prune tracked HEARTBEAT items FIRST.** Active Blockers + Watch Items + Open Discussion combined must stay at ≤10 items; 20 is the absolute max only when genuinely super busy. This cap does not apply to evergreen Standing Orders / Governance / Playbook-index reference sections. Before adding anything, re-check every tracked item against its lift trigger and remove anything resolved, stale, or past its trigger date. Lift incident detail to memory; never keep it inline in HEARTBEAT.md. Every new tracked item must include an explicit lift trigger + date; if it has no removal condition, do not add it. If the tracked list is already at/over cap, prune before (or instead of) adding — the cap is binding.
-3. **Run seeded heartbeat data-gathering.** Use \`script-run\` with global script \`Heartbeat Audit\` and pass the current HEARTBEAT.md text as \`heartbeatMarkdown\`. It covers Rules #10/#13/#15/#16/#17: resolved stale PRs, pool-target risk schedules, schedule/provider failure clusters, and whether daily-blocker-digest ran today. The Slack thread-reply check (Rule #11) stays Lead-side; the script runtime has no Slack token.
-4. Review the system status above plus the \`Heartbeat Audit\` result for anything that needs attention (stalled tasks, idle workers with available work, anomalies).
+3. **Run seeded heartbeat data-gathering.** Use \`script-run\` with the global scripts \`schedule-health\` and \`task-failure-audit\`, both with args \`{ "days": 1, "publishPage": false }\`. They report failing schedules and failure clusters. Check any other standing order in HEARTBEAT.md yourself. Scripts can read Slack too (\`ctx.swarm.slack_read\` or the seeded \`slack-thread-flatten\` script), so a recurring Slack check can be scripted.
+4. Review the system status above plus the script results for anything that needs attention (stalled tasks, idle workers with available work, anomalies).
 5. **CRITICAL — Reboot failure triage:** Failures with reason "worker session not found" or "worker session heartbeat is stale" indicate tasks that were INTERRUPTED by a server restart. These are NOT "expected auto-cleanup" — they represent work that was lost mid-execution. For each such failure:
    - Check what the task was (via \`get-task-details\` with the task ID from the failure)
    - If a retry task was auto-created (tagged \`reboot-retry\`), verify it is progressing
@@ -215,10 +299,22 @@ var HEARTBEAT_RESUME_PIN_GRACE_MIN = (() => {
   return Number.isFinite(parsed) ? parsed : 10;
 })();
 var POOL_AFFINITY_ESCALATION_MIN = Number(process.env.POOL_AFFINITY_ESCALATION_MIN) || 15;
-var HEARTBEAT_CHECKLIST_INTERVAL_MS = Number(process.env.HEARTBEAT_CHECKLIST_INTERVAL_MS) || 30 * 60 * 1000;
-var HEARTBEAT_CHECKLIST_DISABLE = Boolean(process.env.HEARTBEAT_CHECKLIST_DISABLE);
+var DEFAULT_HEARTBEAT_CHECKLIST_INTERVAL_MS = 30 * 60 * 1000;
+function heartbeatChecklistIntervalMs() {
+  const raw = process.env.HEARTBEAT_CHECKLIST_INTERVAL_MS?.trim();
+  if (!raw)
+    return DEFAULT_HEARTBEAT_CHECKLIST_INTERVAL_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed))
+    return DEFAULT_HEARTBEAT_CHECKLIST_INTERVAL_MS;
+  return Math.max(0, parsed);
+}
+function isHeartbeatChecklistDisabled() {
+  return isEnvFlagEnabled("HEARTBEAT_CHECKLIST_DISABLE", false);
+}
 var heartbeatInterval = null;
 var checklistInterval = null;
+var bootTriageTimeout = null;
 var isSweeping = false;
 var beforeHeartbeatSupersedeForTests = null;
 var rebootAffectedTasks = [];
@@ -260,12 +356,15 @@ async function codeLevelTriage() {
       workflowRuns: 0,
       staleRuntimes: 0,
       staleOfferedTasks: 0,
-      abandonedDraftTasks: 0
+      abandonedDraftTasks: 0,
+      approvalAutoCancelled: 0,
+      approvalTimedOut: 0
     }
   };
   findings.staleCleanup.staleRuntimes = (await expireStaleRuntimeInstances()).expired;
   findings.staleCleanup.staleOfferedTasks = await releaseStaleOfferedTasksForOfflineAgents();
   await detectAndRemediateStalledTasks(findings);
+  await repairSupersededWithoutResume(findings);
   await checkWorkerHealth(findings);
   await autoAssignPoolTasks(findings);
   await cleanupStaleResources(findings);
@@ -361,6 +460,31 @@ async function detectAndRemediateStalledTasks(findings) {
     await remediateCrashedWorkerTask(findings, task, remediationOpts, proposed);
   }
 }
+var ORPHAN_SUPERSEDE_MIN_AGE_MS = 60 * 1000;
+var ORPHAN_SUPERSEDE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+async function repairSupersededWithoutResume(findings) {
+  const now = Date.now();
+  const orphans = await getSupersededTasksWithoutResume(new Date(now - ORPHAN_SUPERSEDE_MIN_AGE_MS).toISOString(), new Date(now - ORPHAN_SUPERSEDE_MAX_AGE_MS).toISOString());
+  for (const task of orphans) {
+    const resume = task.agentId && getNextResumeGeneration(task) <= maxResumeGenerations() ? await createResumeFollowUp({ parentId: task.id, reason: "crash_recovery" }) : null;
+    if (resume?.kind !== "created" || !task.agentId) {
+      await settleSupersededTaskDependents(task.id, null);
+      continue;
+    }
+    await backfillSupersedeTaskResumeTaskId(task.id, resume.task.id);
+    findings.autoResumedTasks.push({
+      taskId: task.id,
+      resumeTaskId: resume.task.id,
+      agentId: task.agentId,
+      reason: "repaired superseded task without resume"
+    });
+    console.log(`[Heartbeat] Created missing resume ${resume.task.id.slice(0, 8)} for superseded task ${task.id.slice(0, 8)}`);
+  }
+  const unsettled = await getSupersededTasksWithUnsettledDependents(new Date(now - ORPHAN_SUPERSEDE_MIN_AGE_MS).toISOString(), new Date(now - ORPHAN_SUPERSEDE_MAX_AGE_MS).toISOString());
+  for (const { taskId, resumeTaskId } of unsettled) {
+    await settleSupersededTaskDependents(taskId, resumeTaskId);
+  }
+}
 function isRemediationAction(value) {
   return typeof value === "string" && REMEDIATION_ACTIONS.has(value);
 }
@@ -393,7 +517,9 @@ async function remediateCrashedWorkerTask(findings, task, opts, decision) {
   if (!task.agentId)
     return;
   if (decision.action === "fail") {
-    const failed = await failTask(task.id, decision.reason);
+    const failed = await failTask(task.id, decision.reason, {
+      expectedLastUpdatedAt: task.lastUpdatedAt
+    });
     if (failed) {
       findings.autoFailedTasks.push({
         taskId: task.id,
@@ -416,7 +542,8 @@ async function remediateCrashedWorkerTask(findings, task, opts, decision) {
   await beforeHeartbeatSupersedeForTests?.(task);
   const superseded = await supersedeTask(task.id, {
     reason: decision.reason,
-    resumeTaskId: null
+    resumeTaskId: null,
+    expectedLastUpdatedAt: task.lastUpdatedAt
   });
   if (!superseded) {
     return;
@@ -443,6 +570,7 @@ async function remediateCrashedWorkerTask(findings, task, opts, decision) {
     }
   } else {
     const reason = resume.kind === "skipped" ? `resume_creation_skipped_${resume.reason}` : "resume_creation_skipped_workflow";
+    await settleSupersededTaskDependents(task.id, null);
     const failed = await failTask(task.id, reason);
     if (failed) {
       findings.autoFailedTasks.push({
@@ -510,94 +638,144 @@ async function runRebootSweep() {
         if (sessionLastSeen >= bootEpoch - BOOT_EPOCH_SKEW_MS) {
           continue;
         }
+        if (Date.now() - sessionLastSeen < stallThresholdStaleHeartbeatMin() * 60 * 1000) {
+          continue;
+        }
       }
       if (session)
         await deleteActiveSession(task.id);
-      const failed = await failTask(task.id, reason);
+      const failed = await failTask(task.id, reason, { cascadeDependents: false });
       if (!failed)
         continue;
-      if (await getActiveTaskCount(task.agentId) === 0) {
-        await restoreAgentIdleAfterRemediation(task.agentId);
-      }
-      if (SKIP_AUTO_RESUME_TYPES.has(task.taskType ?? "")) {
-        rebootAffectedTasks.push({ original: failed, retryTaskId: null });
-        continue;
-      }
       let retryTaskId = null;
-      if (task.routingAffinityInvalid) {
-        console.error(`[Heartbeat] Reboot retry suppressed for ${task.id.slice(0, 8)}: invalid routing affinity`);
-        rebootAffectedTasks.push({ original: failed, retryTaskId: null });
-        continue;
-      }
-      const existingRetry = await getDbClient().get(`SELECT id FROM agent_tasks
+      try {
+        if (await getActiveTaskCount(task.agentId) === 0) {
+          await restoreAgentIdleAfterRemediation(task.agentId);
+        }
+        if (SKIP_AUTO_RESUME_TYPES.has(task.taskType ?? "")) {
+          rebootAffectedTasks.push({ original: failed, retryTaskId: null });
+          continue;
+        }
+        if (task.routingAffinityInvalid) {
+          console.error(`[Heartbeat] Reboot retry suppressed for ${task.id.slice(0, 8)}: invalid routing affinity`);
+          rebootAffectedTasks.push({ original: failed, retryTaskId: null });
+          continue;
+        }
+        const existingRetry = await getDbClient().get(`SELECT id FROM agent_tasks
            WHERE parentTaskId = ?
              AND status NOT IN ('completed', 'failed', 'cancelled')
            LIMIT 1`, [task.id]);
-      if (!existingRetry) {
-        try {
-          let preferredAgentId;
-          let sourceCandidate = await getPinCandidateAgent(task.agentId);
-          if (sourceCandidate) {
-            const activeCount = await getActiveTaskCount(sourceCandidate.id);
-            const maxTasks = sourceCandidate.maxTasks ?? 1;
-            const hasCap = activeCount < maxTasks;
-            if (hasCap) {
-              preferredAgentId = sourceCandidate.id;
-            } else {
-              sourceCandidate = null;
-              console.warn(`[Heartbeat] Reboot retry for task ${task.id.slice(0, 8)} NOT pinned: agent ${task.agentId.slice(0, 8)} at capacity (${activeCount}/${maxTasks}); falling back to affinity-gated pool`);
+        if (!existingRetry) {
+          try {
+            let preferredAgentId;
+            let sourceCandidate = await getPinCandidateAgent(task.agentId);
+            if (sourceCandidate) {
+              const activeCount = await getActiveTaskCount(sourceCandidate.id);
+              const maxTasks = sourceCandidate.maxTasks ?? 1;
+              const hasCap = activeCount < maxTasks;
+              if (hasCap) {
+                preferredAgentId = sourceCandidate.id;
+              } else {
+                sourceCandidate = null;
+                console.warn(`[Heartbeat] Reboot retry for task ${task.id.slice(0, 8)} NOT pinned: agent ${task.agentId.slice(0, 8)} at capacity (${activeCount}/${maxTasks}); falling back to affinity-gated pool`);
+              }
             }
-          }
-          const leadOnly = task.routingAffinity?.leadOnly === true;
-          const authorization = await resolveLeadOnlyRecoveryAssignment(task, sourceCandidate);
-          if (leadOnly)
-            preferredAgentId = authorization.agentId;
-          const tags = ["reboot-retry", "auto-generated"];
-          if (preferredAgentId !== undefined)
-            tags.push(REBOOT_RETRY_PIN_TAG);
-          const sourceAffinity = await buildRoutingAffinityFromAgent(task.agentId) ?? undefined;
-          const routingAffinity = leadOnly ? {
-            ...sourceAffinity ?? task.routingAffinity,
-            capabilities: task.routingAffinity?.capabilities ?? sourceAffinity?.capabilities ?? [],
-            leadOnly: true
-          } : sourceAffinity;
-          const retryTask = await createTaskExtended(task.task, {
-            parentTaskId: task.id,
-            agentId: preferredAgentId,
-            routingReason: preferredAgentId === undefined ? undefined : preferredAgentId === task.agentId ? "continuity" : "reroute_fault",
-            routingSource: preferredAgentId === undefined ? undefined : "engine_default",
-            tags,
-            priority: task.priority,
-            source: task.source,
-            taskType: task.taskType ?? undefined,
-            routingAffinity
-          });
-          if (authorization.decision) {
-            await createLogEntry({
-              eventType: "task_recovery_authorization",
-              taskId: retryTask.id,
+            const leadOnly = task.routingAffinity?.leadOnly === true;
+            const authorization = await resolveLeadOnlyRecoveryAssignment(task, sourceCandidate);
+            if (leadOnly)
+              preferredAgentId = authorization.agentId;
+            const tags = ["reboot-retry", "auto-generated"];
+            if (preferredAgentId !== undefined)
+              tags.push(REBOOT_RETRY_PIN_TAG);
+            const sourceAffinity = await buildRoutingAffinityFromAgent(task.agentId) ?? undefined;
+            const routingAffinity = leadOnly ? {
+              ...sourceAffinity ?? task.routingAffinity,
+              capabilities: task.routingAffinity?.capabilities ?? sourceAffinity?.capabilities ?? [],
+              leadOnly: true
+            } : sourceAffinity;
+            const retryTask = await createTaskExtended(task.task, {
+              parentTaskId: task.id,
               agentId: preferredAgentId,
-              metadata: {
-                leadOnly: true,
-                parentTaskId: task.id,
-                sourceAgentId: task.agentId,
-                decision: authorization.decision
-              }
+              routingReason: preferredAgentId === undefined ? undefined : preferredAgentId === task.agentId ? "continuity" : "reroute_fault",
+              routingSource: preferredAgentId === undefined ? undefined : "engine_default",
+              tags,
+              priority: task.priority,
+              source: task.source,
+              taskType: task.taskType ?? undefined,
+              inheritParentFollowUpConfig: true,
+              routingAffinity
             });
+            if (authorization.decision) {
+              await createLogEntry({
+                eventType: "task_recovery_authorization",
+                taskId: retryTask.id,
+                agentId: preferredAgentId,
+                metadata: {
+                  leadOnly: true,
+                  parentTaskId: task.id,
+                  sourceAgentId: task.agentId,
+                  decision: authorization.decision
+                }
+              });
+            }
+            retryTaskId = retryTask.id;
+            console.log(`[Heartbeat] Reboot retry created: ${retryTaskId} (parent: ${task.id})`);
+          } catch (err) {
+            console.error(`[Heartbeat] Failed to create retry task for ${task.id}:`, err);
           }
-          retryTaskId = retryTask.id;
-          console.log(`[Heartbeat] Reboot retry created: ${retryTaskId} (parent: ${task.id})`);
-        } catch (err) {
-          console.error(`[Heartbeat] Failed to create retry task for ${task.id}:`, err);
         }
+        rebootAffectedTasks.push({ original: failed, retryTaskId });
+      } finally {
+        await settleRebootSweptDependents(task.id, retryTaskId);
       }
-      rebootAffectedTasks.push({ original: failed, retryTaskId });
     }
     console.log(`[Heartbeat] Reboot sweep complete: ${rebootAffectedTasks.length} task(s) auto-failed and retried`);
   } finally {
     isSweeping = false;
   }
 }
+var NEVER_STARTED_STATUSES = new Set([
+  "draft",
+  "backlog",
+  "unassigned",
+  "offered",
+  "reviewing",
+  "pending"
+]);
+async function settleRebootSweptDependents(sweptId, retryTaskId) {
+  try {
+    if (retryTaskId) {
+      for (const dep of await getDependentTasks(sweptId)) {
+        if (!NEVER_STARTED_STATUSES.has(dep.status))
+          continue;
+        const dependsOn = [
+          ...new Set(dep.dependsOn.map((id) => id === sweptId ? retryTaskId : id))
+        ];
+        const row = await getDbClient().get(`UPDATE agent_tasks
+              SET dependsOn = ?, lastUpdatedAt = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+            WHERE id = ? AND status = ?
+              AND EXISTS (SELECT 1 FROM json_each(agent_tasks.dependsOn) WHERE value = ?)
+            RETURNING id`, [JSON.stringify(dependsOn), dep.id, dep.status, sweptId]);
+        if (!row)
+          continue;
+        try {
+          await createLogEntry({
+            eventType: "task_dependency_repointed",
+            taskId: dep.id,
+            agentId: dep.agentId ?? undefined,
+            oldValue: sweptId,
+            newValue: retryTaskId,
+            metadata: { reason: "reboot_retry" }
+          });
+        } catch {}
+        console.log(`[Heartbeat] Reboot sweep: dependent ${dep.id.slice(0, 8)} re-pointed from ${sweptId.slice(0, 8)} to retry ${retryTaskId.slice(0, 8)}`);
+      }
+    }
+    await cascadeFailDependents(sweptId, "failed");
+  } catch (err) {
+    console.error(`[Heartbeat] Reboot sweep: settling dependents of ${sweptId} failed:`, err);
+  }
+}
 function getRebootAffectedTasks() {
   return rebootAffectedTasks;
 }
@@ -764,6 +942,18 @@ async function cleanupStaleResources(findings) {
   } catch {
     findings.staleCleanup.workflowRuns = 0;
   }
+  try {
+    findings.staleCleanup.approvalTimedOut = (await timeoutExpiredApprovalRequests()).timedOut.length;
+  } catch (err) {
+    console.error("[heartbeat] approval timeout sweep failed:", err);
+    findings.staleCleanup.approvalTimedOut = 0;
+  }
+  try {
+    findings.staleCleanup.approvalAutoCancelled = (await autoCancelStaleApprovalRequests()).cancelled.length;
+  } catch (err) {
+    console.error("[heartbeat] approval auto-cancel sweep failed:", err);
+    findings.staleCleanup.approvalAutoCancelled = 0;
+  }
 }
 function isEffectivelyEmpty(content) {
   const lines = content.split(`
@@ -970,7 +1160,9 @@ async function runHeartbeatSweep() {
           workflowRuns: 0,
           staleRuntimes: 0,
           staleOfferedTasks: 0,
-          abandonedDraftTasks: 0
+          abandonedDraftTasks: 0,
+          approvalAutoCancelled: 0,
+          approvalTimedOut: 0
         }
       };
       cleanupOnlyFindings.staleCleanup.staleRuntimes = (await expireStaleRuntimeInstances()).expired;
@@ -1018,9 +1210,11 @@ function logFindings(findings) {
     inboxProcessing,
     workflowRuns,
     staleOfferedTasks,
-    abandonedDraftTasks
+    abandonedDraftTasks,
+    approvalAutoCancelled,
+    approvalTimedOut
   } = findings.staleCleanup;
-  const totalCleanup = sessions + reviewingTasks + mentionProcessing + inboxProcessing + workflowRuns;
+  const totalCleanup = sessions + reviewingTasks + mentionProcessing + inboxProcessing + workflowRuns + approvalAutoCancelled + approvalTimedOut;
   if (totalCleanup > 0) {
     parts.push(`stale_cleanup=${totalCleanup}`);
   }
@@ -1086,21 +1280,29 @@ async function createBootTriageTask() {
   });
   console.log(`[Heartbeat] Boot triage task created for lead ${lead.name}`);
 }
-function startHeartbeatChecklist(intervalMs = HEARTBEAT_CHECKLIST_INTERVAL_MS) {
-  if (HEARTBEAT_CHECKLIST_DISABLE) {
+function startHeartbeatChecklist(intervalMs = heartbeatChecklistIntervalMs()) {
+  if (isHeartbeatChecklistDisabled()) {
     console.log("[Heartbeat] Checklist disabled via HEARTBEAT_CHECKLIST_DISABLE");
     return;
   }
-  if (checklistInterval) {
+  if (checklistInterval || bootTriageTimeout) {
+    return;
+  }
+  bootTriageTimeout = setTimeout(() => createBootTriageTask(), 90000);
+  if (intervalMs <= 0) {
+    console.log("[Heartbeat] Recurring checklist off (HEARTBEAT_CHECKLIST_INTERVAL_MS=0); boot triage still scheduled");
     return;
   }
   console.log(`[Heartbeat] Checklist starting with ${intervalMs}ms interval`);
-  setTimeout(() => createBootTriageTask(), 90000);
   checklistInterval = setInterval(() => {
     checkHeartbeatChecklist().catch((err) => console.error("[Heartbeat] checklist check failed:", scrubSecrets(err instanceof Error ? err.message : String(err))));
   }, intervalMs);
 }
 function stopHeartbeatChecklist() {
+  if (bootTriageTimeout) {
+    clearTimeout(bootTriageTimeout);
+    bootTriageTimeout = null;
+  }
   if (checklistInterval) {
     clearInterval(checklistInterval);
     checklistInterval = null;

package/dist/{cli-k0g1sjzm.js → cli-31nkw3g3.js}

@@ -1,6 +1,6 @@
 import {
   getSystemMessageText
-} from "./cli-mcnhgnn1.js";
+} from "./cli-ykk5jaax.js";
 
 // node_modules/@earendil-works/pi-ai/dist/api/constrained-sampling.js
 class UnsupportedStrictJsonSchemaError extends Error {
@@ -313,10 +313,9 @@ function clampMaxTokensToContext(model, context, maxTokens) {
   return Math.min(maxTokens, Math.max(MIN_MAX_TOKENS, available));
 }
 function buildBaseOptions(model, context, options, apiKey) {
-  const samplingParams = model.samplingParams || options?.samplingParams ? { ...model.samplingParams, ...options?.samplingParams } : undefined;
   return {
     temperature: options?.temperature,
-    samplingParams,
+    samplingParams: options?.samplingParams,
     maxTokens: clampMaxTokensToContext(model, context, options?.maxTokens ?? model.maxTokens),
     signal: options?.signal,
     telemetryContext: options?.telemetryContext,
@@ -328,6 +327,7 @@ function buildBaseOptions(model, context, options, apiKey) {
     headers: options?.headers,
     onPayload: options?.onPayload,
     onResponse: options?.onResponse,
+    onProviderStreamEvent: options?.onProviderStreamEvent,
     timeoutMs: options?.timeoutMs,
     websocketConnectTimeoutMs: options?.websocketConnectTimeoutMs,
     maxRetries: options?.maxRetries,