@desplega.ai/agent-swarm 1.55.0 → 1.56.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.55.0",
+  "version": "1.56.2",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",

package/src/be/db.ts

@@ -229,6 +229,7 @@ const VERSIONABLE_FIELDS: VersionableField[] = [
   "toolsMd",
   "claudeMd",
   "setupScript",
+  "heartbeatMd",
 ];
 
 function ensureAgentProfileColumns(database: Database): void {
@@ -399,9 +400,10 @@ function seedContextVersions(): void {
         toolsMd: string | null;
         claudeMd: string | null;
         setupScript: string | null;
+        heartbeatMd: string | null;
       },
       []
-    >(`SELECT id, soulMd, identityMd, toolsMd, claudeMd, setupScript FROM agents`)
+    >(`SELECT id, soulMd, identityMd, toolsMd, claudeMd, setupScript, heartbeatMd FROM agents`)
     .all();
 
   for (const agent of agents) {
@@ -450,6 +452,7 @@ type AgentRow = {
   identityMd: string | null;
   setupScript: string | null;
   toolsMd: string | null;
+  heartbeatMd: string | null;
   lastActivityAt: string | null;
   createdAt: string;
   lastUpdatedAt: string;
@@ -471,6 +474,7 @@ function rowToAgent(row: AgentRow): Agent {
     identityMd: row.identityMd ?? undefined,
     setupScript: row.setupScript ?? undefined,
     toolsMd: row.toolsMd ?? undefined,
+    heartbeatMd: row.heartbeatMd ?? undefined,
     lastActivityAt: row.lastActivityAt ?? undefined,
     createdAt: row.createdAt,
     lastUpdatedAt: row.lastUpdatedAt,
@@ -2259,6 +2263,7 @@ export function updateAgentProfile(
     identityMd?: string;
     setupScript?: string;
     toolsMd?: string;
+    heartbeatMd?: string;
   },
   meta?: VersionMeta,
 ): Agent | null {
@@ -2312,6 +2317,7 @@ export function updateAgentProfile(
           string | null,
           string | null,
           string | null,
+          string | null,
           string,
           string,
         ]
@@ -2325,6 +2331,7 @@ export function updateAgentProfile(
           identityMd = COALESCE(?, identityMd),
           setupScript = COALESCE(?, setupScript),
           toolsMd = COALESCE(?, toolsMd),
+          heartbeatMd = COALESCE(?, heartbeatMd),
           lastUpdatedAt = ?
          WHERE id = ? RETURNING *`,
       )
@@ -2337,6 +2344,7 @@ export function updateAgentProfile(
         updates.identityMd ?? null,
         updates.setupScript ?? null,
         updates.toolsMd ?? null,
+        updates.heartbeatMd ?? null,
         now,
         id,
       );

package/src/be/migrations/025_workflow_run_cancelled_status.sql

@@ -1,5 +1,3 @@
-PRAGMA defer_foreign_keys = ON;
-
 -- Add 'cancelled' as a valid status for workflow runs.
 -- SQLite does not support ALTER CHECK constraints, so we recreate the table.
 

package/src/be/migrations/027_heartbeat_md.sql

@@ -0,0 +1 @@
+ALTER TABLE agents ADD COLUMN heartbeatMd TEXT DEFAULT NULL;

package/src/be/migrations/runner.ts

@@ -152,6 +152,12 @@ export function runMigrations(db: Database): void {
   }
 
   // 5. Run pending migrations
+  // Disable FK checks for the entire migration pass. Individual migrations
+  // (008, 025, 026) need to DROP + recreate tables, which can violate FKs
+  // mid-transaction. PRAGMA foreign_keys cannot be changed inside a transaction,
+  // so we disable it here, outside any transaction, and re-enable after.
+  db.run("PRAGMA foreign_keys = OFF");
+
   for (const migration of migrations) {
     const existing = applied.get(migration.version);
 
@@ -184,4 +190,6 @@ export function runMigrations(db: Database): void {
     const elapsed = (performance.now() - start).toFixed(1);
     console.debug(`[migrations] Applied: ${migration.name} (${elapsed}ms)`);
   }
+
+  db.run("PRAGMA foreign_keys = ON");
 }

package/src/commands/runner.ts

@@ -1991,6 +1991,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
   let agentSetupScript: string | undefined;
   let agentToolsMd: string | undefined;
   let agentClaudeMd: string | undefined;
+  let agentHeartbeatMd: string | undefined;
   let agentProfileName: string | undefined;
   let agentDescription: string | undefined;
   let agentSkillsSummary: { name: string; description: string }[] | undefined;
@@ -2170,6 +2171,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           claudeMd?: string;
           setupScript?: string;
           toolsMd?: string;
+          heartbeatMd?: string;
           name?: string;
           description?: string;
         };
@@ -2178,12 +2180,19 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
         agentSetupScript = profile.setupScript;
         agentToolsMd = profile.toolsMd;
         agentClaudeMd = profile.claudeMd;
+        agentHeartbeatMd = profile.heartbeatMd;
         agentProfileName = profile.name;
         agentDescription = profile.description;
 
         // Generate default templates if missing (runner registers via POST /api/agents
         // which doesn't generate templates like join-swarm does)
-        if (!agentSoulMd || !agentIdentityMd || !agentToolsMd || !agentClaudeMd) {
+        if (
+          !agentSoulMd ||
+          !agentIdentityMd ||
+          !agentToolsMd ||
+          !agentClaudeMd ||
+          !agentHeartbeatMd
+        ) {
           // Use already-fetched template (from pre-registration step)
           if (cachedTemplate) {
             const ctx = {
@@ -2202,6 +2211,8 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
               agentClaudeMd = interpolate(cachedTemplate.files.claudeMd, ctx).result;
             if (!agentSetupScript)
               agentSetupScript = interpolate(cachedTemplate.files.setupScript, ctx).result;
+            if (!agentHeartbeatMd)
+              agentHeartbeatMd = interpolate(cachedTemplate.files.heartbeatMd, ctx).result;
             console.log(`[${role}] Applied template: ${templateId}`);
           }
 
@@ -2226,6 +2237,8 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
             if (!profile.claudeMd && agentClaudeMd) profileUpdate.claudeMd = agentClaudeMd;
             if (!profile.setupScript && agentSetupScript)
               profileUpdate.setupScript = agentSetupScript;
+            if (!profile.heartbeatMd && agentHeartbeatMd)
+              profileUpdate.heartbeatMd = agentHeartbeatMd;
 
             await fetch(`${apiUrl}/api/agents/${agentId}/profile`, {
               method: "PUT",
@@ -2364,6 +2377,16 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
       }
     }
 
+    // Write HEARTBEAT.md to workspace (lead's periodic checklist)
+    if (agentHeartbeatMd) {
+      try {
+        await Bun.write("/workspace/HEARTBEAT.md", agentHeartbeatMd);
+        console.log(`[${role}] Wrote HEARTBEAT.md to workspace`);
+      } catch (err) {
+        console.warn(`[${role}] Could not write HEARTBEAT.md: ${(err as Error).message}`);
+      }
+    }
+
     // Write CLAUDE.md to workspace (agent-level instructions)
     if (agentClaudeMd) {
       try {

package/src/heartbeat/heartbeat.ts

@@ -47,11 +47,12 @@ const STALE_CLEANUP_THRESHOLD_MINUTES = Number(process.env.HEARTBEAT_STALE_CLEAN
 /** Max pool tasks to auto-assign per sweep */
 const MAX_AUTO_ASSIGN_PER_SWEEP = Number(process.env.HEARTBEAT_MAX_AUTO_ASSIGN) || 5;
 
-/** Escalation cooldown: minimum time between escalations for the same task set (ms) */
-const ESCALATION_COOLDOWN_MS =
-  Number(process.env.HEARTBEAT_ESCALATION_COOLDOWN_MS) || 15 * 60 * 1000;
+/** Heartbeat checklist interval: how often to check HEARTBEAT.md (default: 30 min) */
+const HEARTBEAT_CHECKLIST_INTERVAL_MS =
+  Number(process.env.HEARTBEAT_CHECKLIST_INTERVAL_MS) || 30 * 60 * 1000;
 
-const HEARTBEAT_ESCALATION_MARKER = "[heartbeat-escalation]";
+/** Whether to disable the heartbeat checklist entirely */
+const HEARTBEAT_CHECKLIST_DISABLE = Boolean(process.env.HEARTBEAT_CHECKLIST_DISABLE);
 
 // ============================================================================
 // Types
@@ -69,8 +70,6 @@ export interface HeartbeatFindings {
     inboxProcessing: number;
     workflowRuns: number;
   };
-  escalationNeeded: boolean;
-  escalationReason?: string;
 }
 
 // ============================================================================
@@ -78,11 +77,9 @@ export interface HeartbeatFindings {
 // ============================================================================
 
 let heartbeatInterval: ReturnType<typeof setInterval> | null = null;
+let checklistInterval: ReturnType<typeof setInterval> | null = null;
 let isSweeping = false;
 
-/** Tracks last escalation time per escalation key to prevent spam */
-const lastEscalationTime: Map<string, number> = new Map();
-
 // ============================================================================
 // Tier 1: Preflight Gate
 // ============================================================================
@@ -133,10 +130,9 @@ export async function codeLevelTriage(): Promise<HeartbeatFindings> {
       inboxProcessing: 0,
       workflowRuns: 0,
     },
-    escalationNeeded: false,
   };
 
-  // 1. Detect and remediate stalled tasks (tiered: auto-fail dead workers, escalate ambiguous)
+  // 1. Detect and remediate stalled tasks (tiered: auto-fail dead workers)
   detectAndRemediateStalledTasks(findings);
 
   // 2. Check and fix worker health
@@ -148,9 +144,6 @@ export async function codeLevelTriage(): Promise<HeartbeatFindings> {
   // 4. Cleanup stale resources (including workflow run recovery)
   await cleanupStaleResources(findings);
 
-  // 5. Determine if escalation is needed
-  evaluateEscalation(findings);
-
   return findings;
 }
 
@@ -306,102 +299,150 @@ async function cleanupStaleResources(findings: HeartbeatFindings): Promise<void>
 }
 
 // ============================================================================
-// Tier 3: Escalation
+// Heartbeat Checklist (HEARTBEAT.md-based periodic check)
 // ============================================================================
 
 /**
- * Evaluate whether findings require escalation to a Claude session (lead agent).
- * Only escalate for ambiguous stalls (worker alive but task not updating).
+ * Check if content is effectively empty (only headers, comments, empty items).
+ * Returns true if there are no actionable items — the checklist should be skipped.
  */
-function evaluateEscalation(findings: HeartbeatFindings): void {
-  if (findings.stalledTasks.length > 0) {
-    findings.escalationNeeded = true;
-    const taskIds = findings.stalledTasks.map((t) => t.id.slice(0, 8)).join(", ");
-    findings.escalationReason = `${findings.stalledTasks.length} task(s) stalled with active worker (no task update for ${STALL_THRESHOLD_MINUTES}+ min): ${taskIds}`;
-  }
-}
+export function isEffectivelyEmpty(content: string): boolean {
+  const lines = content.split("\n");
+  let inComment = false;
 
-/**
- * Create a triage task for the lead agent to investigate ambiguous findings.
- */
-function escalateToLead(findings: HeartbeatFindings): void {
-  const lead = getLeadAgent();
-  if (!lead) {
-    console.log("[Heartbeat] No lead agent found — skipping escalation");
-    return;
-  }
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Track multi-line HTML comments
+    if (inComment) {
+      if (trimmed.includes("-->")) {
+        inComment = false;
+      }
+      continue;
+    }
 
-  const escalationKey = buildEscalationKey(findings);
+    if (trimmed.startsWith("<!--")) {
+      if (!trimmed.includes("-->")) {
+        inComment = true;
+      }
+      continue;
+    }
 
-  // Cooldown check — prevent repeated escalations for the same task set
-  const lastTime = lastEscalationTime.get(escalationKey);
-  if (lastTime && Date.now() - lastTime < ESCALATION_COOLDOWN_MS) {
-    return;
-  }
+    // Skip blank lines
+    if (trimmed === "") continue;
 
-  if (hasActiveEscalationTask(lead.id, escalationKey)) {
-    return;
+    // Skip markdown headers
+    if (/^#{1,6}\s/.test(trimmed)) continue;
+
+    // Skip empty list items (just a marker with no text)
+    if (/^[-*+]\s*\[\s*\]\s*$/.test(trimmed)) continue;
+    if (/^[-*+]\s*$/.test(trimmed)) continue;
+
+    // If we get here, there's real content
+    return false;
   }
 
-  // Build stalled tasks section
-  let stalledTasksSection = "";
-  if (findings.stalledTasks.length > 0) {
-    const lines: string[] = ["## Stalled Tasks"];
-    for (const task of findings.stalledTasks) {
+  return true;
+}
+
+/**
+ * Gather current system status as a markdown string for the lead's checklist task.
+ */
+export function gatherSystemStatus(): string {
+  const stats = getTaskStats();
+  const stalledTasks = getStalledInProgressTasks(STALL_THRESHOLD_MINUTES);
+  const agents = getAllAgents();
+  const idleWorkers = getIdleWorkersWithCapacity();
+  const poolTasks = getUnassignedPoolTasks(10);
+
+  const sections: string[] = [];
+
+  // Task overview
+  sections.push("## Task Overview [auto-generated]");
+  sections.push(`- In Progress: ${stats.in_progress ?? 0}`);
+  sections.push(`- Pending: ${stats.pending ?? 0}`);
+  sections.push(`- Unassigned: ${stats.unassigned ?? 0}`);
+  sections.push(`- Completed (24h): ${stats.completed ?? 0}`);
+  sections.push(`- Failed (24h): ${stats.failed ?? 0}`);
+
+  // Stalled tasks
+  if (stalledTasks.length > 0) {
+    sections.push("");
+    sections.push("## Stalled Tasks [auto-generated]");
+    for (const task of stalledTasks) {
       const agentSlice = task.agentId?.slice(0, 8) ?? "unassigned";
-      lines.push(
-        `- Task ${task.id.slice(0, 8)} (agent: ${agentSlice}): last updated ${task.lastUpdatedAt}`,
+      sections.push(
+        `- [${task.id.slice(0, 8)}] "${task.task.slice(0, 60)}" — assigned to ${agentSlice}, last update: ${task.lastUpdatedAt}`,
       );
     }
-    lines.push(
-      "\nCheck if these tasks are genuinely stuck or just working without calling store-progress. " +
-        "If stuck, consider cancelling and reassigning.",
-    );
-    stalledTasksSection = lines.join("\n");
   }
 
-  const escalationMarker = `\n${HEARTBEAT_ESCALATION_MARKER} ${escalationKey}`;
-
-  const result = resolveTemplate("heartbeat.escalation.stalled", {
-    stalled_tasks_section: stalledTasksSection,
-    escalation_marker: escalationMarker,
-  });
+  // Agent status
+  const idle = agents.filter((a) => a.status === "idle");
+  const busy = agents.filter((a) => a.status === "busy");
+  const offline = agents.filter((a) => a.status === "offline");
+  sections.push("");
+  sections.push("## Agent Status [auto-generated]");
+  sections.push(
+    `- Online: ${idle.length + busy.length} (${idle.length} idle, ${busy.length} busy), Offline: ${offline.length}`,
+  );
 
-  if (result.skipped) {
-    return;
+  // Available work
+  if (poolTasks.length > 0 || idleWorkers.length > 0) {
+    sections.push("");
+    sections.push("## Available Work [auto-generated]");
+    if (poolTasks.length > 0) {
+      sections.push(`- ${poolTasks.length} unassigned pool task(s) waiting`);
+    }
+    if (idleWorkers.length > 0) {
+      sections.push(`- ${idleWorkers.length} idle worker(s) with capacity`);
+    }
   }
 
-  createTaskExtended(result.text, {
-    agentId: lead.id,
-    taskType: "heartbeat",
-    tags: ["heartbeat", "triage", "auto-generated"],
-    priority: 70,
-  });
-
-  lastEscalationTime.set(escalationKey, Date.now());
-  console.log(`[Heartbeat] Created triage task for lead ${lead.name}`);
+  return sections.join("\n");
 }
 
-function buildEscalationKey(findings: HeartbeatFindings): string {
-  const stalledTaskIds = findings.stalledTasks
-    .map((task) => task.id)
-    .sort((a, b) => a.localeCompare(b));
-  return `stalled:${stalledTaskIds.join(",")}`;
-}
+/**
+ * Check HEARTBEAT.md content and create a checklist task for the lead if needed.
+ */
+export async function checkHeartbeatChecklist(): Promise<void> {
+  const lead = getLeadAgent();
+  if (!lead) return;
+
+  const heartbeatMd = lead.heartbeatMd;
+  if (!heartbeatMd) return;
 
-function hasActiveEscalationTask(leadAgentId: string, escalationKey: string): boolean {
+  if (isEffectivelyEmpty(heartbeatMd)) return;
+
+  // Dedup: skip if lead already has an active heartbeat-checklist task
   const existing = getDb()
-    .prepare<{ id: string }, [string, string]>(
+    .prepare<{ id: string }, [string]>(
       `SELECT id FROM agent_tasks
        WHERE agentId = ?
-         AND taskType = 'heartbeat'
+         AND taskType = 'heartbeat-checklist'
          AND status NOT IN ('completed', 'failed', 'cancelled')
-         AND task LIKE ?
        LIMIT 1`,
     )
-    .get(leadAgentId, `%${HEARTBEAT_ESCALATION_MARKER} ${escalationKey}%`);
+    .get(lead.id);
+  if (existing) return;
+
+  const systemStatus = gatherSystemStatus();
 
-  return Boolean(existing);
+  const result = resolveTemplate("heartbeat.checklist", {
+    system_status: systemStatus,
+    heartbeat_content: heartbeatMd,
+  });
+
+  if (result.skipped) return;
+
+  createTaskExtended(result.text, {
+    agentId: lead.id,
+    taskType: "heartbeat-checklist",
+    tags: ["checklist", "auto-generated"],
+    priority: 60,
+  });
+
+  console.log(`[Heartbeat] Checklist task created for lead ${lead.name}`);
 }
 
 // ============================================================================
@@ -409,7 +450,7 @@ function hasActiveEscalationTask(leadAgentId: string, escalationKey: string): bo
 // ============================================================================
 
 /**
- * Run a single heartbeat sweep (Tier 1 → Tier 2 → Tier 3).
+ * Run a single heartbeat sweep (Tier 1 → Tier 2).
  */
 export async function runHeartbeatSweep(): Promise<void> {
   if (isSweeping) {
@@ -432,7 +473,6 @@ export async function runHeartbeatSweep(): Promise<void> {
           inboxProcessing: 0,
           workflowRuns: 0,
         },
-        escalationNeeded: false,
       };
       await cleanupStaleResources(cleanupOnlyFindings);
       logFindings(cleanupOnlyFindings);
@@ -444,11 +484,6 @@ export async function runHeartbeatSweep(): Promise<void> {
 
     // Log findings summary
     logFindings(findings);
-
-    // Tier 3: Escalate if needed
-    if (findings.escalationNeeded) {
-      escalateToLead(findings);
-    }
   } finally {
     isSweeping = false;
   }
@@ -508,6 +543,9 @@ export function startHeartbeat(intervalMs = DEFAULT_INTERVAL_MS): void {
   heartbeatInterval = setInterval(() => {
     runHeartbeatSweep();
   }, intervalMs);
+
+  // Also start the checklist interval
+  startHeartbeatChecklist();
 }
 
 /**
@@ -520,11 +558,82 @@ export function stopHeartbeat(): void {
     isSweeping = false;
     console.log("[Heartbeat] Stopped");
   }
+  stopHeartbeatChecklist();
+}
+
+/**
+ * Create a one-off boot triage task for the lead after a server restart.
+ * Uses the same HEARTBEAT.md content but with reboot-specific context prepended.
+ */
+export async function createBootTriageTask(): Promise<void> {
+  const lead = getLeadAgent();
+  if (!lead) return;
+
+  const heartbeatMd = lead.heartbeatMd ?? "";
+
+  // Dedup: skip if lead already has an active boot-triage task
+  const existing = getDb()
+    .prepare<{ id: string }, [string]>(
+      `SELECT id FROM agent_tasks
+       WHERE agentId = ?
+         AND taskType = 'boot-triage'
+         AND status NOT IN ('completed', 'failed', 'cancelled')
+       LIMIT 1`,
+    )
+    .get(lead.id);
+  if (existing) return;
+
+  const systemStatus = gatherSystemStatus();
+
+  const result = resolveTemplate("heartbeat.boot-triage", {
+    system_status: systemStatus,
+    heartbeat_content: isEffectivelyEmpty(heartbeatMd)
+      ? "_No standing orders configured._"
+      : heartbeatMd,
+  });
+
+  if (result.skipped) return;
+
+  createTaskExtended(result.text, {
+    agentId: lead.id,
+    taskType: "boot-triage",
+    tags: ["boot", "triage", "auto-generated"],
+    priority: 70, // Higher than regular checklist (60)
+  });
+
+  console.log(`[Heartbeat] Boot triage task created for lead ${lead.name}`);
+}
+
+/**
+ * Start the heartbeat checklist polling loop (separate from the infrastructure sweep).
+ */
+export function startHeartbeatChecklist(intervalMs = HEARTBEAT_CHECKLIST_INTERVAL_MS): void {
+  if (HEARTBEAT_CHECKLIST_DISABLE) {
+    console.log("[Heartbeat] Checklist disabled via HEARTBEAT_CHECKLIST_DISABLE");
+    return;
+  }
+  if (checklistInterval) {
+    return; // Already running
+  }
+
+  console.log(`[Heartbeat] Checklist starting with ${intervalMs}ms interval`);
+
+  // Boot triage replaces the first checklist (30s delay to let system settle)
+  setTimeout(() => createBootTriageTask(), 30_000);
+
+  // Recurring checklist starts from the second interval onward
+  checklistInterval = setInterval(() => {
+    checkHeartbeatChecklist();
+  }, intervalMs);
 }
 
 /**
- * Reset escalation cooldown state. Exported for testing only.
+ * Stop the heartbeat checklist polling loop.
  */
-export function resetEscalationCooldowns(): void {
-  lastEscalationTime.clear();
+export function stopHeartbeatChecklist(): void {
+  if (checklistInterval) {
+    clearInterval(checklistInterval);
+    checklistInterval = null;
+    console.log("[Heartbeat] Checklist stopped");
+  }
 }

package/src/heartbeat/templates.ts

@@ -8,23 +8,78 @@
 import { registerTemplate } from "../prompts/registry";
 
 // ============================================================================
-// Escalation events
+// Heartbeat checklist
 // ============================================================================
 
 registerTemplate({
-  eventType: "heartbeat.escalation.stalled",
+  eventType: "heartbeat.checklist",
   header: "",
-  defaultBody: `Task Type: Triage
-Goal: Investigate heartbeat findings that need human reasoning
+  defaultBody: `Task Type: Heartbeat Checklist
+Goal: Review system status and your standing orders, take action if needed.
 
-{{stalled_tasks_section}}
-{{escalation_marker}}`,
+## Current System Status [auto-generated]
+{{system_status}}
+
+## Your Standing Orders (from HEARTBEAT.md)
+{{heartbeat_content}}
+
+## Instructions
+1. Review the system status above for anything that needs attention (stalled tasks, idle workers with available work, anomalies).
+2. Review your standing orders for any periodic checks or actions.
+3. If something needs attention — take action now using your available tools (create tasks, post to Slack, cancel stuck tasks, etc.).
+4. If everything looks healthy and no standing orders are actionable — complete this task with a brief "All clear" summary.
+5. Do NOT create another heartbeat-checklist task — the system handles scheduling.`,
+  variables: [
+    {
+      name: "system_status",
+      description: "Auto-generated markdown section with current system status",
+    },
+    {
+      name: "heartbeat_content",
+      description: "The lead agent's HEARTBEAT.md standing orders",
+    },
+  ],
+  category: "event",
+});
+
+// ============================================================================
+// Boot triage (one-off after container restart)
+// ============================================================================
+
+registerTemplate({
+  eventType: "heartbeat.boot-triage",
+  header: "",
+  defaultBody: `Task Type: Boot Triage
+Goal: The system just restarted — assess current state and triage based on your role.
+
+## Boot Event [auto-generated]
+The API server has just restarted (possible pod rotation or deployment). This is a one-off triage task — not a recurring checklist. Review the current state, identify anything that needs immediate attention, and take action.
+
+## Current System Status [auto-generated]
+{{system_status}}
+
+## Your Standing Orders (from HEARTBEAT.md)
+{{heartbeat_content}}
+
+## Instructions
+1. **Acknowledge the reboot** — note that the system just restarted and any in-flight work may have been interrupted.
+2. Review the system status above. Pay special attention to:
+   - Tasks that were in-progress before the restart (they may have been auto-failed by the startup sweep)
+   - Workers that may need to re-register
+   - Any stalled or orphaned work
+3. Review your standing orders for any checks that are relevant post-reboot.
+4. Take action using your available tools (re-create failed tasks, notify affected parties, etc.).
+5. Complete this task with a summary of what you found and what actions you took.
+6. Do NOT create another boot-triage task — this is a one-off event.`,
   variables: [
     {
-      name: "stalled_tasks_section",
-      description: "Markdown section listing stalled tasks with details",
+      name: "system_status",
+      description: "Auto-generated markdown section with current system status",
+    },
+    {
+      name: "heartbeat_content",
+      description: "The lead agent's HEARTBEAT.md standing orders",
     },
-    { name: "escalation_marker", description: "Heartbeat escalation marker with key" },
   ],
   category: "event",
 });