sentinelayer-cli 0.1.0

package/src/agents/jules/loop.js

@@ -0,0 +1,367 @@
+import { randomUUID } from "node:crypto";
+import { createMultiProviderApiClient } from "../../ai/client.js";
+import { evaluateBudget } from "../../cost/budget.js";
+import { dispatchTool, createAgentContext, BudgetExhaustedError } from "./tools/dispatch.js";
+import { JULES_DEFINITION } from "./config/definition.js";
+import { shouldSpawnSubAgents, runJulesSwarm } from "./swarm/orchestrator.js";
+import { frontendAnalyze } from "./tools/frontend-analyze.js";
+
+/**
+ * Jules Tanaka — Agentic Loop
+ *
+ * Core state machine: LLM → tool_use → execute → result → LLM → repeat
+ * With sub-agent swarm integration for large codebases.
+ *
+ * This loop is self-contained: it uses the existing ai/client.js for LLM calls,
+ * the existing cost/budget.js for budget enforcement, and the Jules tool
+ * dispatch for tool execution. No dependency on Batches O-Q.
+ */
+
+const DEFAULT_MAX_TURNS = 25;
+const HEARTBEAT_INTERVAL_TURNS = 5;
+
+/**
+ * Run Jules' agentic audit loop.
+ *
+ * @param {object} config
+ * @param {string} config.systemPrompt - Jules' full system prompt
+ * @param {object} config.scopeMap - { primary, secondary, tertiary } file lists
+ * @param {string} config.rootPath - Codebase root
+ * @param {object} [config.omarBaseline] - Deterministic baseline findings (if available)
+ * @param {object} [config.blackboard] - Shared blackboard for cross-agent findings
+ * @param {object} [config.memory] - Memory index for cross-run recall
+ * @param {object} [config.budget] - Budget overrides
+ * @param {object} [config.provider] - LLM provider overrides
+ * @param {string} [config.mode] - "primary" | "secondary" | "tertiary"
+ * @param {number} [config.maxTurns] - Max loop iterations
+ * @param {AbortController} [config.abortController]
+ * @param {function} [config.onEvent] - Streaming event callback
+ * @returns {AsyncGenerator<JulesEvent>} Yields events as they occur
+ */
+export async function* julesAuditLoop(config) {
+  const {
+    systemPrompt,
+    scopeMap,
+    rootPath,
+    omarBaseline,
+    blackboard,
+    memory,
+    provider,
+    mode = "primary",
+    maxTurns = DEFAULT_MAX_TURNS,
+    abortController,
+    onEvent,
+  } = config;
+
+  const budget = { ...JULES_DEFINITION.budget, ...config.budget };
+  const runId = `jules-${Date.now()}-${randomUUID().slice(0, 8)}`;
+  const startedAt = Date.now();
+  const client = createMultiProviderApiClient(provider || {});
+
+  const ctx = createAgentContext({
+    agentIdentity: { id: JULES_DEFINITION.id, persona: JULES_DEFINITION.persona },
+    budget,
+    runId,
+    onEvent,
+  });
+
+  const emit = (event, payload) => {
+    const evt = {
+      stream: "sl_event",
+      event,
+      agent: { id: JULES_DEFINITION.id, persona: JULES_DEFINITION.persona, color: JULES_DEFINITION.color, avatar: JULES_DEFINITION.avatar },
+      payload,
+      usage: {
+        costUsd: ctx.usage.costUsd,
+        outputTokens: ctx.usage.outputTokens,
+        toolCalls: ctx.usage.toolCalls,
+        durationMs: Date.now() - startedAt,
+      },
+    };
+    if (onEvent) onEvent(evt);
+    return evt;
+  };
+
+  yield emit("agent_start", { mode, runId, maxTurns, budget });
+
+  // ── Phase 0: Prerequisites ────────────────────────────────────────
+
+  yield emit("progress", { phase: "prerequisites", message: "Detecting framework..." });
+
+  let framework = {};
+  try {
+    framework = frontendAnalyze({ operation: "detect_framework", path: rootPath });
+    ctx.usage.toolCalls++;
+    yield emit("tool_result", { tool: "FrontendAnalyze", operation: "detect_framework", result: { framework: framework.framework, componentCount: framework.componentCount } });
+  } catch { /* proceed without */ }
+
+  // ── Phase 1: Swarm or direct? ─────────────────────────────────────
+
+  const spawnDecision = shouldSpawnSubAgents(scopeMap);
+  let swarmFindings = [];
+
+  if (spawnDecision.spawn && blackboard) {
+    yield emit("progress", { phase: "swarm", message: `Large frontend (${spawnDecision.reason}). Spawning sub-agents...` });
+
+    const swarmResult = await runJulesSwarm({
+      scopeMap,
+      rootPath,
+      blackboard,
+      budget: { ...budget, maxCostUsd: budget.maxCostUsd * 0.6 }, // 60% for swarm
+      provider,
+      parentAbort: abortController,
+      onEvent,
+    });
+
+    swarmFindings = swarmResult.agentResults.flatMap(r => r.findings);
+    ctx.usage.costUsd += swarmResult.usage.totalCostUsd;
+    ctx.usage.toolCalls += swarmResult.usage.totalToolCalls;
+
+    yield emit("swarm_complete", {
+      totalFindings: swarmFindings.length,
+      totalAgents: swarmResult.usage.totalAgents,
+      totalCostUsd: swarmResult.usage.totalCostUsd,
+    });
+  }
+
+  // ── Phase 2: Jules primary deep analysis (agentic LLM loop) ──────
+
+  yield emit("progress", { phase: "deep_analysis", message: "Starting deep analysis..." });
+
+  // Build context for LLM
+  const contextParts = [];
+  contextParts.push(`Framework: ${framework.framework || "unknown"}`);
+  contextParts.push(`Mode: ${mode}`);
+  contextParts.push(`Components: ${framework.componentCount || "unknown"}`);
+  contextParts.push(`Scope: ${(scopeMap.primary || []).length} primary files`);
+
+  if (swarmFindings.length > 0) {
+    contextParts.push(`\nSub-agent findings (${swarmFindings.length} total):`);
+    for (const f of swarmFindings.slice(0, 30)) {
+      contextParts.push(`- [${f.severity || "P3"}] ${f.file || ""}:${f.line || ""} ${f.title || f.type || ""}`);
+    }
+  }
+
+  if (omarBaseline) {
+    const baselineFindings = omarBaseline.findings || omarBaseline.summary || [];
+    if (Array.isArray(baselineFindings) && baselineFindings.length > 0) {
+      contextParts.push(`\nOmar baseline findings (${baselineFindings.length}):`);
+      for (const f of baselineFindings.slice(0, 20)) {
+        contextParts.push(`- [${f.severity || ""}] ${f.file || ""}:${f.line || ""} ${f.message || f.title || ""}`);
+      }
+    }
+  }
+
+  if (memory) {
+    try {
+      const recalled = memory.query ? memory.query({
+        files: (scopeMap.primary || []).map(f => f.path || f),
+        limit: 10,
+      }) : [];
+      if (recalled.length > 0) {
+        contextParts.push(`\nPrevious findings recalled from memory (${recalled.length}):`);
+        for (const r of recalled) {
+          contextParts.push(`- ${r.content || r.text || JSON.stringify(r).slice(0, 100)}`);
+        }
+      }
+    } catch { /* memory recall failure is non-blocking */ }
+  }
+
+  const messages = [
+    { role: "user", content: contextParts.join("\n") +
+      "\n\nPerform your deep analysis now. Use FileRead, Grep, Glob, and FrontendAnalyze tools as needed. " +
+      "Return your findings in a ```json code block as an array of { severity, file, line, title, evidence, rootCause, recommendedFix, trafficLight }." },
+  ];
+
+  const allFindings = [...swarmFindings];
+  let turnCount = 0;
+
+  while (turnCount < maxTurns) {
+    if (abortController?.signal.aborted) {
+      yield emit("agent_abort", { reason: "user_cancelled" });
+      break;
+    }
+
+    // Budget check before LLM call
+    const preCheck = evaluateBudget({
+      sessionSummary: {
+        costUsd: ctx.usage.costUsd,
+        outputTokens: ctx.usage.outputTokens,
+        durationMs: Date.now() - startedAt,
+        toolCalls: ctx.usage.toolCalls,
+      },
+      ...budget,
+    });
+
+    if (preCheck.blocking) {
+      yield emit("budget_stop", { reasons: preCheck.reasons });
+      break;
+    }
+
+    if (preCheck.warnings.length > 0) {
+      yield emit("budget_warning", { warnings: preCheck.warnings });
+    }
+
+    turnCount++;
+
+    // Heartbeat
+    if (turnCount % HEARTBEAT_INTERVAL_TURNS === 0) {
+      yield emit("heartbeat", {
+        turnsCompleted: turnCount,
+        turnsMax: maxTurns,
+        findingsSoFar: allFindings.length,
+        budgetRemaining: {
+          costUsd: Math.max(0, budget.maxCostUsd - ctx.usage.costUsd),
+          pct: Math.max(0, 100 - (ctx.usage.costUsd / budget.maxCostUsd * 100)),
+        },
+      });
+    }
+
+    // Call LLM
+    let response;
+    try {
+      response = await client.invoke({
+        systemPrompt,
+        messages,
+      });
+    } catch (err) {
+      yield emit("llm_error", { error: err.message, turn: turnCount });
+      break;
+    }
+
+    const responseText = response.text || "";
+    ctx.usage.outputTokens += Math.ceil(responseText.length / 4);
+    ctx.usage.costUsd += (Math.ceil(responseText.length / 4) / 1_000_000) * 15;
+
+    yield emit("reasoning", {
+      phase: "deep_analysis",
+      turn: turnCount,
+      summary: responseText.slice(0, 200),
+    });
+
+    // Parse tool_use blocks
+    const toolCalls = parseToolUseBlocks(responseText);
+
+    if (toolCalls.length === 0) {
+      // No tools — extract findings from response
+      const parsed = extractJsonFindings(responseText);
+      for (const finding of parsed) {
+        allFindings.push(finding);
+        yield emit("finding", { ...finding });
+        if (blackboard) {
+          try {
+            await blackboard.appendEntry({
+              agentId: JULES_DEFINITION.id,
+              source: "jules-primary",
+              ...finding,
+            });
+          } catch { /* blackboard write failure non-blocking */ }
+        }
+      }
+      messages.push({ role: "assistant", content: responseText });
+      break; // LLM is done
+    }
+
+    // Execute tool calls
+    const results = [];
+    for (const call of toolCalls) {
+      try {
+        const result = await dispatchTool(call.tool, call.input, ctx);
+        results.push({ tool: call.tool, result });
+        yield emit("tool_call", { tool: call.tool, input: sanitizeForEvent(call.input) });
+      } catch (err) {
+        if (err instanceof BudgetExhaustedError) {
+          yield emit("budget_stop", { reason: err.message });
+          break;
+        }
+        results.push({ tool: call.tool, error: err.message });
+      }
+    }
+
+    // Feed results back
+    messages.push({ role: "assistant", content: responseText });
+    messages.push({
+      role: "user",
+      content: results.map(r =>
+        r.error
+          ? `Tool ${r.tool} failed: ${r.error}`
+          : `Tool ${r.tool} result:\n${JSON.stringify(r.result).slice(0, 3000)}`,
+      ).join("\n\n") + "\n\nContinue your analysis. If done, return findings in a ```json code block.",
+    });
+  }
+
+  // ── Phase 3: Build final report ───────────────────────────────────
+
+  const durationMs = Date.now() - startedAt;
+  const severityCounts = { P0: 0, P1: 0, P2: 0, P3: 0 };
+  for (const f of allFindings) {
+    const sev = (f.severity || "P3").toUpperCase();
+    if (severityCounts[sev] !== undefined) severityCounts[sev]++;
+    else severityCounts.P3++;
+  }
+
+  const report = {
+    runId,
+    persona: JULES_DEFINITION.persona,
+    mode,
+    framework: framework.framework || "unknown",
+    status: "completed",
+    findings: allFindings,
+    summary: {
+      total: allFindings.length,
+      ...severityCounts,
+      blocking: severityCounts.P0 > 0 || severityCounts.P1 > 0,
+    },
+    usage: {
+      turns: turnCount,
+      costUsd: ctx.usage.costUsd,
+      outputTokens: ctx.usage.outputTokens,
+      toolCalls: ctx.usage.toolCalls,
+      durationMs,
+    },
+    signature: JULES_DEFINITION.signature,
+  };
+
+  yield emit("agent_complete", {
+    ...report.summary,
+    costUsd: ctx.usage.costUsd,
+    durationMs,
+    turns: turnCount,
+  });
+
+  return report;
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function parseToolUseBlocks(text) {
+  const calls = [];
+  const regex = /```tool_use\s*\n([\s\S]*?)```/g;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    try {
+      const parsed = JSON.parse(match[1].trim());
+      if (parsed.tool && parsed.input) calls.push(parsed);
+    } catch { /* skip malformed */ }
+  }
+  return calls;
+}
+
+function extractJsonFindings(text) {
+  const jsonMatch = text.match(/```json\s*\n([\s\S]*?)```/);
+  if (!jsonMatch) return [];
+  try {
+    const parsed = JSON.parse(jsonMatch[1].trim());
+    if (Array.isArray(parsed)) return parsed;
+    if (parsed.findings && Array.isArray(parsed.findings)) return parsed.findings;
+  } catch { /* skip malformed */ }
+  return [];
+}
+
+function sanitizeForEvent(input) {
+  const sanitized = { ...input };
+  if (typeof sanitized.content === "string" && sanitized.content.length > 200) {
+    sanitized.content = `[${sanitized.content.length} chars]`;
+  }
+  return sanitized;
+}

package/src/agents/jules/pulse.js

@@ -0,0 +1,319 @@
+import { PERSONA_VISUALS } from "./config/definition.js";
+
+/**
+ * Pulse — SentinelLayer Internal Daemon Monitor
+ *
+ * Monitors running agent health, routes errors to the right persona,
+ * detects stuck/idle agents, and sends alerts on state changes.
+ * NOT called Kairos — Pulse monitors the heartbeat of all agents.
+ */
+
+// ── Stuck Detection ──────────────────────────────────────────────────
+
+const STUCK_THRESHOLDS = Object.freeze({
+  noToolCallSeconds: 90,
+  noProgressTurns: 5,
+  sameFileReadCount: 3,
+  budgetConsumedNoOutput: 0.5,
+  maxIdleBeforeEscalate: 300,
+  maxIdleBeforeKill: 600,
+});
+
+/**
+ * Detect if an agent is stuck based on its current state.
+ *
+ * @param {object} agentState
+ * @param {number} agentState.lastToolCallAt - Epoch ms
+ * @param {number} agentState.lastTurnProgressAt - Epoch ms
+ * @param {number} agentState.sameFileReadCount - Consecutive reads of same file
+ * @param {string} [agentState.lastFileRead] - Path of last file read
+ * @param {number} agentState.budgetConsumedPct - 0-100
+ * @param {number} agentState.findingCount
+ * @param {number} [agentState.turnsSinceLastProgress]
+ * @returns {{ stuck: boolean, reason?: string, idleSeconds?: number, file?: string, budgetPct?: number }}
+ */
+export function detectStuckState(agentState) {
+  const now = Date.now();
+
+  // No tool calls for threshold period
+  if (agentState.lastToolCallAt) {
+    const idleMs = now - agentState.lastToolCallAt;
+    if (idleMs > STUCK_THRESHOLDS.noToolCallSeconds * 1000) {
+      return { stuck: true, reason: "no_tool_calls", idleSeconds: Math.floor(idleMs / 1000) };
+    }
+  }
+
+  // Same file read repeatedly (loop detection)
+  if (agentState.sameFileReadCount >= STUCK_THRESHOLDS.sameFileReadCount) {
+    return { stuck: true, reason: "loop_detected", file: agentState.lastFileRead };
+  }
+
+  // High budget consumption with no findings
+  if (
+    agentState.budgetConsumedPct > STUCK_THRESHOLDS.budgetConsumedNoOutput * 100 &&
+    agentState.findingCount === 0
+  ) {
+    return { stuck: true, reason: "inefficient", budgetPct: agentState.budgetConsumedPct };
+  }
+
+  // No turn progress
+  if (agentState.turnsSinceLastProgress >= STUCK_THRESHOLDS.noProgressTurns) {
+    return { stuck: true, reason: "no_progress", turns: agentState.turnsSinceLastProgress };
+  }
+
+  return { stuck: false };
+}
+
+/**
+ * Determine recovery action based on idle duration.
+ *
+ * @param {number} idleSeconds
+ * @returns {"hint" | "escalate" | "kill"}
+ */
+export function determineRecoveryAction(idleSeconds) {
+  if (idleSeconds >= STUCK_THRESHOLDS.maxIdleBeforeKill) return "kill";
+  if (idleSeconds >= STUCK_THRESHOLDS.maxIdleBeforeEscalate) return "escalate";
+  return "hint";
+}
+
+// ── Error-to-Persona Routing ─────────────────────────────────────────
+
+const ROUTING_RULES = [
+  // Stack trace patterns (most reliable)
+  { test: (w) => /\.(tsx|jsx|vue|svelte):\d+/.test(w.stackTrace || ""), persona: "frontend" },
+  { test: (w) => /React|Next|Vite|Webpack|hydrat/i.test(w.stackTrace || ""), persona: "frontend" },
+  { test: (w) => /\.py:\d+/.test(w.stackTrace || ""), persona: "backend" },
+  { test: (w) => /\.go:\d+/.test(w.stackTrace || ""), persona: "backend" },
+
+  // Endpoint patterns
+  { test: (w) => /\.(html|css|js|png|svg|woff)$/.test(w.endpoint || ""), persona: "frontend" },
+  { test: (w) => /\/api\/v\d+\/auth/.test(w.endpoint || ""), persona: "security" },
+  { test: (w) => /\/api\//.test(w.endpoint || ""), persona: "backend" },
+
+  // Error code patterns
+  { test: (w) => /HYDRATION|RENDER|DOM|CSR|SSR/i.test(w.errorCode || ""), persona: "frontend" },
+  { test: (w) => /AUTH|TOKEN|SESSION|PERMISSION/i.test(w.errorCode || ""), persona: "security" },
+  { test: (w) => /TIMEOUT|ECONNREFUSED|DNS|SOCKET/i.test(w.errorCode || ""), persona: "infrastructure" },
+  { test: (w) => /QUERY|MIGRATION|CONSTRAINT|DEADLOCK/i.test(w.errorCode || ""), persona: "data" },
+];
+
+/**
+ * Route an error work item to the appropriate persona.
+ *
+ * @param {object} workItem - Error queue item
+ * @returns {string} Persona ID (e.g., "frontend", "backend", "security")
+ */
+export function routeErrorToPersona(workItem) {
+  for (const rule of ROUTING_RULES) {
+    if (rule.test(workItem)) return rule.persona;
+  }
+  return "backend"; // default fallback
+}
+
+// ── Alert Building ───────────────────────────────────────────────────
+
+/**
+ * Build a concise alert payload for Slack/Telegram.
+ *
+ * @param {object} config
+ * @param {string} config.agentId - Persona ID
+ * @param {string} config.event - Alert event type
+ * @param {object} config.state - Agent state snapshot
+ * @param {string} [config.workItemId]
+ * @param {string} [config.jiraIssueKey]
+ * @returns {{ headline, body, severity }}
+ */
+export function buildAlertPayload({ agentId, event, state, workItemId, jiraIssueKey }) {
+  const visual = PERSONA_VISUALS[agentId] || { avatar: "", fullName: agentId, color: "white" };
+  const avatar = visual.avatar;
+  const name = visual.fullName;
+
+  const lines = [];
+  lines.push(`${avatar} ${name} \u2014 ${formatAlertEvent(event)}`);
+  lines.push("\u2501".repeat(30));
+
+  if (workItemId) lines.push(`Work Item: ${workItemId}`);
+  if (jiraIssueKey) lines.push(`Jira: ${jiraIssueKey}`);
+
+  if (state) {
+    if (state.durationMs) lines.push(`Duration: ${formatDuration(state.durationMs)}`);
+    if (state.budgetPct !== undefined) lines.push(`Budget: ${state.budgetPct.toFixed(0)}%`);
+    if (state.turnsCompleted !== undefined) lines.push(`Turns: ${state.turnsCompleted}/${state.turnsMax || "?"}`);
+    if (state.findingCount !== undefined) lines.push(`Findings: ${state.findingCount}`);
+    if (state.lastAction) lines.push(`Last: ${state.lastAction}`);
+    if (state.costUsd !== undefined) lines.push(`Cost: $${state.costUsd.toFixed(2)}`);
+    if (state.prNumber) lines.push(`PR: #${state.prNumber}`);
+  }
+
+  const severity = event.includes("stuck") || event.includes("kill") ? "warning" :
+    event.includes("merged") || event.includes("complete") ? "success" : "info";
+
+  lines.push("");
+  lines.push(`\u2014 ${name}, SentinelLayer`);
+
+  return {
+    headline: `${avatar} ${name}: ${formatAlertEvent(event)}`,
+    body: lines.join("\n"),
+    severity,
+  };
+}
+
+function formatAlertEvent(event) {
+  const map = {
+    agent_stuck: "Agent Stuck",
+    agent_recovered: "Agent Recovered",
+    budget_warning: "Budget Warning",
+    budget_exhausted: "Budget Exhausted",
+    pr_merged: "PR Merged",
+    audit_complete: "Audit Complete",
+    fix_complete: "Fix Complete",
+    kill_switch: "Kill Switch Activated",
+    error_intake: "Error Received",
+    jira_resolved: "Jira Resolved",
+  };
+  return map[event] || event;
+}
+
+function formatDuration(ms) {
+  if (ms < 60000) return `${(ms / 1000).toFixed(0)}s`;
+  if (ms < 3600000) return `${(ms / 60000).toFixed(1)}m`;
+  return `${(ms / 3600000).toFixed(1)}h`;
+}
+
+// ── Health Summary ───────────────────────────────────────────────────
+
+/**
+ * Build a periodic health summary for Slack/Telegram.
+ *
+ * @param {object[]} agentStates - Current states of all running agents
+ * @returns {{ headline, body } | null} null if nothing to report
+ */
+export function buildHealthSummary(agentStates) {
+  if (!agentStates || agentStates.length === 0) return null;
+
+  const active = agentStates.filter(a => a.status === "active");
+  const stuck = agentStates.filter(a => a.stuck);
+  const completed = agentStates.filter(a => a.status === "completed");
+
+  if (active.length === 0 && stuck.length === 0 && completed.length === 0) return null;
+
+  const lines = [];
+  lines.push("\u{1F4CA} Pulse Health Summary");
+  lines.push("\u2501".repeat(30));
+  lines.push(`Active: ${active.length} | Stuck: ${stuck.length} | Completed: ${completed.length}`);
+
+  for (const a of active.slice(0, 5)) {
+    const visual = PERSONA_VISUALS[a.agentId] || {};
+    lines.push(`  ${visual.avatar || ""} ${visual.shortName || a.agentId}: ${a.findingCount || 0} findings, $${(a.costUsd || 0).toFixed(2)}`);
+  }
+
+  if (stuck.length > 0) {
+    lines.push("");
+    lines.push("\u26A0\uFE0F Stuck agents:");
+    for (const s of stuck) {
+      const visual = PERSONA_VISUALS[s.agentId] || {};
+      lines.push(`  ${visual.avatar || ""} ${visual.shortName || s.agentId}: ${s.reason || "unknown"} (${s.idleSeconds || 0}s idle)`);
+    }
+  }
+
+  return {
+    headline: `Pulse: ${active.length} active, ${stuck.length} stuck, ${completed.length} done`,
+    body: lines.join("\n"),
+  };
+}
+
+// ── Webhook Delivery ─────────────────────────────────────────────────
+
+/**
+ * Send an alert to configured Slack/Telegram webhooks.
+ * Reads config from env or .sentinelayer.yml.
+ * Fails silently — alert delivery must never block agent work.
+ *
+ * @param {object} alert - { headline, body, severity } from buildAlertPayload
+ * @param {object} [channels] - Override channel config
+ * @returns {Promise<{ sent: object[], errors: object[] }>}
+ */
+export async function sendAlert(alert, channels) {
+  const resolved = channels || resolveAlertChannels();
+  const sent = [];
+  const errors = [];
+
+  for (const channel of resolved) {
+    try {
+      if (channel.type === "slack" && channel.webhook_url) {
+        await sendSlackWebhook(channel.webhook_url, alert);
+        sent.push({ type: "slack", status: "sent" });
+      } else if (channel.type === "telegram" && channel.bot_token && channel.chat_id) {
+        await sendTelegramMessage(channel.bot_token, channel.chat_id, alert);
+        sent.push({ type: "telegram", status: "sent" });
+      }
+    } catch (err) {
+      errors.push({ type: channel.type, error: err.message });
+    }
+  }
+
+  return { sent, errors };
+}
+
+async function sendSlackWebhook(webhookUrl, alert) {
+  const payload = JSON.stringify({
+    text: alert.headline,
+    blocks: [
+      { type: "header", text: { type: "plain_text", text: alert.headline } },
+      { type: "section", text: { type: "mrkdwn", text: alert.body } },
+    ],
+  });
+
+  const response = await fetch(webhookUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: payload,
+    signal: AbortSignal.timeout(10000),
+  });
+
+  if (!response.ok) {
+    throw new Error("Slack webhook failed: " + response.status);
+  }
+}
+
+async function sendTelegramMessage(botToken, chatId, alert) {
+  const url = "https://api.telegram.org/bot" + botToken + "/sendMessage";
+  const payload = JSON.stringify({
+    chat_id: chatId,
+    text: alert.body,
+    parse_mode: "Markdown",
+    disable_web_page_preview: true,
+  });
+
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: payload,
+    signal: AbortSignal.timeout(10000),
+  });
+
+  if (!response.ok) {
+    throw new Error("Telegram send failed: " + response.status);
+  }
+}
+
+function resolveAlertChannels() {
+  const channels = [];
+
+  // Slack from env
+  const slackUrl = process.env.SENTINELAYER_SLACK_WEBHOOK_URL;
+  if (slackUrl) {
+    channels.push({ type: "slack", webhook_url: slackUrl });
+  }
+
+  // Telegram from env
+  const tgToken = process.env.SENTINELAYER_TELEGRAM_BOT_TOKEN;
+  const tgChat = process.env.SENTINELAYER_TELEGRAM_CHAT_ID;
+  if (tgToken && tgChat) {
+    channels.push({ type: "telegram", bot_token: tgToken, chat_id: tgChat });
+  }
+
+  return channels;
+}
+
+export { STUCK_THRESHOLDS };