@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/dist/{cli-rqz8qbw7.js → cli-a8dvhzrt.js}

@@ -3,7 +3,6 @@ import {
   agentsWithLiveRuntime,
   cancelApprovalRequestAndRun,
   countActiveRuntimeInstancesForAgent,
-  createApprovalFollowUpTask,
   createPoolStarvationDecisionTask,
   createRerouteDecisionTask,
   createResumeFollowUp,
@@ -14,13 +13,17 @@ import {
   getNextResumeGeneration,
   getPinCandidateAgent,
   getResumeGeneration,
+  poolTaskRunsOnHarness,
   recoverIncompleteRuns,
   repointTrackerSyncBySwarmId,
   resolveLeadOnlyRecoveryAssignment
-} from "./cli-ftfvggzx.js";
+} from "./cli-9hsgwz4w.js";
 import {
   isMultiRuntimeEnabled
 } from "./cli-re8z5p8p.js";
+import {
+  createApprovalFollowUpTask
+} from "./cli-tpq83z89.js";
 import {
   MAX_EMPTY_POLLS,
   assignUnassignedTaskPending,
@@ -49,6 +52,7 @@ import {
   getStalePinnedResumes,
   getStaleUnassignedAffinityTasks,
   getStalledInProgressTasks,
+  getSupersededTasksWithUnsettledDependents,
   getSupersededTasksWithoutResume,
   getTaskById,
   getTaskStats,
@@ -67,15 +71,20 @@ import {
   releaseStaleProcessingInbox,
   releaseStaleReviewingTasks,
   resolveApprovalRequest,
+  settleSupersededTaskDependents,
   supersedeTask,
   updateAgentStatus
-} from "./cli-47m6dkd3.js";
+} from "./cli-qydf22qq.js";
 import {
   init_registry,
   init_resolver,
   registerTemplate,
   resolveTemplate
-} from "./cli-ggm92wcn.js";
+} from "./cli-ptr8h7kp.js";
+import {
+  init_env_flag,
+  isEnvFlagEnabled
+} from "./cli-ej6gbxfb.js";
 import {
   init_secret_scrubber,
   scrubSecrets
@@ -152,6 +161,7 @@ async function timeoutExpiredApprovalRequests(now = new Date) {
 init_db();
 init_steering();
 init_resolver();
+init_env_flag();
 init_secret_scrubber();
 
 // src/heartbeat/templates.ts
@@ -173,8 +183,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
@@ -290,10 +300,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 = [];
@@ -445,13 +467,11 @@ 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) {
-    if (!task.agentId)
-      continue;
-    if (getNextResumeGeneration(task) > maxResumeGenerations())
-      continue;
-    const resume = await createResumeFollowUp({ parentId: task.id, reason: "crash_recovery" });
-    if (resume.kind !== "created")
+    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,
@@ -461,6 +481,10 @@ async function repairSupersededWithoutResume(findings) {
     });
     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);
@@ -547,6 +571,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({
@@ -804,7 +829,7 @@ async function autoAssignPoolTasks(findings) {
           break;
         let worker;
         for (const w of idleWorkers) {
-          if (await reservedForWorker(w.id) < (w.maxTasks ?? 1) && isAgentEligibleForTask(w, task)) {
+          if (await reservedForWorker(w.id) < (w.maxTasks ?? 1) && isAgentEligibleForTask(w, task) && await poolTaskRunsOnHarness(task, w.harnessProvider ?? w.provider ?? null)) {
             worker = w;
             break;
           }
@@ -887,7 +912,13 @@ async function escalateStarvedPoolTasks(findings) {
     return;
   const registeredAgents = (await getAllAgents()).filter((a) => !a.isLead);
   for (const task of candidates) {
-    const hasEligibleAgent = registeredAgents.some((agent) => isAgentEligibleForTask(agent, task));
+    let hasEligibleAgent = false;
+    for (const agent of registeredAgents) {
+      if (isAgentEligibleForTask(agent, task) && await poolTaskRunsOnHarness(task, agent.harnessProvider ?? agent.provider ?? null)) {
+        hasEligibleAgent = true;
+        break;
+      }
+    }
     if (hasEligibleAgent)
       continue;
     const decision = await createPoolStarvationDecisionTask({ original: task });
@@ -1256,21 +1287,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;