@desplega.ai/agent-swarm 1.157.0 → 1.158.0

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

@@ -1,7 +1,9 @@
 import {
   REBOOT_RETRY_PIN_TAG,
   agentsWithLiveRuntime,
+  cancelApprovalRequestAndRun,
   countActiveRuntimeInstancesForAgent,
+  createApprovalFollowUpTask,
   createPoolStarvationDecisionTask,
   createRerouteDecisionTask,
   createResumeFollowUp,
@@ -15,7 +17,7 @@ import {
   recoverIncompleteRuns,
   repointTrackerSyncBySwarmId,
   resolveLeadOnlyRecoveryAssignment
-} from "./cli-01vfmq8c.js";
+} from "./cli-ftfvggzx.js";
 import {
   isMultiRuntimeEnabled
 } from "./cli-re8z5p8p.js";
@@ -24,6 +26,7 @@ import {
   assignUnassignedTaskPending,
   backfillSupersedeTaskResumeTaskId,
   buildRoutingAffinityFromAgent,
+  cascadeFailDependents,
   cleanupStaleSessions,
   createLogEntry,
   createTaskExtended,
@@ -34,15 +37,19 @@ import {
   getActiveTaskCount,
   getAllAgents,
   getDbClient,
+  getDependentTasks,
+  getExpiredPendingApprovals,
   getIdleWorkersWithCapacity,
   getLeadAgent,
   getPendingSteeringForTask,
   getRecentCompletedCount,
   getRecentFailedCount,
   getRecentFailedTasks,
+  getStaleApprovalRequests,
   getStalePinnedResumes,
   getStaleUnassignedAffinityTasks,
   getStalledInProgressTasks,
+  getSupersededTasksWithoutResume,
   getTaskById,
   getTaskStats,
   getTasksByStatus,
@@ -59,9 +66,10 @@ import {
   releaseStaleOfferedTasksForOfflineAgents,
   releaseStaleProcessingInbox,
   releaseStaleReviewingTasks,
+  resolveApprovalRequest,
   supersedeTask,
   updateAgentStatus
-} from "./cli-awwphhcs.js";
+} from "./cli-47m6dkd3.js";
 import {
   init_registry,
   init_resolver,
@@ -73,6 +81,73 @@ import {
   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();
@@ -260,12 +335,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 +439,29 @@ 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) {
+    if (!task.agentId)
+      continue;
+    if (getNextResumeGeneration(task) > maxResumeGenerations())
+      continue;
+    const resume = await createResumeFollowUp({ parentId: task.id, reason: "crash_recovery" });
+    if (resume.kind !== "created")
+      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)}`);
+  }
+}
 function isRemediationAction(value) {
   return typeof value === "string" && REMEDIATION_ACTIONS.has(value);
 }
@@ -393,7 +494,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 +519,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;
@@ -510,94 +614,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 +918,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 +1136,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 +1186,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}`);
   }

package/dist/{cli-p37sg0a9.js → cli-s8eet254.js}

@@ -63160,7 +63160,7 @@ function getCreateJiti() {
 }
 var virtualModulesPromise;
 function getVirtualModules() {
-  virtualModulesPromise ??= import("./virtual-modules-8qheft18.js").then((module) => module.VIRTUAL_MODULES);
+  virtualModulesPromise ??= import("./virtual-modules-3htpgn8x.js").then((module) => module.VIRTUAL_MODULES);
   return virtualModulesPromise;
 }
 var _aliases = null;