getpatter 0.6.0 → 0.6.2

package/dist/{chunk-X3364LSI.mjs → chunk-R2T4JABZ.mjs}

@@ -174,6 +174,11 @@ var OnnxModel = class {
     const data = out.data;
     return data[0] ?? 0;
   }
+  /** Reset the RNN hidden state + rolling context to a fresh inference. */
+  reset() {
+    this.context = new Float32Array(this.contextSize);
+    this.rnnState = new Float32Array(2 * 1 * 128);
+  }
 };
 var SileroVAD = class _SileroVAD {
   constructor(model, opts) {
@@ -213,7 +218,11 @@ var SileroVAD = class _SileroVAD {
     const model = new OnnxModel(runtime, session, sampleRate);
     return new _SileroVAD(model, {
       minSpeechDuration: options.minSpeechDuration ?? 0.25,
-      minSilenceDuration: options.minSilenceDuration ?? 0.1,
+      // Bumped 0.1 -> 0.4s after round 10f confirmed VAD speech_end fired on
+      // natural inter-sentence pauses < 250ms, causing double-talk dispatch.
+      // 400ms is the industry default for telephony and matches the new
+      // inter_utterance_gap_ms debounce in stream-handler.ts.
+      minSilenceDuration: options.minSilenceDuration ?? 0.4,
       prefixPaddingDuration: options.prefixPaddingDuration ?? 0.03,
       activationThreshold,
       deactivationThreshold,
@@ -233,7 +242,10 @@ var SileroVAD = class _SileroVAD {
    *   - `activationThreshold = 0.5` — upstream `threshold`
    *   - `deactivationThreshold = 0.35` — upstream `neg_threshold = threshold - 0.15`
    *   - `minSpeechDuration = 0.25` — upstream `min_speech_duration_ms = 250`
-   *   - `minSilenceDuration = 0.1` — upstream `min_silence_duration_ms = 100`
+   *   - `minSilenceDuration = 0.4` — telephony default (was 0.1, bumped after
+   *     round 10f found speech_end firing on inter-sentence pauses < 250 ms,
+   *     causing double-talk dispatch). 400 ms matches the industry telephony
+   *     default and the inter_utterance_gap_ms debounce in stream-handler.ts.
    *   - `prefixPaddingDuration = 0.03` — upstream `speech_pad_ms = 30`
    *
    * Override any field by passing `options`. Deployments that experience
@@ -250,6 +262,19 @@ var SileroVAD = class _SileroVAD {
   static forPhoneCall(options = {}) {
     return _SileroVAD.load({
       sampleRate: 16e3,
+      // Telephony bumps the activation threshold from the upstream
+      // 0.5 → 0.8 (with deactivation 0.65) so background voices and
+      // low-volume audio in the caller's room don't trip barge-in.
+      // Near-mic speech typically scores 0.85-0.98 on Silero — above
+      // 0.8 — while a distant second speaker through a phone's noise-
+      // suppression pipeline lands around 0.4-0.6 and is now correctly
+      // ignored. Bumped twice during 2026-05-20 acceptance: first 0.5
+      // → 0.7 (still triggered on quiet voices), then 0.7 → 0.8.
+      // Trade-off: a whispered legitimate input may not trigger;
+      // typical phone-call speakers are unaffected. Pass an explicit
+      // ``activationThreshold`` to override per call site.
+      activationThreshold: 0.8,
+      deactivationThreshold: 0.65,
       ...options
     });
   }
@@ -356,6 +381,28 @@ var SileroVAD = class _SileroVAD {
     if (this.closed) return;
     this.closed = true;
   }
+  /**
+   * Reset all per-utterance state so the next ``processFrame`` starts from
+   * a clean SILENCE state.
+   *
+   * Called by the stream handler between agent turns to prevent a "stuck
+   * SPEECH" condition where PSTN echo / loopback kept the detector's
+   * probability above ``deactivationThreshold`` for the entire agent turn.
+   * Without this reset the next user utterance would never trigger a
+   * SILENCE→SPEECH transition and barge-in would feel "one-shot" (works
+   * once, then never again until the call ends).
+   *
+   * Safe to call any time including on a closed instance (no-op).
+   */
+  reset() {
+    if (this.closed) return;
+    this.pending = new Float32Array(0);
+    this.pubSpeaking = false;
+    this.speechThresholdDuration = 0;
+    this.silenceThresholdDuration = 0;
+    this.expFilter.reset();
+    this.model.reset();
+  }
 };
 
 export {

package/dist/cli.js

@@ -29,8 +29,8 @@ var import_express = __toESM(require("express"));
 
 // src/dashboard/store.ts
 var import_events = require("events");
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
 
 // src/logger.ts
 var defaultLogger = {
@@ -45,11 +45,41 @@ function getLogger() {
   return currentLogger;
 }
 
+// src/version.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+function readVersion() {
+  try {
+    const pkgPath = path.resolve(__dirname, "..", "package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    return typeof pkg.version === "string" && pkg.version.length > 0 ? pkg.version : "";
+  } catch {
+    return "";
+  }
+}
+var VERSION = readVersion();
+
 // src/dashboard/store.ts
+function sdkVersion() {
+  return VERSION;
+}
 var MetricsStore = class extends import_events.EventEmitter {
   maxCalls;
   calls = [];
   activeCalls = /* @__PURE__ */ new Map();
+  /**
+   * User-driven soft delete: call_ids the operator removed from the
+   * dashboard view. The on-disk artefacts written by ``CallLogger``
+   * (``metadata.json``, ``transcript.jsonl``) are intentionally NOT
+   * touched — they serve as the durable backup. All read paths
+   * (``getCalls`` / ``getCall`` / ``getAggregates`` / ``getCallsInRange``
+   * / ``hydrate``) filter against this set so the call is invisible
+   * to the UI and excluded from rolling metrics. Populated from
+   * ``<logRoot>/.deleted_call_ids.json`` on hydrate so deletions
+   * survive a process restart. Parity with Python.
+   */
+  deletedCallIds = /* @__PURE__ */ new Set();
+  deletedIdsPath = null;
   /**
    * Accepts either a numeric ``maxCalls`` (legacy positional — matches the
    * original TS API) or an options object ``{ maxCalls }`` to align with the
@@ -142,6 +172,8 @@ var MetricsStore = class extends import_events.EventEmitter {
           ended_at: Date.now() / 1e3,
           status,
           metrics: null,
+          ...active.turns && active.turns.length > 0 ? { turns: active.turns } : {},
+          ...active.transcript && active.transcript.length > 0 ? { transcript: active.transcript } : {},
           ...extra
         };
         this.activeCalls.delete(callId);
@@ -170,6 +202,21 @@ var MetricsStore = class extends import_events.EventEmitter {
     if (active) {
       if (!active.turns) active.turns = [];
       active.turns.push(turn);
+      if (!active.transcript) active.transcript = [];
+      const turnRecord = turn;
+      const userText = typeof turnRecord.user_text === "string" ? turnRecord.user_text : "";
+      const agentText = typeof turnRecord.agent_text === "string" ? turnRecord.agent_text : "";
+      const ts = typeof turnRecord.timestamp === "number" ? turnRecord.timestamp : Date.now() / 1e3;
+      if (userText.length > 0) {
+        active.transcript.push({ role: "user", text: userText, timestamp: ts });
+      }
+      if (agentText.length > 0 && agentText !== "[interrupted]") {
+        active.transcript.push({
+          role: "assistant",
+          text: agentText,
+          timestamp: ts
+        });
+      }
     }
     this.publish("turn_complete", { call_id: callId, turn });
   }
@@ -179,40 +226,140 @@ var MetricsStore = class extends import_events.EventEmitter {
     if (!callId) return;
     const active = this.activeCalls.get(callId);
     this.activeCalls.delete(callId);
-    const activeStatus = active?.status;
-    const resolvedStatus = activeStatus && activeStatus !== "in-progress" ? activeStatus : "completed";
+    let existingIdx = -1;
+    if (active === void 0) {
+      for (let i = this.calls.length - 1; i >= 0; i--) {
+        if (this.calls[i].call_id === callId) {
+          existingIdx = i;
+          break;
+        }
+      }
+    }
+    const existing = existingIdx >= 0 ? this.calls[existingIdx] : void 0;
+    const priorStatus = active?.status ?? existing?.status;
+    const resolvedStatus = priorStatus && priorStatus !== "in-progress" ? priorStatus : "completed";
+    const dataTranscript = data.transcript;
+    const resolvedTranscript = dataTranscript && dataTranscript.length > 0 ? dataTranscript : active?.transcript && active.transcript.length > 0 ? active.transcript : existing?.transcript && existing.transcript.length > 0 ? existing.transcript : [];
+    const resolvedTurns = active?.turns && active.turns.length > 0 ? active.turns : existing?.turns && existing.turns.length > 0 ? existing.turns : void 0;
     const entry = {
       call_id: callId,
-      caller: data.caller || active?.caller || "",
-      callee: data.callee || active?.callee || "",
-      direction: active?.direction || data.direction || "inbound",
-      started_at: active?.started_at || 0,
+      caller: data.caller || active?.caller || existing?.caller || "",
+      callee: data.callee || active?.callee || existing?.callee || "",
+      direction: active?.direction || existing?.direction || data.direction || "inbound",
+      started_at: active?.started_at || existing?.started_at || 0,
       ended_at: Date.now() / 1e3,
-      transcript: data.transcript || [],
+      transcript: resolvedTranscript,
+      ...resolvedTurns ? { turns: resolvedTurns } : {},
       status: resolvedStatus,
-      metrics: metrics ?? null
+      metrics: metrics ?? existing?.metrics ?? null
     };
-    this.calls.push(entry);
-    if (this.calls.length > this.maxCalls) {
-      this.calls = this.calls.slice(-this.maxCalls);
+    if (existingIdx >= 0) {
+      this.calls[existingIdx] = entry;
+    } else {
+      this.calls.push(entry);
+      if (this.calls.length > this.maxCalls) {
+        this.calls = this.calls.slice(-this.maxCalls);
+      }
     }
     this.publish("call_end", {
       call_id: callId,
       metrics: entry.metrics ?? null
     });
   }
-  /** Return a window of completed calls in newest-first order. */
+  /**
+   * Return a window of completed calls in newest-first order.
+   *
+   * Soft-deleted call_ids (see ``deleteCalls``) are filtered out so the
+   * dashboard never re-shows a row the user removed. The on-disk
+   * artefacts are intentionally preserved as a backup.
+   */
   getCalls(limit = 50, offset = 0) {
-    const ordered = [...this.calls].reverse();
+    const visible = this.calls.filter((c) => !this.deletedCallIds.has(c.call_id));
+    const ordered = visible.reverse();
     return ordered.slice(offset, offset + limit);
   }
-  /** Look up a completed call by id (newest match wins). */
+  /**
+   * Look up a completed call by id (newest match wins).
+   *
+   * Soft-deleted call_ids resolve to ``null`` so the SPA's detail pane
+   * cannot render a row the user removed.
+   */
   getCall(callId) {
+    if (this.deletedCallIds.has(callId)) return null;
     for (let i = this.calls.length - 1; i >= 0; i--) {
       if (this.calls[i].call_id === callId) return this.calls[i];
     }
     return null;
   }
+  /**
+   * Soft-delete one or more calls from the dashboard view.
+   *
+   * Adds each ``call_id`` to an in-memory set. Subsequent reads via
+   * ``getCalls`` / ``getCall`` / ``getAggregates`` / ``getCallsInRange``
+   * exclude the deleted ids, so rolling metrics (avg latency, total
+   * spend) are recomputed without them. The on-disk
+   * ``metadata.json`` / ``transcript.jsonl`` files written by
+   * ``CallLogger`` are NOT touched — they serve as a durable backup
+   * the operator can audit outside the dashboard.
+   *
+   * Active calls are never deletable. A call_id that is currently
+   * in ``activeCalls`` is silently skipped so a mid-call delete
+   * from the UI cannot orphan the live transcript pane.
+   *
+   * Persisted to ``<logRoot>/.deleted_call_ids.json`` (best-effort)
+   * when ``hydrate()`` has been called with a log root. Parity with
+   * Python ``delete_calls``.
+   *
+   * @returns The list of call_ids actually accepted as deleted.
+   */
+  deleteCalls(callIds) {
+    const ids = /* @__PURE__ */ new Set();
+    for (const cid of callIds || []) {
+      if (typeof cid === "string" && cid && !this.activeCalls.has(cid)) {
+        ids.add(cid);
+      }
+    }
+    if (ids.size === 0) return [];
+    const accepted = [];
+    for (const cid of ids) {
+      if (!this.deletedCallIds.has(cid)) {
+        this.deletedCallIds.add(cid);
+        accepted.push(cid);
+      }
+    }
+    if (accepted.length === 0) return [];
+    accepted.sort();
+    this.persistDeletedIds();
+    this.publish("calls_deleted", { call_ids: accepted });
+    return accepted;
+  }
+  /** Whether ``callId`` was soft-deleted from the dashboard. */
+  isDeleted(callId) {
+    return this.deletedCallIds.has(callId);
+  }
+  /** Snapshot of soft-deleted call_ids (sorted). */
+  getDeletedCallIds() {
+    return Array.from(this.deletedCallIds).sort();
+  }
+  /** Atomically persist the deleted-ids set to disk. Best-effort. */
+  persistDeletedIds() {
+    if (this.deletedIdsPath === null) return;
+    try {
+      const dir = path2.dirname(this.deletedIdsPath);
+      fs2.mkdirSync(dir, { recursive: true });
+      const tmp = this.deletedIdsPath + ".tmp";
+      const payload = {
+        version: 1,
+        deleted_call_ids: Array.from(this.deletedCallIds).sort()
+      };
+      fs2.writeFileSync(tmp, JSON.stringify(payload, null, 2), "utf8");
+      fs2.renameSync(tmp, this.deletedIdsPath);
+    } catch (err) {
+      getLogger().debug(
+        `MetricsStore.persistDeletedIds: ${String(err)}`
+      );
+    }
+  }
   /** Look up an active call by id (returns undefined if not active or unknown). */
   getActive(callId) {
     return this.activeCalls.get(callId);
@@ -221,9 +368,17 @@ var MetricsStore = class extends import_events.EventEmitter {
   getActiveCalls() {
     return Array.from(this.activeCalls.values());
   }
-  /** Compute summary statistics across the buffered call history. */
+  /**
+   * Compute summary statistics across the buffered call history.
+   *
+   * Soft-deleted calls are excluded so rolling metrics (avg latency,
+   * total spend) match exactly what the operator sees in the call list.
+   */
   getAggregates() {
-    const totalCalls = this.calls.length;
+    const visible = this.calls.filter(
+      (c) => !this.deletedCallIds.has(c.call_id)
+    );
+    const totalCalls = visible.length;
     if (totalCalls === 0) {
       return {
         total_calls: 0,
@@ -231,7 +386,8 @@ var MetricsStore = class extends import_events.EventEmitter {
         avg_duration: 0,
         avg_latency_ms: 0,
         cost_breakdown: { stt: 0, tts: 0, llm: 0, telephony: 0 },
-        active_calls: this.activeCalls.size
+        active_calls: this.activeCalls.size,
+        sdk_version: sdkVersion()
       };
     }
     let totalCost = 0;
@@ -242,7 +398,7 @@ var MetricsStore = class extends import_events.EventEmitter {
     let costTts = 0;
     let costLlm = 0;
     let costTel = 0;
-    for (const call of this.calls) {
+    for (const call of visible) {
       const m = call.metrics;
       if (!m) continue;
       const cost = m.cost || {};
@@ -253,7 +409,7 @@ var MetricsStore = class extends import_events.EventEmitter {
       costTel += cost.telephony || 0;
       totalDuration += m.duration_seconds || 0;
       const avgLat = m.latency_avg || {};
-      const tMs = avgLat.total_ms || 0;
+      const tMs = avgLat.agent_response_ms || avgLat.total_ms || 0;
       if (tMs > 0) {
         totalLatency += tMs;
         latencyCount++;
@@ -270,21 +426,30 @@ var MetricsStore = class extends import_events.EventEmitter {
         llm: Math.round(costLlm * 1e6) / 1e6,
         telephony: Math.round(costTel * 1e6) / 1e6
       },
-      active_calls: this.activeCalls.size
+      active_calls: this.activeCalls.size,
+      sdk_version: sdkVersion()
     };
   }
-  /** Return calls whose `started_at` falls within `[fromTs, toTs]` (Unix seconds). */
+  /**
+   * Return calls whose `started_at` falls within `[fromTs, toTs]` (Unix
+   * seconds). Soft-deleted calls are filtered out.
+   */
   getCallsInRange(fromTs = 0, toTs = 0) {
     return this.calls.filter((call) => {
+      if (this.deletedCallIds.has(call.call_id)) return false;
       const started = call.started_at || 0;
       if (fromTs && started < fromTs) return false;
       if (toTs && started > toTs) return false;
       return true;
     });
   }
-  /** Number of completed calls currently in the ring buffer. */
+  /** Number of completed (non-deleted) calls currently in the ring buffer. */
   get callCount() {
-    return this.calls.length;
+    let n = 0;
+    for (const c of this.calls) {
+      if (!this.deletedCallIds.has(c.call_id)) n++;
+    }
+    return n;
   }
   /**
    * Rebuild the in-memory call list from `metadata.json` files written by
@@ -298,19 +463,37 @@ var MetricsStore = class extends import_events.EventEmitter {
    */
   hydrate(logRoot) {
     if (!logRoot) return 0;
-    const callsRoot = path.join(logRoot, "calls");
-    if (!fs.existsSync(callsRoot)) return 0;
+    const deletedIdsPath = path2.join(logRoot, ".deleted_call_ids.json");
+    this.deletedIdsPath = deletedIdsPath;
+    if (fs2.existsSync(deletedIdsPath)) {
+      try {
+        const raw = fs2.readFileSync(deletedIdsPath, "utf8");
+        const payload = JSON.parse(raw);
+        const arr = Array.isArray(payload.deleted_call_ids) ? payload.deleted_call_ids : [];
+        for (const cid of arr) {
+          if (typeof cid === "string" && cid.length > 0) {
+            this.deletedCallIds.add(cid);
+          }
+        }
+      } catch (err) {
+        getLogger().debug(
+          `MetricsStore.hydrate: skipping ${deletedIdsPath}: ${String(err)}`
+        );
+      }
+    }
+    const callsRoot = path2.join(logRoot, "calls");
+    if (!fs2.existsSync(callsRoot)) return 0;
     const collected = [];
     const seen = new Set(this.calls.map((c) => c.call_id));
     const walk = (dir, depth) => {
       let entries;
       try {
-        entries = fs.readdirSync(dir, { withFileTypes: true });
+        entries = fs2.readdirSync(dir, { withFileTypes: true });
       } catch {
         return;
       }
       for (const entry of entries) {
-        const childPath = path.join(dir, entry.name);
+        const childPath = path2.join(dir, entry.name);
         if (depth < 3) {
           if (entry.isDirectory() && /^\d+$/.test(entry.name)) {
             walk(childPath, depth + 1);
@@ -318,10 +501,10 @@ var MetricsStore = class extends import_events.EventEmitter {
           continue;
         }
         if (!entry.isDirectory()) continue;
-        const metadataPath = path.join(childPath, "metadata.json");
-        if (!fs.existsSync(metadataPath)) continue;
+        const metadataPath = path2.join(childPath, "metadata.json");
+        if (!fs2.existsSync(metadataPath)) continue;
         try {
-          const raw = fs.readFileSync(metadataPath, "utf8");
+          const raw = fs2.readFileSync(metadataPath, "utf8");
           const meta = JSON.parse(raw);
           const callId = meta.call_id || entry.name;
           if (!callId || seen.has(callId)) continue;
@@ -332,6 +515,12 @@ var MetricsStore = class extends import_events.EventEmitter {
             );
             continue;
           }
+          if (!record.transcript || record.transcript.length === 0) {
+            const fromJsonl = loadTranscriptJsonl(
+              path2.join(childPath, "transcript.jsonl")
+            );
+            if (fromJsonl.length > 0) record.transcript = fromJsonl;
+          }
           collected.push(record);
           seen.add(callId);
         } catch (err) {
@@ -353,12 +542,45 @@ var MetricsStore = class extends import_events.EventEmitter {
     return collected.length;
   }
 };
+function metricsFromTopLevel(meta) {
+  const cost = meta.cost && typeof meta.cost === "object" ? meta.cost : null;
+  const latency = meta.latency && typeof meta.latency === "object" ? meta.latency : null;
+  const durationMs = meta.duration_ms;
+  const telephony = meta.telephony_provider;
+  if (cost === null && latency === null && durationMs == null && !telephony) {
+    return null;
+  }
+  const out = {};
+  if (cost !== null) out.cost = cost;
+  if (latency !== null) {
+    const fullAvg = latency.avg && typeof latency.avg === "object" ? latency.avg : null;
+    const fullP50 = latency.p50 && typeof latency.p50 === "object" ? latency.p50 : null;
+    const fullP95 = latency.p95 && typeof latency.p95 === "object" ? latency.p95 : null;
+    const fullP99 = latency.p99 && typeof latency.p99 === "object" ? latency.p99 : null;
+    if (fullAvg) out.latency_avg = fullAvg;
+    if (fullP50) out.latency_p50 = fullP50;
+    if (fullP95) out.latency_p95 = fullP95;
+    if (fullP99) out.latency_p99 = fullP99;
+    if (!fullAvg && !fullP50 && !fullP95) {
+      const totalMs = typeof latency.p95_ms === "number" && latency.p95_ms || typeof latency.p50_ms === "number" && latency.p50_ms || 0;
+      out.latency_avg = { total_ms: totalMs };
+    }
+    out.latency = latency;
+  }
+  if (typeof durationMs === "number" && durationMs > 0) {
+    out.duration_seconds = durationMs / 1e3;
+  }
+  if (typeof telephony === "string" && telephony) {
+    out.telephony_provider = telephony;
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
 function metadataToCallRecord(callId, meta) {
   const startedAt = parseTimestamp(meta.started_at);
   if (startedAt === null) return null;
   const endedAt = parseTimestamp(meta.ended_at);
   const status = meta.status || "completed";
-  const metrics = meta.metrics && typeof meta.metrics === "object" ? meta.metrics : null;
+  const metrics = meta.metrics && typeof meta.metrics === "object" ? meta.metrics : metricsFromTopLevel(meta);
   const transcript = Array.isArray(meta.transcript) ? meta.transcript : [];
   return {
     call_id: callId,
@@ -372,6 +594,36 @@ function metadataToCallRecord(callId, meta) {
     transcript
   };
 }
+function loadTranscriptJsonl(filePath) {
+  try {
+    if (!fs2.existsSync(filePath)) return [];
+    const raw = fs2.readFileSync(filePath, "utf8");
+    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    const out = [];
+    for (const line of lines) {
+      let row;
+      try {
+        row = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const tsIso = typeof row.ts === "string" ? Date.parse(row.ts) : NaN;
+      const tsNumeric = typeof row.timestamp === "number" ? row.timestamp * 1e3 : NaN;
+      const timestamp = Number.isFinite(tsIso) ? tsIso : Number.isFinite(tsNumeric) ? tsNumeric : 0;
+      const userText = typeof row.user_text === "string" ? row.user_text : "";
+      const agentText = typeof row.agent_text === "string" ? row.agent_text : "";
+      if (userText.length > 0) {
+        out.push({ role: "user", text: userText, timestamp });
+      }
+      if (agentText.length > 0 && agentText !== "[interrupted]") {
+        out.push({ role: "assistant", text: agentText, timestamp });
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
 function parseTimestamp(raw) {
   if (typeof raw === "number") {
     return Number.isFinite(raw) ? raw : null;
@@ -490,9 +742,9 @@ function loadDashboardHtml() {
     (0, import_node_path.join)(here, "dashboard", "ui.html"),
     (0, import_node_path.join)(here, "..", "dashboard", "ui.html")
   ];
-  for (const path2 of candidates) {
+  for (const path3 of candidates) {
     try {
-      return (0, import_node_fs.readFileSync)(path2, "utf8");
+      return (0, import_node_fs.readFileSync)(path3, "utf8");
     } catch {
     }
   }
@@ -512,7 +764,8 @@ function mountDashboard(app, store, token = "") {
     res.json(store.getCalls(limit, offset));
   });
   app.get("/api/dashboard/calls/:callId", auth, (req, res) => {
-    const call = store.getCall(String(req.params.callId));
+    const callId = String(req.params.callId);
+    const call = store.getCall(callId) ?? store.getActive(callId);
     if (!call) {
       res.status(404).json({ error: "Not found" });
       return;
@@ -525,6 +778,24 @@ function mountDashboard(app, store, token = "") {
   app.get("/api/dashboard/aggregates", auth, (_req, res) => {
     res.json(store.getAggregates());
   });
+  app.delete("/api/dashboard/calls/:callId", auth, (req, res) => {
+    const callId = String(req.params.callId);
+    const accepted = store.deleteCalls([callId]);
+    res.json({ deleted: accepted, count: accepted.length });
+  });
+  app.post("/api/dashboard/calls/delete", auth, (req, res) => {
+    const body = req.body ?? {};
+    const raw = body.call_ids;
+    if (!Array.isArray(raw)) {
+      res.status(400).json({ error: "Expected JSON body { 'call_ids': [...] }" });
+      return;
+    }
+    const ids = raw.filter(
+      (cid) => typeof cid === "string" && cid.length > 0
+    );
+    const accepted = store.deleteCalls(ids);
+    res.json({ deleted: accepted, count: accepted.length });
+  });
   app.get("/api/dashboard/events", auth, (req, res) => {
     res.writeHead(200, {
       "Content-Type": "text/event-stream",
@@ -597,7 +868,8 @@ function mountApi(app, store, token = "") {
     res.json({ data: active, count: active.length });
   });
   app.get("/api/v1/calls/:callId", auth, (req, res) => {
-    const call = store.getCall(String(req.params.callId));
+    const callId = String(req.params.callId);
+    const call = store.getCall(callId) ?? store.getActive(callId);
     if (!call) {
       res.status(404).json({ error: "Call not found" });
       return;
@@ -725,6 +997,12 @@ async function main() {
       res.json({ ok: false, error: "missing call_id" });
       return;
     }
+    const status = data.status;
+    if (status === "initiated") {
+      store.recordCallInitiated(data);
+      res.json({ ok: true, call_id: callId, event: "initiated" });
+      return;
+    }
     store.recordCallStart(data);
     if (data.ended_at) {
       store.recordCallEnd(data, data.metrics ?? null);