@desplega.ai/agent-swarm 1.86.0 → 1.87.0

package/src/heartbeat/heartbeat.ts

@@ -17,18 +17,27 @@ import {
   getTaskStats,
   getTasksByStatus,
   getUnassignedPoolTasks,
+  hasNonTerminalResumeChild,
   releaseStaleMentionProcessing,
   releaseStaleProcessingInbox,
   releaseStaleReviewingTasks,
+  supersedeTask,
   updateAgentStatus,
 } from "../be/db";
 import { resolveTemplate } from "../prompts/resolver";
+import { createResumeFollowUp } from "../tasks/worker-follow-up";
 import type { AgentTask } from "../types";
 import { getExecutorRegistry } from "../workflows";
 import { recoverIncompleteRuns } from "../workflows/recovery";
 // Side-effect import: registers heartbeat event templates in the in-memory registry
 import "./templates";
 
+/**
+ * System tasks that must NOT be auto-resumed — mirrors `runRebootSweep`'s exclusion list
+ * to prevent infinite retry loops on the heartbeat/triage system tasks themselves.
+ */
+const SKIP_AUTO_RESUME_TYPES = new Set(["heartbeat-checklist", "boot-triage", "heartbeat"]);
+
 // ============================================================================
 // Configuration (env var overrides)
 // ============================================================================
@@ -65,6 +74,12 @@ const HEARTBEAT_CHECKLIST_DISABLE = Boolean(process.env.HEARTBEAT_CHECKLIST_DISA
 export interface HeartbeatFindings {
   stalledTasks: AgentTask[];
   autoFailedTasks: Array<{ taskId: string; agentId: string; reason: string }>;
+  autoResumedTasks: Array<{
+    taskId: string;
+    resumeTaskId: string;
+    agentId: string;
+    reason: string;
+  }>;
   workerHealthFixes: Array<{ agentId: string; oldStatus: string; newStatus: string }>;
   autoAssigned: Array<{ taskId: string; agentId: string }>;
   staleCleanup: {
@@ -128,6 +143,7 @@ export async function codeLevelTriage(): Promise<HeartbeatFindings> {
   const findings: HeartbeatFindings = {
     stalledTasks: [],
     autoFailedTasks: [],
+    autoResumedTasks: [],
     workerHealthFixes: [],
     autoAssigned: [],
     staleCleanup: {
@@ -175,19 +191,13 @@ function detectAndRemediateStalledTasks(findings: HeartbeatFindings): void {
     if (!session) {
       // Case A: No active session — worker is dead
       if (taskAgeMs >= STALL_THRESHOLD_NO_SESSION_MIN * 60 * 1000) {
-        const reason =
-          "Auto-failed by heartbeat: worker session not found (no active session for task)";
-        const failed = failTask(task.id, reason);
-        if (failed) {
-          findings.autoFailedTasks.push({ taskId: task.id, agentId: task.agentId, reason });
-          console.log(`[Heartbeat] Auto-failed task ${task.id.slice(0, 8)} — no active session`);
-
-          // Fix agent status if no other active tasks
-          const remaining = getActiveTaskCount(task.agentId);
-          if (remaining === 0) {
-            updateAgentStatus(task.agentId, "idle");
-          }
-        }
+        remediateCrashedWorkerTask(findings, task, {
+          supersedeReason:
+            "Auto-superseded by heartbeat: worker session not found (no active session for task)",
+          legacyFailReason:
+            "Auto-failed by heartbeat: worker session not found (no active session for task)",
+          shortLabel: "no active session",
+        });
       }
     } else {
       const sessionHeartbeatAgeMs = Date.now() - new Date(session.lastHeartbeatAt).getTime();
@@ -197,21 +207,14 @@ function detectAndRemediateStalledTasks(findings: HeartbeatFindings): void {
       if (isStaleHeartbeat) {
         // Case B: Session exists but heartbeat is stale — worker likely crashed
         if (taskAgeMs >= STALL_THRESHOLD_STALE_HEARTBEAT_MIN * 60 * 1000) {
-          const reason =
-            "Auto-failed by heartbeat: worker session heartbeat is stale (likely crashed)";
-          const failed = failTask(task.id, reason);
-          if (failed) {
-            findings.autoFailedTasks.push({ taskId: task.id, agentId: task.agentId, reason });
-            deleteActiveSession(task.id);
-            console.log(
-              `[Heartbeat] Auto-failed task ${task.id.slice(0, 8)} — stale session heartbeat`,
-            );
-
-            const remaining = getActiveTaskCount(task.agentId);
-            if (remaining === 0) {
-              updateAgentStatus(task.agentId, "idle");
-            }
-          }
+          remediateCrashedWorkerTask(findings, task, {
+            supersedeReason:
+              "Auto-superseded by heartbeat: worker session heartbeat is stale (likely crashed)",
+            legacyFailReason:
+              "Auto-failed by heartbeat: worker session heartbeat is stale (likely crashed)",
+            shortLabel: "stale session heartbeat",
+            cleanupActiveSession: true,
+          });
         }
       } else {
         // Case C: Session exists and heartbeat is fresh — ambiguous
@@ -223,6 +226,115 @@ function detectAndRemediateStalledTasks(findings: HeartbeatFindings): void {
   }
 }
 
+/**
+ * Shared remediation for Cases A (no active session) and B (stale heartbeat) of the
+ * stalled-task detector. Prefers the supersede → resume follow-up path (DES-523) so a
+ * crashed worker's task gets a fresh "resume" sibling instead of being silently dropped.
+ *
+ * Falls back to the legacy `failTask` path when:
+ *   - the task is a system task (heartbeat / boot-triage) — would loop forever,
+ *   - a non-terminal child already exists — a prior sweep already created a resume,
+ *   - `createResumeFollowUp` returns `workflow-skip` — workflow engine owns retries.
+ */
+function remediateCrashedWorkerTask(
+  findings: HeartbeatFindings,
+  task: AgentTask,
+  opts: {
+    supersedeReason: string;
+    legacyFailReason: string;
+    shortLabel: string;
+    cleanupActiveSession?: boolean;
+  },
+): void {
+  if (!task.agentId) return; // Type guard — caller already checked.
+
+  const skipAutoResume = SKIP_AUTO_RESUME_TYPES.has(task.taskType ?? "");
+  // Workflow-step tasks: skip supersede entirely so the engine's retry policy
+  // owns recovery. `createResumeFollowUp` would also bail with `workflow-skip`,
+  // but checking here avoids leaving the parent in `superseded` with a dangling
+  // dedicated-reason `failTask` no-op chasing it.
+  const isWorkflowStep = task.workflowRunStepId != null;
+  // Idempotency: if a non-terminal `resume` child already exists for this
+  // parent, a prior sweep already created the resume — fall back to the
+  // legacy fail path. We filter on `taskType = 'resume'` specifically (not
+  // any child task) because `send-task` auto-defaults `parentTaskId` to the
+  // caller's current task, so a crashed worker with delegated subtasks
+  // would otherwise be incorrectly skipped (PR #594 review).
+  const alreadyResumed = !skipAutoResume && !isWorkflowStep && hasNonTerminalResumeChild(task.id);
+
+  if (isWorkflowStep) {
+    const failed = failTask(task.id, "superseded_workflow_task");
+    if (failed) {
+      findings.autoFailedTasks.push({
+        taskId: task.id,
+        agentId: task.agentId,
+        reason: "superseded_workflow_task",
+      });
+      if (opts.cleanupActiveSession) deleteActiveSession(task.id);
+      console.log(
+        `[Heartbeat] Workflow-step task ${task.id.slice(0, 8)} failed — engine will handle retry (${opts.shortLabel})`,
+      );
+      const remaining = getActiveTaskCount(task.agentId);
+      if (remaining === 0) updateAgentStatus(task.agentId, "idle");
+    }
+    return;
+  }
+
+  if (skipAutoResume || alreadyResumed) {
+    const failed = failTask(task.id, opts.legacyFailReason);
+    if (failed) {
+      findings.autoFailedTasks.push({
+        taskId: task.id,
+        agentId: task.agentId,
+        reason: opts.legacyFailReason,
+      });
+      if (opts.cleanupActiveSession) deleteActiveSession(task.id);
+      console.log(
+        `[Heartbeat] Auto-failed task ${task.id.slice(0, 8)} — ${opts.shortLabel} (${
+          skipAutoResume ? "skipRetry taskType" : "resume already exists"
+        })`,
+      );
+      const remaining = getActiveTaskCount(task.agentId);
+      if (remaining === 0) updateAgentStatus(task.agentId, "idle");
+    }
+    return;
+  }
+
+  // Supersede + resume path.
+  const superseded = supersedeTask(task.id, {
+    reason: opts.supersedeReason,
+    resumeTaskId: null,
+  });
+  if (!superseded) return;
+
+  const resume = createResumeFollowUp({ parentId: task.id, reason: "crash_recovery" });
+
+  if (resume.kind === "created") {
+    findings.autoResumedTasks.push({
+      taskId: task.id,
+      resumeTaskId: resume.task.id,
+      agentId: task.agentId,
+      reason: opts.supersedeReason,
+    });
+    console.log(
+      `[Heartbeat] Auto-superseded task ${task.id.slice(0, 8)} — created resume ${resume.task.id.slice(0, 8)} (${opts.shortLabel})`,
+    );
+  } else {
+    // `workflow-skip` is unreachable here (handled above). `skipped` covers
+    // parent-not-found / lead-not-found edge cases — just log for operators.
+    console.log(
+      `[Heartbeat] Task ${task.id.slice(0, 8)} superseded but no resume created (${
+        resume.kind === "skipped" ? resume.reason : "workflow-skip"
+      })`,
+    );
+  }
+
+  if (opts.cleanupActiveSession) deleteActiveSession(task.id);
+
+  const remaining = getActiveTaskCount(task.agentId);
+  if (remaining === 0) updateAgentStatus(task.agentId, "idle");
+}
+
 /**
  * Aggressive sweep that runs once after server restart.
  * Ignores age thresholds — any in_progress task with no active session is auto-failed.
@@ -268,8 +380,7 @@ export async function runRebootSweep(): Promise<void> {
       }
 
       // Don't retry system-generated heartbeat tasks
-      const skipRetryTypes = ["heartbeat-checklist", "boot-triage", "heartbeat"];
-      if (skipRetryTypes.includes(task.taskType ?? "")) {
+      if (SKIP_AUTO_RESUME_TYPES.has(task.taskType ?? "")) {
         rebootAffectedTasks.push({ original: failed, retryTaskId: null });
         continue;
       }
@@ -674,6 +785,7 @@ export async function runHeartbeatSweep(): Promise<void> {
       const cleanupOnlyFindings: HeartbeatFindings = {
         stalledTasks: [],
         autoFailedTasks: [],
+        autoResumedTasks: [],
         workerHealthFixes: [],
         autoAssigned: [],
         staleCleanup: {
@@ -708,6 +820,9 @@ function logFindings(findings: HeartbeatFindings): void {
   if (findings.autoFailedTasks.length > 0) {
     parts.push(`auto_failed=${findings.autoFailedTasks.length}`);
   }
+  if (findings.autoResumedTasks.length > 0) {
+    parts.push(`auto_resumed=${findings.autoResumedTasks.length}`);
+  }
   if (findings.stalledTasks.length > 0) {
     parts.push(`stalled=${findings.stalledTasks.length}`);
   }

package/src/heartbeat/templates.ts

@@ -78,13 +78,17 @@ The API server has just restarted (deployment, pod rotation, or crash). An aggre
    - If a retry failed or is stuck, re-create the task manually
    - If the work is no longer needed, cancel the retry task
    - You MUST address every item — do NOT skip this section
-2. **Check orphaned tasks.** If the "Orphaned Tasks" section lists pending/offered tasks assigned to offline workers, re-assign or cancel them.
-3. Review agent status — are all expected workers online? If not, note which are missing.
-4. Review your standing orders for any post-reboot checks.
-5. Take action using your available tools.
-6. Complete this task with a summary of what you found and what actions you took. Include the status of each reboot-interrupted task.
-7. Do NOT create another boot-triage task — this is a one-off event.
-8. **Update your standing orders** — If the reboot revealed a pattern worth monitoring (e.g., frequent restarts, specific tasks that keep failing), add a standing order to HEARTBEAT.md via \`update-profile\` with \`heartbeatMd\`.`,
+2. **Verify supersede + resume worked end-to-end.** Worker crashes / OOMs are recovered via supersede (parent → \`superseded\`) + a fresh \`taskType=resume\` child created by the heartbeat sweep (DES-523). Sanity check:
+   - List recent \`superseded\` tasks: \`list-tasks status=superseded\` (last ~hour).
+   - For each, confirm a child task with \`taskType=resume\` and a non-terminal status exists. If a superseded task is missing its resume child, the work is silently dropped — recreate the task manually.
+   - Look for \`in_progress\` tasks older than 5 min on agents that show as offline — the sweep should have caught them. If any remain, recreate as needed.
+3. **Check orphaned tasks.** If the "Orphaned Tasks" section lists pending/offered tasks assigned to offline workers, re-assign or cancel them.
+4. Review agent status — are all expected workers online? If not, note which are missing.
+5. Review your standing orders for any post-reboot checks.
+6. Take action using your available tools.
+7. Complete this task with a summary of what you found and what actions you took. Include the status of each reboot-interrupted task.
+8. Do NOT create another boot-triage task — this is a one-off event.
+9. **Update your standing orders** — If the reboot revealed a pattern worth monitoring (e.g., frequent restarts, specific tasks that keep failing), add a standing order to HEARTBEAT.md via \`update-profile\` with \`heartbeatMd\`.`,
   variables: [
     {
       name: "system_status",

package/src/http/session-data.ts

@@ -46,6 +46,13 @@ const getSessionLogsByTask = route({
   summary: "Get session logs for a task",
   tags: ["Session Data"],
   params: z.object({ taskId: z.string() }),
+  query: z.object({
+    // When set, returns the last N log rows ordered ASC. Used by the
+    // resume context preamble to avoid pulling the full log set over HTTP
+    // just to slice the tail. Server-side limit prevents OOM / slow
+    // dispatch for tasks with very long run history (PR #594 review).
+    limit: z.coerce.number().int().min(1).max(1000).optional(),
+  }),
   responses: {
     200: { description: "Session logs" },
     404: { description: "Task not found" },
@@ -181,7 +188,7 @@ export async function handleSessionData(
       jsonError(res, "Task not found", 404);
       return true;
     }
-    const logs = getSessionLogsByTaskId(parsed.params.taskId);
+    const logs = getSessionLogsByTaskId(parsed.params.taskId, parsed.query?.limit);
     json(res, { logs });
     return true;
   }

package/src/http/tasks.ts

@@ -16,20 +16,23 @@ import {
   getUserById,
   pauseTask,
   resumeTask,
+  supersedeTask,
   updateAgentStatusFromCapacity,
   updateTaskClaudeSessionId,
   updateTaskProgress,
   updateTaskVcs,
 } from "../be/db";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
-import { createWorkerTaskFollowUp } from "../tasks/worker-follow-up";
+import { createResumeFollowUp, createWorkerTaskFollowUp } from "../tasks/worker-follow-up";
 import { telemetry } from "../telemetry";
 import {
   type AgentTaskSource,
   AgentTaskSourceSchema,
   type AgentTaskStatus,
   AgentTaskStatusSchema,
+  isTerminalTaskStatus,
   ProviderNameSchema,
+  ResumeReasonSchema,
 } from "../types";
 import { route } from "./route-def";
 import { json, jsonError } from "./utils";
@@ -234,6 +237,25 @@ const resumeTaskRoute = route({
   },
 });
 
+const supersedeTaskRoute = route({
+  method: "post",
+  path: "/api/tasks/{id}/supersede",
+  pattern: ["api", "tasks", null, "supersede"],
+  summary: "Supersede an in-progress task (terminate + spawn resume follow-up)",
+  description:
+    'Marks the original task `superseded` (terminal) and creates a fresh `taskType="resume"` follow-up so a worker can pick up the work in a new provider session. Workflow-step tasks (those with `workflowRunStepId`) are carved out: the original is marked `failed` with reason `superseded_workflow_task` and no follow-up is created — the workflow engine\'s retry/failure policy applies.',
+  tags: ["Tasks"],
+  params: z.object({ id: z.string() }),
+  body: z.object({ reason: ResumeReasonSchema }),
+  auth: { apiKey: true, agentId: true },
+  responses: {
+    200: { description: "Task superseded (or workflow-failed)" },
+    400: { description: "Task not in_progress" },
+    403: { description: "Task belongs to another agent" },
+    404: { description: "Task not found" },
+  },
+});
+
 const updateTaskVcsRoute = route({
   method: "patch",
   path: "/api/tasks/{id}/vcs",
@@ -429,8 +451,7 @@ export async function handleTasks(
       return true;
     }
 
-    const terminalStatuses = ["completed", "failed", "cancelled"];
-    if (terminalStatuses.includes(task.status)) {
+    if (isTerminalTaskStatus(task.status)) {
       jsonError(res, `Cannot cancel task with status '${task.status}'`, 400);
       return true;
     }
@@ -776,5 +797,133 @@ export async function handleTasks(
     return true;
   }
 
+  if (supersedeTaskRoute.match(req.method, pathSegments)) {
+    const parsed = await supersedeTaskRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    const task = getTaskById(parsed.params.id);
+
+    if (!task) {
+      jsonError(res, "Task not found", 404);
+      return true;
+    }
+
+    if (myAgentId && task.agentId !== myAgentId) {
+      jsonError(res, "Task belongs to another agent", 403);
+      return true;
+    }
+
+    // Idempotency: if already terminal, return the alreadyFinished-shaped
+    // response (mirrors finishTask). Caller treats this as a successful
+    // supersede.
+    if (isTerminalTaskStatus(task.status)) {
+      json(res, {
+        success: true,
+        kind: "alreadyFinished",
+        task,
+        resumeTaskId: null,
+      });
+      return true;
+    }
+
+    if (task.status !== "in_progress") {
+      jsonError(res, `Task status is '${task.status}', not 'in_progress'`, 400);
+      return true;
+    }
+
+    // Workflow-step tasks: fail back to the engine instead of superseding.
+    // Check this BEFORE the supersede UPDATE so we don't leave a workflow
+    // step in `superseded` if the engine expects `failed`.
+    if (task.workflowRunStepId != null) {
+      const failed = failTask(parsed.params.id, "superseded_workflow_task");
+      ensure({
+        id: "task.workflow_step_failed_on_supersede",
+        flow: "task",
+        runId: parsed.params.id,
+        data: {
+          taskId: parsed.params.id,
+          agentId: task.agentId,
+          stepId: task.workflowRunStepId,
+          reason: parsed.body.reason,
+        },
+      });
+      json(res, {
+        success: true,
+        kind: "workflow-failed",
+        task: failed,
+        resumeTaskId: null,
+      });
+      return true;
+    }
+
+    // Supersede FIRST (atomic + idempotent in db.ts) so we don't orphan a
+    // resume child if a worker races to complete/fail/cancel between the
+    // pre-read status check and the supersede UPDATE.
+    const superseded = supersedeTask(parsed.params.id, {
+      reason: parsed.body.reason,
+      // resumeTaskId is attached AFTER the child is created. Lost race here
+      // means no child is created at all, so the log entry's null is accurate.
+      resumeTaskId: null,
+    });
+    if (!superseded) {
+      // Worker won the race (terminal transition between status check and
+      // this UPDATE). Treat as `alreadyFinished` — no resume child is created.
+      const fresh = getTaskById(parsed.params.id);
+      json(res, {
+        success: true,
+        kind: "alreadyFinished",
+        task: fresh,
+        resumeTaskId: null,
+      });
+      return true;
+    }
+
+    // Parent is now superseded. Create the resume child.
+    const followUp = createResumeFollowUp({
+      parentId: parsed.params.id,
+      reason: parsed.body.reason,
+    });
+
+    // `workflow-skip` is unreachable here (workflow-step path branched above).
+    // `skipped` covers parent_not_found / lead_not_found edge cases — the
+    // supersede already landed, so log + roll forward without a resume task.
+    if (followUp.kind !== "created") {
+      console.warn(
+        `[Supersede] Task ${parsed.params.id.slice(0, 8)} superseded but resume creation skipped (${
+          followUp.kind === "skipped" ? followUp.reason : followUp.kind
+        })`,
+      );
+      json(res, {
+        success: true,
+        kind: "resumed",
+        task: superseded,
+        resumeTaskId: null,
+      });
+      return true;
+    }
+
+    const resumeTaskId = followUp.task.id;
+
+    ensure({
+      id: "task.superseded",
+      flow: "task",
+      runId: parsed.params.id,
+      data: {
+        taskId: parsed.params.id,
+        agentId: task.agentId,
+        reason: parsed.body.reason,
+        resumeTaskId,
+      },
+    });
+
+    json(res, {
+      success: true,
+      kind: "resumed",
+      task: superseded,
+      resumeTaskId,
+      resumeTaskStatus: followUp.task.status,
+    });
+    return true;
+  }
+
   return false;
 }

package/src/jira/sync.ts

@@ -25,7 +25,7 @@ import { ensureToken, ensureTokenOrThrow } from "../oauth/ensure-token";
 import { resolveTemplate } from "../prompts/resolver";
 import { buildJiraContextKey } from "../tasks/context-key";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
-import type { Agent } from "../types";
+import { type Agent, isTerminalTaskStatus } from "../types";
 import { extractMentions, extractText } from "./adf";
 import { getJiraMetadata } from "./metadata";
 // Side-effect import: registers all Jira event templates in the prompt registry
@@ -252,7 +252,7 @@ export async function handleIssueEvent(event: Record<string, unknown>): Promise<
 
   // Pre-existing — branch on prior task state.
   const priorTask = claim.sync.swarmId ? getTaskById(claim.sync.swarmId) : null;
-  if (priorTask && !["completed", "failed", "cancelled"].includes(priorTask.status)) {
+  if (priorTask && !isTerminalTaskStatus(priorTask.status)) {
     // In-progress: do not duplicate. Match Linear's behavior of acknowledging
     // and continuing with the existing task.
     console.log(
@@ -408,7 +408,7 @@ async function routeCommentOnExistingSync(input: {
   syncRow: { id: string; swarmId: string };
 }): Promise<void> {
   const priorTask = input.syncRow.swarmId ? getTaskById(input.syncRow.swarmId) : null;
-  if (priorTask && !["completed", "failed", "cancelled"].includes(priorTask.status)) {
+  if (priorTask && !isTerminalTaskStatus(priorTask.status)) {
     // In-progress: log and ignore (mirrors Linear's prompted-on-active path).
     console.log(
       `[Jira Sync] Bot mentioned on issue ${input.issueKey} but task ${priorTask.id} still ${priorTask.status} — ignoring`,
@@ -440,7 +440,7 @@ export async function handleIssueDeleteEvent(event: Record<string, unknown>): Pr
   if (!sync) return;
 
   const task = sync.swarmId ? getTaskById(sync.swarmId) : null;
-  if (task && !["completed", "failed", "cancelled"].includes(task.status)) {
+  if (task && !isTerminalTaskStatus(task.status)) {
     cancelTask(sync.swarmId, "Jira issue deleted");
     console.log(
       `[Jira Sync] Cancelled task ${sync.swarmId} (Jira issue ${issue.key ?? issue.id} deleted)`,

package/src/linear/sync.ts

@@ -11,6 +11,7 @@ import { ensureToken } from "../oauth/ensure-token";
 import { resolveTemplate } from "../prompts/resolver";
 import { linearContextKey } from "../tasks/context-key";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
+import { isTerminalTaskStatus } from "../types";
 import {
   buildSkipMessage,
   getLinearGateConfig,
@@ -503,7 +504,7 @@ export async function handleAgentSessionEvent(event: Record<string, unknown>): P
     // session can be closed. Do NOT create a duplicate swarm task. If the user
     // wants to force a fresh run, they can re-assign the issue after the
     // current task finishes.
-    if (existingTask && !["completed", "failed", "cancelled"].includes(existingTask.status)) {
+    if (existingTask && !isTerminalTaskStatus(existingTask.status)) {
       console.log(
         `[Linear Sync] Issue ${issueIdentifier} already tracked as active task ${existing.swarmId} (status: ${existingTask.status}), skipping duplicate`,
       );
@@ -671,7 +672,7 @@ export async function handleIssueUpdate(
   // Map status to swarm actions
   if (swarmStatus === "cancelled") {
     const task = getTaskById(sync.swarmId);
-    if (task && !["completed", "failed", "cancelled"].includes(task.status)) {
+    if (task && !isTerminalTaskStatus(task.status)) {
       cancelTask(sync.swarmId, `Linear issue cancelled`);
       console.log(
         `[Linear Sync] Cancelled task ${sync.swarmId} (Linear issue ${data.identifier ?? issueId} cancelled)`,
@@ -709,7 +710,7 @@ export async function handleIssueDelete(event: Record<string, unknown>): Promise
   if (!sync) return;
 
   const task = getTaskById(sync.swarmId);
-  if (task && !["completed", "failed", "cancelled"].includes(task.status)) {
+  if (task && !isTerminalTaskStatus(task.status)) {
     cancelTask(sync.swarmId, "Linear issue deleted");
     console.log(`[Linear Sync] Cancelled task ${sync.swarmId} (Linear issue ${issueId} deleted)`);
   }
@@ -750,7 +751,7 @@ export async function handleAgentSessionPrompted(event: Record<string, unknown>)
     const existing = getTrackerSyncByExternalId("linear", "task", issueId);
     if (existing) {
       const existingTask = getTaskById(existing.swarmId);
-      if (existingTask && !["completed", "failed", "cancelled"].includes(existingTask.status)) {
+      if (existingTask && !isTerminalTaskStatus(existingTask.status)) {
         cancelTask(existing.swarmId, "Stopped by user from Linear");
         console.log(`[Linear Sync] Cancelled task ${existing.swarmId} (stop signal from Linear)`);
       }
@@ -775,7 +776,7 @@ export async function handleAgentSessionPrompted(event: Record<string, unknown>)
     const existingTask = getTaskById(existing.swarmId);
 
     // If the task is still in progress, acknowledge but don't create a new one
-    if (existingTask && !["completed", "failed", "cancelled"].includes(existingTask.status)) {
+    if (existingTask && !isTerminalTaskStatus(existingTask.status)) {
       console.log(`[Linear Sync] Prompted on in-progress task ${existing.swarmId}, acknowledging`);
       if (sessionId) {
         postAgentSessionThought(