@cohortapp/agent-sdk 2.3.0

package/scripts/poller/trigger.mjs

@@ -0,0 +1,75 @@
+// Priority Trigger — writes a priority task file when urgent items detected
+import { writeFileSync, mkdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { AGENT_REPO_DIR } from "./utils.mjs";
+
+const COOLDOWN_MS = 30_000;
+let lastTrigger = 0;
+
+// Cached agent identity — used to label the "mentions agent" reason
+// without hardcoding any one agent's name in the reason string.
+let _agent = null;
+function loadAgent() {
+  if (_agent) return _agent;
+  try {
+    _agent = JSON.parse(readFileSync(join(AGENT_REPO_DIR, "config/agent.json"), "utf-8"));
+  } catch {
+    _agent = { firstName: "Agent" };
+  }
+  return _agent;
+}
+
+// Back-compat export: callers used to invoke `triggerSophie`. The function
+// is fully agent-neutral now; both names map to the same implementation.
+export function triggerAgent(item) {
+  const now = Date.now();
+  if (now - lastTrigger < COOLDOWN_MS) {
+    console.log(
+      `[trigger] Cooldown active, skipping trigger for: ${item.subject}`,
+    );
+    return false;
+  }
+  lastTrigger = now;
+
+  const reasons = [];
+  if (item.priority_signals?.from_ceo) reasons.push("Message from CEO");
+  if (item.priority_signals?.tagged_urgent) reasons.push("Tagged urgent");
+  if (item.priority_signals?.mentions_agent) reasons.push(`Mentions ${loadAgent().firstName}`);
+  const reason = reasons.join(", ") || "Priority item";
+
+  console.log(`[trigger] Priority event detected: ${reason}`);
+
+  try {
+    const dir = join(AGENT_REPO_DIR, "state", "inbox", "internal");
+    mkdirSync(dir, { recursive: true });
+    const taskFile = join(dir, `priority-${Date.now()}.yaml`);
+    let content = `type: priority_trigger
+reason: "${reason}"
+source_item: "${item.raw_ref}"
+timestamp: "${new Date().toISOString()}"
+sender: "${item.sender}"
+channel: "${item.channel}"
+content: |
+  ${(item.content || "").replace(/\n/g, "\n  ")}
+`;
+    // Include attachment metadata so downstream sessions can view files
+    if (item.attachments && item.attachments.length > 0) {
+      content += `attachments:\n`;
+      for (const att of item.attachments) {
+        content += `  - name: "${att.name || "unnamed"}"\n`;
+        content += `    mimetype: "${att.mimetype || "unknown"}"\n`;
+        content += `    size: ${att.size || 0}\n`;
+        if (att.local_path) content += `    local_path: "${att.local_path}"\n`;
+        if (att.url_private) content += `    url_private: "${att.url_private}"\n`;
+      }
+    }
+    writeFileSync(taskFile, content);
+    console.log(`[trigger] Priority task written to ${taskFile}`);
+    return true;
+  } catch (err) {
+    console.error(`[trigger] Failed to trigger: ${err.message}`);
+    return false;
+  }
+}
+
+export const triggerSophie = triggerAgent;

package/scripts/poller/utils.mjs

@@ -0,0 +1,371 @@
+import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, readdirSync, renameSync } from "fs";
+import { join, dirname, extname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export const AGENT_REPO_DIR = process.env.AGENT_DIR || join(__dirname, "../..");
+
+// Re-export under legacy name for any external script still importing
+// SOPHIE_AI_DIR from this module. New code should use AGENT_REPO_DIR.
+export const SOPHIE_AI_DIR = AGENT_REPO_DIR;
+export const ATTACHMENTS_DIR = join(AGENT_REPO_DIR, "state", "inbox", "attachments");
+
+export function writeInboxItem(service, item, agentRoot = AGENT_REPO_DIR) {
+  const dir = join(agentRoot, "state", "inbox", service);
+  mkdirSync(dir, { recursive: true });
+  const ts = item.timestamp.replace(/[:.]/g, "-");
+  const filename = `${ts}-${item.id}.yaml`;
+  const filePath = join(dir, filename);
+
+  // Skip if this item was already written or already processed/deferred/in-flight.
+  // The daemon renames files to .processed after handling, to .deferred
+  // when parked behind an active channel lock, to .processed-bundled
+  // when older entries are folded into a newer message during promotion,
+  // and to .dispatched while a session is in-flight (durable admission, F1).
+  // Without all of these checks the 30-min thread lookback re-creates the
+  // file every poll cycle, causing duplicate responses, surprise re-promotion
+  // of work that was already bundled, or double-delivery of an in-flight item.
+  if (
+    existsSync(filePath) ||
+    existsSync(filePath + ".processed") ||
+    existsSync(filePath + ".deferred") ||
+    existsSync(filePath + ".processed-bundled") ||
+    existsSync(filePath + ".dispatched")
+  ) {
+    return;
+  }
+
+  writeFileSync(filePath, inboxItemToYaml(item));
+}
+
+// ── Durable inbox admission (F1 / H2) ────────────────────────────────────────
+//
+// The crash window: the daemon used to rename an inbox item straight to
+// `.processed` the instant `dispatch()` returned — but `dispatch()` may only
+// have parked the item in an in-memory queue (governor/budget/rate gate, or all
+// slots full). A crash/restart then loses the in-memory queue while the durable
+// file already reads `.processed` and `writeInboxItem` dedupe blocks re-creation
+// — the user's message is silently dropped.
+//
+// Fix: a `.dispatched` intermediate state. `markDispatched` parks an *admitted*
+// item as `.dispatched` (durable, but NOT terminal); `markInboxProcessed`
+// retires it to `.processed` only on session close (success). The scanner skips
+// fresh `.dispatched` files (no double-delivery on the happy path) but RECLAIMS
+// stale ones (older than the reclaim window) so a crash mid-flight re-delivers.
+//
+// File-matching mirrors the daemon's markProcessed/markDeferred (id or raw_ref
+// substring) so we hit the same file those would have. All paths are idempotent.
+
+/**
+ * Rename a live inbox file to `<name>.dispatched` at admission time. Durable
+ * but re-deliverable: a crash before session close leaves a `.dispatched` file
+ * the scanner can reclaim. No-op (returns 0) when there is no matching live
+ * file (e.g. backlog items, or already dispatched/processed).
+ *
+ * @returns {number} number of files renamed (usually 1, 0 for non-inbox items)
+ */
+export function markDispatched(item, service, agentRoot = AGENT_REPO_DIR) {
+  return renameLiveInbox(item, service, agentRoot, ".dispatched");
+}
+
+/**
+ * Retire an inbox item to `<name>.processed` on session close (success).
+ * Matches both the live `.yaml` (item never reached dispatch — e.g. ignored or
+ * quick-reply) and an in-flight `.dispatched` sibling. Terminal: the scanner
+ * never re-emits a `.processed` file.
+ *
+ * @returns {number} number of files renamed
+ */
+export function markInboxProcessed(item, service, agentRoot = AGENT_REPO_DIR) {
+  if (!item || !service || !agentRoot) return 0;
+  const inboxDir = join(agentRoot, "state", "inbox", service);
+  if (!existsSync(inboxDir)) return 0;
+  const needles = [item.id, item.raw_ref].filter(Boolean);
+  if (needles.length === 0) return 0;
+  let renamed = 0;
+  try {
+    const files = readdirSync(inboxDir).filter(
+      (f) =>
+        !f.endsWith(".processed") &&
+        !f.endsWith(".processed-bundled") &&
+        (f.endsWith(".yaml") || f.endsWith(".dispatched")) &&
+        needles.some((n) => f.includes(n))
+    );
+    for (const file of files) {
+      // Strip the live/.dispatched suffix, then append .processed so the result
+      // is always `<base>.yaml.processed` — the terminal name the scanner skips.
+      const base = file.replace(/\.dispatched$/, "");
+      renameSync(join(inboxDir, file), join(inboxDir, base + ".processed"));
+      renamed++;
+    }
+  } catch {
+    // Inbox dir may not exist for non-poller-backed items (e.g. backlog).
+  }
+  return renamed;
+}
+
+/** Shared helper: rename matching live `.yaml` inbox files to `<name><suffix>`. */
+function renameLiveInbox(item, service, agentRoot, suffix) {
+  if (!item || !service || !agentRoot) return 0;
+  const inboxDir = join(agentRoot, "state", "inbox", service);
+  if (!existsSync(inboxDir)) return 0;
+  const needles = [item.id, item.raw_ref].filter(Boolean);
+  if (needles.length === 0) return 0;
+  let renamed = 0;
+  try {
+    const files = readdirSync(inboxDir).filter(
+      (f) => f.endsWith(".yaml") && needles.some((n) => f.includes(n))
+    );
+    for (const file of files) {
+      renameSync(join(inboxDir, file), join(inboxDir, file + suffix));
+      renamed++;
+    }
+  } catch {
+    // Inbox dir may not exist for non-poller-backed items.
+  }
+  return renamed;
+}
+
+function inboxItemToYaml(item) {
+  const content = (item.content || "").replace(/\n/g, "\n  ");
+  let yaml = `id: "${item.id}"
+service: "${item.service}"
+channel: "${item.channel}"
+sender: "${item.sender}"
+sender_privilege: "${item.sender_privilege}"
+timestamp: "${item.timestamp}"
+subject: "${item.subject || ""}"
+content: |
+  ${content}
+thread_id: "${item.thread_id || ""}"
+is_reply: ${item.is_reply || false}
+is_voice_transcript: ${item.is_voice_transcript || false}
+priority_signals:
+  from_ceo: ${item.priority_signals?.from_ceo || false}
+  tagged_urgent: ${item.priority_signals?.tagged_urgent || false}
+  contains_deadline: ${item.priority_signals?.contains_deadline || false}
+  mentions_agent: ${item.priority_signals?.mentions_agent || false}
+raw_ref: "${item.raw_ref || ""}"
+`;
+
+  // Add thread context if present (conversation history before this message)
+  if (item.thread_context) {
+    const tc = item.thread_context.replace(/\n/g, "\n  ");
+    yaml += `thread_context: |\n  ${tc}\n`;
+  }
+
+  // Add channel_id if present
+  if (item.channel_id) {
+    yaml += `channel_id: "${item.channel_id}"\n`;
+  }
+
+  // Add event_type if present (e.g., message_changed, reaction)
+  if (item.event_type) {
+    yaml += `event_type: "${item.event_type}"\n`;
+  }
+
+  // Add attachments if present
+  if (item.attachments && item.attachments.length > 0) {
+    yaml += `attachments:\n`;
+    for (const att of item.attachments) {
+      yaml += `  - id: "${att.id}"\n`;
+      yaml += `    name: "${att.name}"\n`;
+      yaml += `    mimetype: "${att.mimetype}"\n`;
+      yaml += `    size: ${att.size}\n`;
+      if (att.local_path) {
+        yaml += `    local_path: "${att.local_path}"\n`;
+      }
+      if (att.url_private) {
+        yaml += `    url_private: "${att.url_private}"\n`;
+      }
+    }
+  }
+
+  // Add voice metadata if present
+  if (item.is_voice_transcript && item.voice_meta) {
+    yaml += `voice_meta:
+  caller_phone: "${item.voice_meta.caller_phone || ""}"
+  duration_seconds: ${item.voice_meta.duration_seconds || 0}
+  turns: ${item.voice_meta.turns || 0}
+  topics: [${(item.voice_meta.topics || []).map((t) => `"${t}"`).join(", ")}]
+  action_priority: "${item.voice_meta.action_priority || ""}"
+`;
+  }
+
+  return yaml;
+}
+
+// ── Attachment Handling ──────────────────────────────────────────────────────
+
+/**
+ * Download a Slack file attachment to local storage.
+ * Slack file URLs require the bot token for authentication.
+ * Returns the local file path on success, null on failure.
+ */
+export async function downloadSlackAttachment(file, token) {
+  if (!file || !token) return null;
+
+  const downloadUrl = file.url_private_download || file.url_private;
+  if (!downloadUrl) return null;
+
+  const ext = extname(file.name || "") || "";
+  const safeId = (file.id || "unknown").replace(/[^a-zA-Z0-9_-]/g, "");
+  const safeName = (file.name || "file").replace(/[^a-zA-Z0-9._-]/g, "_");
+  const localName = `${safeId}-${safeName}`;
+  const localPath = join(ATTACHMENTS_DIR, localName);
+
+  // Skip if already downloaded
+  if (existsSync(localPath)) return localPath;
+
+  try {
+    mkdirSync(ATTACHMENTS_DIR, { recursive: true });
+    const res = await fetch(downloadUrl, {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok) {
+      console.error(`[attachment] Failed to download ${file.name}: HTTP ${res.status}`);
+      return null;
+    }
+    const buffer = Buffer.from(await res.arrayBuffer());
+    writeFileSync(localPath, buffer);
+    return localPath;
+  } catch (err) {
+    console.error(`[attachment] Download error for ${file.name}: ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * Extract attachment metadata from a Slack message's files array.
+ * Returns a structured array suitable for inbox YAML serialization.
+ */
+export function extractSlackAttachments(files) {
+  if (!files || !Array.isArray(files) || files.length === 0) return [];
+  return files.map((f) => ({
+    id: f.id || "",
+    name: f.name || "unnamed",
+    mimetype: f.mimetype || f.filetype || "unknown",
+    size: f.size || 0,
+    url_private: f.url_private || "",
+    url_private_download: f.url_private_download || "",
+    local_path: null, // Populated after download
+  }));
+}
+
+// ── Slack Reactions ─────────────────────────────────────────────────────────
+
+/**
+ * Add an emoji reaction to a Slack message.
+ * Used by the agent to acknowledge, approve, or signal status on messages.
+ *
+ * @param {string} channel - Slack channel ID
+ * @param {string} timestamp - Message timestamp (ts)
+ * @param {string} emoji - Emoji name without colons (e.g., "eyes", "white_check_mark")
+ * @param {string} token - Slack bot token
+ * @returns {Promise<{ok: boolean, error?: string}>}
+ */
+export async function addSlackReaction(channel, timestamp, emoji, token) {
+  if (!token || !channel || !timestamp || !emoji) {
+    return { ok: false, error: "missing_parameters" };
+  }
+
+  try {
+    const res = await fetch("https://slack.com/api/reactions.add", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        channel,
+        timestamp,
+        name: emoji,
+      }),
+    });
+    return await res.json();
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+export function readCursor(service) {
+  const path = join(
+    AGENT_REPO_DIR,
+    "state",
+    "polling",
+    `${service}-cursor.yaml`,
+  );
+  try {
+    const content = readFileSync(path, "utf-8");
+    const match = content.match(/last_checked:\s*"?([^"\n]*)"?/);
+    const val = match ? match[1] : null;
+    return val === "null" ? null : val;
+  } catch {
+    return null;
+  }
+}
+
+export function writeCursor(service, timestamp) {
+  const path = join(
+    AGENT_REPO_DIR,
+    "state",
+    "polling",
+    `${service}-cursor.yaml`,
+  );
+  const content = `service: ${service}
+last_checked: "${timestamp}"
+cursors: {}
+stats:
+  total_polls_today: 0
+  items_found_today: 0
+  errors_today: 0
+`;
+  writeFileSync(path, content);
+}
+
+export function appendLog(service, entry) {
+  const dir = join(AGENT_REPO_DIR, "logs", "polling");
+  mkdirSync(dir, { recursive: true });
+  const today = new Date().toISOString().split("T")[0];
+  const path = join(dir, `${today}-${service}.jsonl`);
+  appendFileSync(path, JSON.stringify(entry) + "\n");
+}
+
+export function isPriorityItem(item) {
+  if (!item) return false;
+  return (
+    item.priority_signals?.from_ceo ||
+    item.priority_signals?.tagged_urgent ||
+    item.priority_signals?.mentions_agent
+  );
+}
+
+// Known user IDs for privilege resolution — derived from config/agent.json so
+// the agent's own Slack ID gets "system" privilege and the principal's gets "ceo".
+const KNOWN_USERS = (() => {
+  const map = {};
+  try {
+    const a = JSON.parse(readFileSync(join(AGENT_REPO_DIR, "config/agent.json"), "utf-8"));
+    if (a.principal?.slackMemberId) {
+      map[a.principal.slackMemberId] = {
+        name: (a.principal.fullName || "").toLowerCase().replace(/\s+/g, "-"),
+        privilege: "ceo",
+      };
+    }
+    if (a.slackMemberId) {
+      map[a.slackMemberId] = {
+        name: (a.fullName || "").toLowerCase().replace(/\s+/g, "-"),
+        privilege: "system",
+      };
+    }
+  } catch { /* no agent.json yet — empty registry */ }
+  return map;
+})();
+
+export function resolvePrivilege(userId) {
+  return KNOWN_USERS[userId]?.privilege || "unknown";
+}
+
+export function resolveName(userId) {
+  return KNOWN_USERS[userId]?.name || userId;
+}

package/scripts/poller/voice-cloud-relay-client.mjs

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+/**
+ * voice-cloud-relay-client.mjs — Polls the Railway-hosted voice relay for
+ * buffered `realtime.call.incoming` events from OpenAI, then forwards
+ * each event to the local voice-webhook-server's /voice/sip/incoming
+ * endpoint so all the existing context-loader / tool-bridge / brief
+ * machinery runs unchanged.
+ *
+ * Lifecycle:
+ *   1. Honour .emergency-stop before any I/O.
+ *   2. Loop forever:
+ *        a. GET <VOICE_RELAY_URL>/openai/realtime/calls with bearer auth
+ *        b. For each event in the response, POST it to the local
+ *           voice-webhook-server with a fabricated openai-signature
+ *           header so the local handler trusts it (we compute the
+ *           HMAC locally using OPENAI_WEBHOOK_SECRET).
+ *        c. Sleep VOICE_RELAY_POLL_INTERVAL_MS (default 2500).
+ *
+ * Env (from .env):
+ *   VOICE_RELAY_URL              — https://<your-railway-domain>
+ *   VOICE_RELAY_POLL_TOKEN       — bearer for the relay's poll endpoint
+ *   OPENAI_WEBHOOK_SECRET        — to re-sign forwarded events for the
+ *                                  local webhook server
+ *   VOICE_WEBHOOK_PORT           — local server port (default 3200)
+ *   VOICE_RELAY_POLL_INTERVAL_MS — poll cadence (default 2500)
+ *
+ * If VOICE_RELAY_URL isn't set, this exits cleanly so installations not
+ * using Railway aren't affected.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHmac } from "node:crypto";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AGENT_DIR = process.env.AGENT_DIR || process.env.AGENT_ROOT || resolve(__dirname, "../..");
+
+if (existsSync(join(AGENT_DIR, ".emergency-stop"))) {
+  console.error("[voice-relay-poller] .emergency-stop present — refusing to start");
+  await new Promise((r) => setTimeout(r, 30_000));
+  process.exit(0);
+}
+
+function loadDotEnv(p) {
+  if (!existsSync(p)) return;
+  for (const ln of readFileSync(p, "utf-8").split("\n")) {
+    const t = ln.trim();
+    if (!t || t.startsWith("#")) continue;
+    const eq = t.indexOf("=");
+    if (eq <= 0) continue;
+    const k = t.slice(0, eq).trim();
+    let v = t.slice(eq + 1).trim();
+    if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) v = v.slice(1, -1);
+    if (!process.env[k]) process.env[k] = v;
+  }
+}
+loadDotEnv(join(AGENT_DIR, ".env"));
+
+const RELAY_URL = (process.env.VOICE_RELAY_URL || "").replace(/\/$/, "");
+const POLL_TOKEN = process.env.VOICE_RELAY_POLL_TOKEN || "";
+const OPENAI_WEBHOOK_SECRET = process.env.OPENAI_WEBHOOK_SECRET || "";
+const LOCAL_WEBHOOK_PORT = parseInt(process.env.VOICE_WEBHOOK_PORT || "3200", 10);
+const POLL_INTERVAL_MS = parseInt(process.env.VOICE_RELAY_POLL_INTERVAL_MS || "750", 10);
+const LOCAL_WEBHOOK_URL = `http://127.0.0.1:${LOCAL_WEBHOOK_PORT}/voice/sip/incoming`;
+
+if (!RELAY_URL) {
+  console.log("[voice-relay-poller] VOICE_RELAY_URL not set — exiting (Railway relay not in use)");
+  process.exit(0);
+}
+if (!POLL_TOKEN) {
+  console.error("[voice-relay-poller] VOICE_RELAY_POLL_TOKEN not set — refusing to poll an unauthenticated relay");
+  process.exit(78);
+}
+if (!OPENAI_WEBHOOK_SECRET) {
+  console.warn("[voice-relay-poller] OPENAI_WEBHOOK_SECRET not set — local webhook server may reject forwarded events");
+}
+
+try {
+  const { acquireLock } = await import("../../lib/singleton.js");
+  if (!acquireLock("voice-relay-poller")) {
+    console.log("[voice-relay-poller] already running — exiting");
+    process.exit(0);
+  }
+} catch { /* singleton unavailable; continue without lock */ }
+
+console.log(`[voice-relay-poller] start: relay=${RELAY_URL} interval=${POLL_INTERVAL_MS}ms local=${LOCAL_WEBHOOK_URL}`);
+
+let consecutiveErrors = 0;
+const MAX_BACKOFF_MS = 60_000;
+
+async function pollOnce() {
+  let resp;
+  try {
+    resp = await fetch(`${RELAY_URL}/openai/realtime/calls`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${POLL_TOKEN}` },
+    });
+  } catch (err) {
+    consecutiveErrors++;
+    console.warn(`[voice-relay-poller] poll fetch failed (${consecutiveErrors}): ${err.message}`);
+    return;
+  }
+  if (!resp.ok) {
+    consecutiveErrors++;
+    const body = await resp.text().catch(() => "");
+    console.warn(`[voice-relay-poller] poll HTTP ${resp.status}: ${body.slice(0, 200)}`);
+    return;
+  }
+  consecutiveErrors = 0;
+  let data;
+  try { data = await resp.json(); }
+  catch (err) { console.warn(`[voice-relay-poller] poll bad json: ${err.message}`); return; }
+
+  if (!data.events || data.events.length === 0) return;
+  console.log(`[voice-relay-poller] received ${data.events.length} buffered event(s)`);
+
+  for (const evt of data.events) {
+    await forwardToLocal(evt);
+  }
+}
+
+async function forwardToLocal(evt) {
+  // Prefer evt.raw_body (the exact bytes OpenAI sent + signed) so HMAC
+  // verification on the local side matches. If absent (older relay
+  // version), fall back to re-stringifying — but warn the operator.
+  const payloadStr = typeof evt.raw_body === "string" && evt.raw_body.length
+    ? evt.raw_body
+    : JSON.stringify(evt.payload || {});
+  if (!evt.raw_body) {
+    console.warn(`[voice-relay-poller] no raw_body in event — re-stringified payload may HMAC-mismatch local server`);
+  }
+  const headers = { "Content-Type": "application/json" };
+  if (OPENAI_WEBHOOK_SECRET) {
+    headers["openai-signature"] = createHmac("sha256", OPENAI_WEBHOOK_SECRET)
+      .update(payloadStr)
+      .digest("hex");
+  }
+  // If Railway already POSTed /accept on receipt (because it's the only path
+  // with low enough latency to beat OpenAI's accept window), tell the local
+  // handler to skip its own accept attempt — the call_id is already taken.
+  if (evt.accepted_by_relay) {
+    headers["x-maestro-relay-accepted"] = "1";
+  }
+  try {
+    const r = await fetch(LOCAL_WEBHOOK_URL, {
+      method: "POST",
+      headers,
+      body: payloadStr,
+    });
+    const body = await r.text().catch(() => "");
+    if (r.ok) {
+      console.log(`[voice-relay-poller] forwarded ${evt.event_type} call=${evt.call_id} → local OK`);
+    } else {
+      console.warn(`[voice-relay-poller] local webhook HTTP ${r.status}: ${body.slice(0, 200)}`);
+    }
+  } catch (err) {
+    console.warn(`[voice-relay-poller] forward failed: ${err.message}`);
+  }
+}
+
+async function loop() {
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  while (true) {
+    await pollOnce();
+    const backoff = consecutiveErrors > 0
+      ? Math.min(MAX_BACKOFF_MS, POLL_INTERVAL_MS * Math.pow(2, consecutiveErrors))
+      : POLL_INTERVAL_MS;
+    await sleep(backoff);
+  }
+}
+
+process.on("SIGTERM", () => { console.log("[voice-relay-poller] SIGTERM"); process.exit(0); });
+process.on("SIGINT", () => { console.log("[voice-relay-poller] SIGINT"); process.exit(0); });
+
+loop().catch((err) => {
+  console.error(`[voice-relay-poller] fatal: ${err.message}`);
+  process.exit(1);
+});