@remnic/capture-audio 9.54.1 → 9.54.3

package/dist/{chunk-BRVXKUZY.js → chunk-MFWH245M.js}

@@ -4,7 +4,7 @@
 var CAPTURE_AUDIO_VERSION = "9.14.0";
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 4340;
-var SPOOL_SCHEMA_VERSION = 1;
+var SPOOL_SCHEMA_VERSION = 2;
 var MAX_CONVERSATIONS_LIMIT = 500;
 var DEFAULT_CONVERSATIONS_LIMIT = 50;
 
@@ -128,6 +128,7 @@ function defaultDaemonConfig() {
       threshold: 0.5,
       threads: 1
     },
+    reorderWindowSeconds: 60,
     diarization: { similarityThreshold: 0.4 },
     stt: { engine: "whisper-cpp", modelPath: null, threads: null },
     denyApps: [],
@@ -140,6 +141,7 @@ var KNOWN_TOP_KEYS = {
   chunkSeconds: true,
   captureChannel: true,
   conversationGapMinutes: true,
+  reorderWindowSeconds: true,
   rawRetentionHours: true,
   spoolRetentionDays: true,
   vad: true,
@@ -195,6 +197,12 @@ function parseDaemonConfig(raw) {
   if (obj.spoolRetentionDays !== void 0) {
     cfg.spoolRetentionDays = coerceNumber(obj.spoolRetentionDays, "spoolRetentionDays", { integer: true, min: 1 });
   }
+  if (obj.reorderWindowSeconds !== void 0) {
+    cfg.reorderWindowSeconds = coerceNumber(obj.reorderWindowSeconds, "reorderWindowSeconds", {
+      min: 0,
+      max: 3600
+    });
+  }
   if (obj.vad !== void 0) {
     const vad = asObject(obj.vad, "vad");
     warnUnknownKeys(
@@ -947,7 +955,8 @@ CREATE TABLE IF NOT EXISTS segments (
   text TEXT NOT NULL,
   start_utc TEXT NOT NULL,
   end_utc TEXT NOT NULL,
-  ordinal INTEGER NOT NULL DEFAULT 0
+  ordinal INTEGER NOT NULL DEFAULT 0,
+  embedding BLOB
 );
 CREATE TABLE IF NOT EXISTS speaker_clusters (
   id TEXT PRIMARY KEY,
@@ -965,6 +974,20 @@ CREATE TABLE IF NOT EXISTS applied_chunks (
 CREATE INDEX IF NOT EXISTS idx_conv_keyset ON conversations(started_at_utc, id);
 CREATE INDEX IF NOT EXISTS idx_seg_conv ON segments(conversation_id, ordinal);
 `;
+function encodeEmbedding(embedding) {
+  if (!embedding || embedding.length === 0) return null;
+  return Buffer.from(JSON.stringify(embedding));
+}
+function decodeEmbedding(blob) {
+  if (!blob || blob.byteLength === 0) return null;
+  try {
+    const parsed = JSON.parse(Buffer.from(blob).toString("utf8"));
+    if (!Array.isArray(parsed)) return null;
+    return parsed.every((n) => typeof n === "number" && Number.isFinite(n)) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
 var ISO_INSTANT = /^(\d{4})-(\d{2})-(\d{2})T\d{2}:\d{2}(:\d{2}(\.\d{1,9})?)?(Z|[+-]\d{2}:\d{2})$/;
 function assertIsoInstant(value, label) {
   const match = typeof value === "string" ? ISO_INSTANT.exec(value) : null;
@@ -1008,7 +1031,25 @@ var Spool = class {
       } catch {
       }
     }
-    this.#db.prepare("INSERT OR IGNORE INTO meta(key, value) VALUES (?, ?)").run("schema_version", String(SPOOL_SCHEMA_VERSION));
+    const storedVersion = this.#db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+    if (storedVersion?.value !== void 0) {
+      const parsed = Number(storedVersion.value);
+      if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new CaptureConfigError(
+          `spool schema_version is malformed: ${JSON.stringify(storedVersion.value)}`
+        );
+      }
+      if (parsed > SPOOL_SCHEMA_VERSION) {
+        throw new CaptureConfigError(
+          `spool schema_version ${parsed} is newer than this build supports (${SPOOL_SCHEMA_VERSION})`
+        );
+      }
+    }
+    const segmentColumns = this.#db.prepare("PRAGMA table_info(segments)").all();
+    if (!segmentColumns.some((column) => column.name === "embedding")) {
+      this.#db.exec("ALTER TABLE segments ADD COLUMN embedding BLOB");
+    }
+    this.#db.prepare("INSERT INTO meta(key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run("schema_version", String(SPOOL_SCHEMA_VERSION));
     this.#db.prepare("INSERT OR IGNORE INTO meta(key, value) VALUES (?, ?)").run("instance_id", ulid());
   }
   close() {
@@ -1077,7 +1118,7 @@ var Spool = class {
         "INSERT INTO conversations(id, started_at_utc, ended_at_utc, state, segment_count) VALUES (?,?,?,?,?)"
       ).run(convId, startedAtUtc, endedAtUtc, state, segments.length);
       const segStmt = db.prepare(
-        "INSERT INTO segments(id, chunk_id, conversation_id, speaker_cluster, is_wearer, channel, text, start_utc, end_utc, ordinal) VALUES (?,?,?,?,?,?,?,?,?,?)"
+        "INSERT INTO segments(id, chunk_id, conversation_id, speaker_cluster, is_wearer, channel, text, start_utc, end_utc, ordinal, embedding) VALUES (?,?,?,?,?,?,?,?,?,?,?)"
       );
       for (let i = 0; i < segments.length; i++) {
         const seg = segments[i];
@@ -1091,7 +1132,8 @@ var Spool = class {
           seg.text,
           seg.startUtc,
           seg.endUtc,
-          i
+          i,
+          encodeEmbedding(seg.embedding)
         );
       }
       db.exec("COMMIT");
@@ -1166,7 +1208,7 @@ var Spool = class {
       const ordinalRow = db.prepare("SELECT COALESCE(MAX(ordinal), -1) + 1 AS n FROM segments WHERE conversation_id = ?").get(convId);
       const nextOrdinal = Number(ordinalRow.n);
       const segStmt = db.prepare(
-        "INSERT INTO segments(id, chunk_id, conversation_id, speaker_cluster, is_wearer, channel, text, start_utc, end_utc, ordinal) VALUES (?,?,?,?,?,?,?,?,?,?)"
+        "INSERT INTO segments(id, chunk_id, conversation_id, speaker_cluster, is_wearer, channel, text, start_utc, end_utc, ordinal, embedding) VALUES (?,?,?,?,?,?,?,?,?,?,?)"
       );
       for (let i = 0; i < segments.length; i++) {
         const seg = segments[i];
@@ -1180,7 +1222,8 @@ var Spool = class {
           seg.text,
           seg.startUtc,
           seg.endUtc,
-          nextOrdinal + i
+          nextOrdinal + i,
+          encodeEmbedding(seg.embedding)
         );
       }
       db.prepare(
@@ -1251,11 +1294,129 @@ var Spool = class {
     }
     return removed;
   }
+  /**
+   * Segments of one conversation that still need a speaker, chronological.
+   *
+   * Only rows with a stored embedding and no cluster yet: clustering runs at
+   * finalize over the segments that SURVIVED dedup (issue #2145), and skipping
+   * already-assigned rows keeps a repeated finalize from double-counting a
+   * centroid.
+   */
+  conversationSegmentsForDiarization(conversationId) {
+    const rows = this.#db.prepare(
+      "SELECT id, channel, embedding FROM segments WHERE conversation_id = ? AND embedding IS NOT NULL AND speaker_cluster IS NULL ORDER BY start_utc ASC, ordinal ASC, id ASC"
+    ).all(conversationId);
+    const out = [];
+    for (const row of rows) {
+      const embedding = decodeEmbedding(row.embedding);
+      if (embedding !== null) out.push({ id: row.id, channel: row.channel, embedding });
+    }
+    return out;
+  }
+  /**
+   * Commit one conversation's diarization: cluster snapshots and the segment
+   * assignments that produced them, in ONE transaction.
+   *
+   * Splitting the two lets a crash persist an updated `embedding_count` while
+   * its segments stay unassigned; the next finalize would select the same rows
+   * and count the same embeddings again (issue #2145). Atomicity is what makes
+   * the repeated-finalize idempotency claim true.
+   */
+  commitDiarization(input) {
+    if (input.assignments.length === 0 && input.clusters.length === 0) return 0;
+    const stmt = this.#db.prepare("UPDATE segments SET speaker_cluster = ?, is_wearer = ? WHERE id = ?");
+    let updated = 0;
+    this.#db.exec("BEGIN");
+    try {
+      for (const cluster of input.clusters) this.#upsertSpeakerUnlocked(cluster);
+      for (const assignment of input.assignments) {
+        updated += Number(stmt.run(assignment.speakerCluster, assignment.isWearer ? 1 : 0, assignment.id).changes);
+      }
+      this.#db.exec("COMMIT");
+    } catch (err) {
+      this.#db.exec("ROLLBACK");
+      throw err;
+    }
+    return updated;
+  }
   /** Ids of every still-`capturing` conversation (dedup-before-finalize sweep). */
   capturingConversationIds() {
     const rows = this.#db.prepare("SELECT id FROM conversations WHERE state = 'capturing' ORDER BY id ASC").all();
     return rows.map((r) => r.id);
   }
+  /**
+   * Record a bare idempotency marker (no segments).
+   *
+   * Used to persist facts a later replay cannot re-derive — such as how many
+   * segments a chunk's transcript produced, which is the only way to tell a
+   * legitimately shorter retranscription from a missing tail (issue #2145).
+   */
+  markApplied(idempotencyKey, conversationId) {
+    this.#db.prepare("INSERT OR IGNORE INTO applied_chunks(idempotency_key, conversation_id, applied_at_utc) VALUES (?,?,?)").run(idempotencyKey, conversationId, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  /**
+   * Whether ANY idempotency key for this chunk was applied.
+   *
+   * Only a SILENT replay needs this — a chunk partially applied by a binary
+   * predating the transcript manifest has no manifest to compare, and a
+   * zero-segment replay has no per-segment key to look up exactly. Speech
+   * chunks use the indexed manifest lookup below, so continuous capture never
+   * pays for this scan (issue #2145).
+   */
+  hasAppliedChunkPrefix(chunkIdPrefix) {
+    const escaped = chunkIdPrefix.replace(/[\\%_]/g, "\\$&");
+    const row = this.#db.prepare("SELECT 1 AS present FROM applied_chunks WHERE idempotency_key LIKE ? ESCAPE '\\' LIMIT 1").get(`${escaped}%`);
+    return row?.present === 1;
+  }
+  /**
+   * Conversations a chunk actually contributed stored segments to.
+   *
+   * Used to scope a rebuilt replay hold to the prefix that chunk belongs to,
+   * rather than to every conversation that happens to be capturing (#2145).
+   * Matches the bare chunk id and every per-segment or per-group derivative
+   * (`<chunkId>:h<hash>`, and the pre-manifest `<chunkId>:<n>`).
+   */
+  conversationIdsForChunk(chunkId) {
+    const escaped = chunkId.replace(/[\\%_]/g, "\\$&");
+    const rows = this.#db.prepare(
+      `SELECT DISTINCT conversation_id AS conversationId
+           FROM segments
+          WHERE conversation_id IS NOT NULL
+            AND (chunk_id = ? OR chunk_id LIKE ? ESCAPE '\\')
+          ORDER BY conversation_id`
+    ).all(chunkId, `${escaped}:%`);
+    return rows.map((row) => row.conversationId);
+  }
+  /**
+   * Chunks whose transcript manifest is recorded but which never completed.
+   *
+   * A restart loses the in-memory record of which chunks are still awaiting a
+   * replay, so it is re-derived from these two durable markers: the manifest is
+   * written before any append, `:done` only after every segment is stored
+   * (issue #2145).
+   */
+  incompleteChunkIds() {
+    const rows = this.#db.prepare(
+      `SELECT substr(idempotency_key, 1, length(idempotency_key) - 9) AS chunkId
+           FROM applied_chunks
+          WHERE idempotency_key LIKE '%:manifest'
+            AND substr(idempotency_key, 1, length(idempotency_key) - 9) || ':done' NOT IN (
+                  SELECT idempotency_key FROM applied_chunks
+                )`
+    ).all();
+    return rows.map((row) => row.chunkId);
+  }
+  /**
+   * The value stored alongside an idempotency marker, or `undefined`.
+   *
+   * `markApplied` uses this column to carry a fact a replay cannot re-derive —
+   * the chunk's transcript manifest hash — and this is the exact, primary-key
+   * lookup that reads it back (issue #2145).
+   */
+  appliedChunkValue(idempotencyKey) {
+    const row = this.#db.prepare("SELECT conversation_id AS conversationId FROM applied_chunks WHERE idempotency_key = ?").get(idempotencyKey);
+    return row?.conversationId;
+  }
   /** Whether a chunk with this idempotency key was already durably applied. */
   isChunkApplied(idempotencyKey) {
     return this.#db.prepare("SELECT 1 FROM applied_chunks WHERE idempotency_key = ? LIMIT 1").get(idempotencyKey) !== void 0;
@@ -1280,11 +1441,23 @@ var Spool = class {
     if (!row) return null;
     return { id: row.id, startedAtUtc: row.startedAtUtc, endedAtUtc: row.endedAtUtc ?? row.startedAtUtc };
   }
+  /** One capturing conversation by id, for resuming a specific prefix. */
+  capturingConversationById(id) {
+    const row = this.#db.prepare(
+      "SELECT id, started_at_utc AS startedAtUtc, ended_at_utc AS endedAtUtc FROM conversations WHERE id = ? AND state = 'capturing'"
+    ).get(id);
+    if (!row) return null;
+    return { id: row.id, startedAtUtc: row.startedAtUtc, endedAtUtc: row.endedAtUtc ?? row.startedAtUtc };
+  }
   #segmentCount(conversationId) {
     const row = this.#db.prepare("SELECT segment_count AS n FROM conversations WHERE id = ?").get(conversationId);
     return row ? Number(row.n) : 0;
   }
   upsertSpeaker(input) {
+    this.#upsertSpeakerUnlocked(input);
+  }
+  /** `upsertSpeaker` without its own transaction, for use inside one. */
+  #upsertSpeakerUnlocked(input) {
     const current = this.#db.prepare(
       "SELECT label, embedding_count AS embeddingCount, is_self AS isSelf, centroid, example_embeddings AS examples FROM speaker_clusters WHERE id = ?"
     ).get(input.id);
@@ -1421,6 +1594,12 @@ function assembleConversations(segments, gapMinutes, state = "final") {
   return conversations;
 }
 var DEFAULT_CONVERSATION_GAP_MINUTES = 10;
+function cloneSegment(segment) {
+  return {
+    ...segment,
+    ...segment.embedding ? { embedding: segment.embedding.slice() } : {}
+  };
+}
 function epochMs(value, field) {
   const ms = Date.parse(value);
   if (!Number.isFinite(ms)) {
@@ -1489,6 +1668,40 @@ var ConversationAssembler = class {
       segments: []
     });
   }
+  /**
+   * Drop finalized conversations the caller no longer needs.
+   *
+   * A long-running daemon would otherwise retain every conversation and every
+   * segment forever, which makes the rollback snapshot below O(capture
+   * history) and the daemon's per-chunk work quadratic (issue #2145). Only the
+   * open conversation can still be mutated, so nothing else needs keeping.
+   */
+  pruneFinalized() {
+    const open = this.#open();
+    const removed = this.#conversations.length - (open ? 1 : 0);
+    this.#conversations.length = 0;
+    if (open) this.#conversations.push(open);
+    return removed;
+  }
+  /**
+   * Deep snapshot for rollback (issue #2145).
+   *
+   * `add` mutates the open conversation in place. A caller that fails BEFORE
+   * anything was persisted must be able to rewind, or the retry feeds earlier
+   * timestamps into an advanced assembler and collapses conversations the
+   * first attempt had split. A caller that already persisted something must
+   * NOT rewind: the durable ids would then diverge from the in-memory ones.
+   */
+  checkpoint() {
+    return this.#conversations.map((conv) => ({ ...conv, segments: conv.segments.map(cloneSegment) }));
+  }
+  /** Rewind to a {@link checkpoint}. */
+  rewind(snapshot) {
+    this.#conversations.length = 0;
+    for (const conv of snapshot) {
+      this.#conversations.push({ ...conv, segments: conv.segments.map(cloneSegment) });
+    }
+  }
   /** Ordered snapshot; segments are cloned so callers cannot mutate internal state. */
   conversations() {
     return this.#conversations.map((conv) => ({ ...conv, segments: conv.segments.slice() }));
@@ -1634,6 +1847,27 @@ var SpeakerClusterer = class {
     this.#clusters.push(cluster);
     return cluster.id;
   }
+  /**
+   * Replace every cluster with `snapshot` (issue #2145).
+   *
+   * `assign` mutates centroids and counts in place, so a diarization commit
+   * that rolls back in SQLite must roll back here too — otherwise the retry
+   * counts the same embeddings twice. Deep-copied, so the caller's snapshot
+   * cannot alias internal state.
+   */
+  restore(snapshot) {
+    this.#clusters = snapshot.map((cluster) => ({
+      ...cluster,
+      centroid: cluster.centroid.slice(),
+      examples: cluster.examples.map((example) => example.slice())
+    }));
+    let highest = 0;
+    for (const cluster of this.#clusters) {
+      const parsed = /^spk_(\d+)$/.exec(cluster.id);
+      if (parsed) highest = Math.max(highest, Number(parsed[1]));
+    }
+    this.#next = highest + 1;
+  }
   /** Snapshot for persistence. */
   clusters() {
     return this.#clusters.map((c) => ({
@@ -2042,14 +2276,74 @@ function dedupeCrossChannel(segments, options = {}) {
 
 // src/processor.ts
 import { createHash as createHash2 } from "crypto";
+import { log } from "@remnic/core/logger";
+function segmentStableKey(chunkId, segment) {
+  const digest = createHash2("sha1").update(`${segment.startUtc}\0${segment.endUtc}\0${segment.text}`).digest("hex").slice(0, 16);
+  return `${chunkId}:h${digest}`;
+}
+function transcriptManifestHash(chunkId, segments) {
+  return createHash2("sha1").update(segments.map((segment) => segmentStableKey(chunkId, segment)).join("\n")).digest("hex").slice(0, 16);
+}
+function transcriptManifestKey(chunkId) {
+  return `${chunkId}:manifest`;
+}
 function chunkStableId(event) {
   return `chk_${createHash2("sha1").update(event.path).digest("hex")}`;
 }
+var MAX_BUFFERED_CHUNKS = 512;
+function instantMs(value, field) {
+  const ms = Date.parse(value);
+  if (Number.isNaN(ms)) {
+    throw new CaptureInputError(`${field}: expected an ISO-8601 instant, got ${JSON.stringify(value)}`);
+  }
+  return ms;
+}
+function firstStartMs(event, raw) {
+  let earliest = instantMs(event.startedAtUtc, "chunk.startedAtUtc");
+  for (const segment of raw) {
+    earliest = Math.min(earliest, instantMs(segment.startUtc, "segment.startUtc"));
+  }
+  return earliest;
+}
+function lastEndMs(event, raw) {
+  let latest = instantMs(event.endedAtUtc, "chunk.endedAtUtc");
+  for (const segment of raw) {
+    latest = Math.max(latest, instantMs(segment.endUtc, "segment.endUtc"));
+  }
+  return latest;
+}
 function createChunkProcessor(deps) {
   let tail = Promise.resolve();
   let recovered = false;
   let openConversationId = null;
+  const retainedChunks = /* @__PURE__ */ new Map();
+  function isHeldForReplay(conversationId) {
+    for (const held of retainedChunks.values()) {
+      if (held.has(conversationId)) return true;
+    }
+    return false;
+  }
+  function trackRetention(chunkId, retained, resumable) {
+    if (!retained) {
+      retainedChunks.delete(chunkId);
+      return;
+    }
+    retainedChunks.set(chunkId, heldFor(chunkId, resumable));
+  }
+  function heldFor(chunkId, resumable) {
+    const own = deps.spool.conversationIdsForChunk(chunkId).filter((id) => resumable.has(id));
+    return own.length > 0 ? new Set(own) : new Set(resumable);
+  }
+  function resumableConversations() {
+    const ids = new Set(deps.spool.capturingConversationIds());
+    if (openConversationId !== null) ids.add(openConversationId);
+    return ids;
+  }
   const processedThisRun = /* @__PURE__ */ new Set();
+  const reorderWindowMs = Math.max(0, deps.reorderWindowMs ?? 0);
+  const buffer = [];
+  const bufferedIds = /* @__PURE__ */ new Set();
+  let watermarkSourceMs = Number.NEGATIVE_INFINITY;
   const dedupeConversation = (id) => {
     const segs = deps.spool.conversationSegmentsForDedup(id);
     if (segs.length === 0) return;
@@ -2058,16 +2352,54 @@ function createChunkProcessor(deps) {
     const drop = segs.filter((s) => !keep.has(s.id)).map((s) => s.id);
     if (drop.length > 0) deps.spool.deleteSegments(drop);
   };
+  const diarizeConversation = (id) => {
+    const diarizer = deps.diarizer;
+    if (!diarizer) return;
+    const pending = deps.spool.conversationSegmentsForDiarization(id);
+    if (pending.length === 0) return;
+    const before = diarizer.clusters();
+    const selfVoiceEnrolled = diarizer.clusters().some((c) => c.isSelf && c.embeddingCount > 0);
+    const assignments = [];
+    const touched = /* @__PURE__ */ new Set();
+    for (const segment of pending) {
+      const clusterId = diarizer.assign(segment.embedding);
+      const assigned = diarizer.clusters().find((c) => c.id === clusterId);
+      const isWearer = (assigned?.isSelf ?? false) || segment.channel === "mic" && !selfVoiceEnrolled;
+      assignments.push({ id: segment.id, speakerCluster: clusterId, isWearer });
+      touched.add(clusterId);
+    }
+    const byId = new Map(diarizer.clusters().map((c) => [c.id, c]));
+    const clusters = [...touched].map((clusterId) => byId.get(clusterId)).filter((cluster) => cluster !== void 0).map((cluster) => ({
+      id: cluster.id,
+      label: cluster.label,
+      isSelf: cluster.isSelf,
+      embeddingCount: cluster.embeddingCount,
+      centroid: cluster.centroid,
+      examples: cluster.examples
+    }));
+    try {
+      deps.spool.commitDiarization({ clusters, assignments });
+    } catch (err) {
+      diarizer.restore(before);
+      throw err;
+    }
+  };
   const finalizeConv = (id) => {
+    if (isHeldForReplay(id)) return false;
     dedupeConversation(id);
+    diarizeConversation(id);
     deps.spool.finalizeConversation(id);
+    return true;
   };
   const report = (error, event) => {
-    deps.onError?.(error instanceof Error ? error : new Error(String(error)), event);
+    try {
+      deps.onError?.(error instanceof Error ? error : new Error(String(error)), event);
+    } catch {
+    }
   };
   async function process2(event) {
     const chunkId = chunkStableId(event);
-    if (processedThisRun.has(chunkId)) return;
+    if (processedThisRun.has(chunkId) || bufferedIds.has(chunkId)) return;
     if (deps.spool.isChunkApplied(`${chunkId}:done`)) {
       processedThisRun.add(chunkId);
       try {
@@ -2077,107 +2409,258 @@ function createChunkProcessor(deps) {
       }
       return;
     }
+    if (deps.spool.isChunkApplied(chunkId) || deps.spool.isChunkApplied(`${chunkId}:0`)) {
+      processedThisRun.add(chunkId);
+      log.warn(
+        `[capture-audio] chunk ${chunkId} was partially applied under the pre-#2145 key scheme; leaving it and its raw audio in place for replay`
+      );
+      return;
+    }
     const isSpeech = deps.detectSpeech ? await deps.detectSpeech(event) : true;
     const raw = isSpeech ? await deps.transcribe({
       wavPath: event.path,
       modelPath: deps.resolveModel(),
       chunkStartedAtUtc: event.startedAtUtc
     }) : [];
-    if (!recovered) {
-      recovered = true;
-      const prior = deps.spool.latestCapturingConversation();
-      if (prior) {
-        deps.assembler.resume(prior);
-        openConversationId = prior.id;
+    const built = buildSegments(event, raw);
+    buffer.push({
+      event,
+      chunkId,
+      built,
+      startMs: firstStartMs(event, raw),
+      endMs: lastEndMs(event, raw),
+      manifestRecorded: false
+    });
+    bufferedIds.add(chunkId);
+    watermarkSourceMs = Math.max(watermarkSourceMs, lastEndMs(event, raw));
+    if (buffer.length > MAX_BUFFERED_CHUNKS) {
+      const evicted = buffer.shift();
+      if (evicted !== void 0) {
+        bufferedIds.delete(evicted.chunkId);
+        report(
+          new Error(
+            `reorder buffer is full (${MAX_BUFFERED_CHUNKS}); chunk ${evicted.chunkId} was dropped with its raw audio retained`
+          ),
+          evicted.event
+        );
       }
     }
-    const closed = deps.assembler.closeIfIdle(event.startedAtUtc);
-    if (closed !== null && closed === openConversationId) {
-      finalizeConv(closed);
-      openConversationId = null;
-    }
-    const selfVoiceEnrolled = deps.diarizer !== void 0 && deps.diarizer.clusters().some((c) => c.isSelf && c.embeddingCount > 0);
+    await releaseReady(false);
+  }
+  function buildSegments(event, raw) {
     const built = [];
     for (const s of raw) {
       const text = s.text.trim();
       if (text === "") continue;
       built.push({
-        seg: { channel: event.channel, text, startUtc: s.startUtc, endUtc: s.endUtc, isWearer: event.channel === "mic" },
+        seg: {
+          channel: event.channel,
+          text,
+          startUtc: s.startUtc,
+          endUtc: s.endUtc,
+          isWearer: event.channel === "mic"
+        },
         raw: s
       });
     }
-    if (built.length > 0) {
-      const groups = [];
-      for (const item of built) {
-        const conv = deps.assembler.add(item.seg);
-        const last = groups[groups.length - 1];
-        if (last && last.id === conv.id) last.items.push(item);
-        else groups.push({ id: conv.id, startedAtUtc: conv.startedAtUtc, items: [item] });
-      }
-      for (let g = 0; g < groups.length; g++) {
-        const grp = groups[g];
-        const key = groups.length === 1 ? chunkId : `${chunkId}:${g}`;
-        if (deps.spool.isChunkApplied(key)) {
-          openConversationId = grp.id;
-          continue;
-        }
-        if (openConversationId !== null && openConversationId !== grp.id) {
-          finalizeConv(openConversationId);
-        }
-        if (deps.embed && deps.diarizer) {
-          for (const item of grp.items) {
-            const embedding = await deps.embed(event, item.raw);
-            const clusterId = deps.diarizer.assign(embedding);
-            const assigned = deps.diarizer.clusters().find((c) => c.id === clusterId);
-            let isWearer = assigned?.isSelf ?? false;
-            if (!isWearer && event.channel === "mic" && !selfVoiceEnrolled) isWearer = true;
-            item.seg.isWearer = isWearer;
-            item.seg.speakerCluster = clusterId;
-          }
-        }
-        if (deps.diarizer) {
-          const touched = new Set(
-            grp.items.map((it) => it.seg.speakerCluster).filter((id) => typeof id === "string")
-          );
-          if (touched.size > 0) {
-            const byId = new Map(deps.diarizer.clusters().map((c) => [c.id, c]));
-            for (const cid of touched) {
-              const c = byId.get(cid);
-              if (c) {
-                deps.spool.upsertSpeaker({
-                  id: c.id,
-                  label: c.label,
-                  isSelf: c.isSelf,
-                  embeddingCount: c.embeddingCount,
-                  centroid: c.centroid,
-                  examples: c.examples
-                });
-              }
-            }
-          }
+    return built;
+  }
+  async function applyBatch(batch, progress) {
+    if (!recovered) {
+      recovered = true;
+      const ownPrefix = batch.flatMap((entry) => deps.spool.conversationIdsForChunk(entry.chunkId)).map((id) => deps.spool.capturingConversationById(id)).find((conversation) => conversation !== null);
+      const prior = ownPrefix ?? deps.spool.latestCapturingConversation();
+      if (prior) {
+        deps.assembler.resume(prior);
+        openConversationId = prior.id;
+      }
+      const capturingAtStartup = new Set(deps.spool.capturingConversationIds());
+      for (const chunkId of deps.spool.incompleteChunkIds()) {
+        const held = heldFor(chunkId, capturingAtStartup);
+        if (held.size > 0) retainedChunks.set(chunkId, held);
+      }
+    }
+    const resumable = resumableConversations();
+    for (const entry of batch) trackRetention(entry.chunkId, !isFullyProcessed(entry), resumable);
+    const earliestStart = batch.reduce(
+      (earliest, entry) => entry.startMs < earliest.startMs ? entry : earliest,
+      batch[0]
+    );
+    const closed = deps.assembler.closeIfIdle(earliestStart.event.startedAtUtc);
+    if (closed !== null && closed === openConversationId) {
+      if (finalizeConv(closed)) {
+        progress.persisted = true;
+        openConversationId = null;
+      }
+    }
+    const stream = batch.flatMap(
+      (entry) => entry.built.map((item, index) => ({ entry, item, index }))
+    ).sort((left, right) => {
+      if (left.item.seg.startUtc !== right.item.seg.startUtc) {
+        return left.item.seg.startUtc < right.item.seg.startUtc ? -1 : 1;
+      }
+      if (left.item.seg.endUtc !== right.item.seg.endUtc) {
+        return left.item.seg.endUtc < right.item.seg.endUtc ? -1 : 1;
+      }
+      if (left.entry.chunkId !== right.entry.chunkId) {
+        return left.entry.chunkId < right.entry.chunkId ? -1 : 1;
+      }
+      return left.index - right.index;
+    });
+    const fresh = stream.filter(
+      ({ entry, item }) => !deps.spool.isChunkApplied(segmentStableKey(entry.chunkId, item.seg))
+    );
+    if (deps.embed) {
+      for (const { entry, item } of fresh) {
+        item.seg.embedding = await deps.embed(entry.event, item.raw);
+      }
+    }
+    const runs = [];
+    for (const { entry, item, index } of fresh) {
+      const conv = deps.assembler.add(item.seg);
+      const carried = { ...item, index };
+      const last = runs[runs.length - 1];
+      if (last && last.id === conv.id && last.entry === entry) last.items.push(carried);
+      else runs.push({ entry, id: conv.id, startedAtUtc: conv.startedAtUtc, items: [carried] });
+    }
+    for (const run of runs) {
+      const { chunkId, event } = run.entry;
+      for (const item of run.items) {
+        const key = segmentStableKey(chunkId, item.seg);
+        if (openConversationId !== null && openConversationId !== run.id) {
+          if (finalizeConv(openConversationId)) progress.persisted = true;
         }
         deps.spool.appendAssembledSegments({
           idempotencyKey: key,
           chunkId: key,
-          conversationId: grp.id,
-          startedAtUtc: grp.startedAtUtc,
+          conversationId: run.id,
+          startedAtUtc: run.startedAtUtc,
           state: "capturing",
           device: event.device,
           wavPath: event.path,
-          segments: grp.items.map((it) => it.seg)
+          segments: [item.seg]
         });
-        openConversationId = grp.id;
+        progress.persisted = true;
+        openConversationId = run.id;
       }
     }
-    const chunkFullyProcessed = built.length > 0 || !deps.spool.isChunkApplied(`${chunkId}:0`);
-    processedThisRun.add(chunkId);
-    if (chunkFullyProcessed) {
-      deps.spool.markChunkComplete(chunkId, openConversationId ?? "-");
+    for (const entry of batch) {
+      const fullyProcessed = isFullyProcessed(entry);
+      trackRetention(entry.chunkId, !fullyProcessed, resumable);
+      if (entry.built.length > 0 && !fullyProcessed) {
+        log.warn(
+          `[capture-audio] chunk ${entry.chunkId} retranscribed to a different transcript than an earlier run; keeping its raw audio for replay`
+        );
+      }
+      processedThisRun.add(entry.chunkId);
+      if (!fullyProcessed) continue;
+      deps.spool.markChunkComplete(entry.chunkId, openConversationId ?? "-");
       try {
-        await deps.cleanupRawAudio(event);
+        await deps.cleanupRawAudio(entry.event);
       } catch (err) {
-        report(err, event);
+        report(err, entry.event);
+      }
+    }
+  }
+  function isFullyProcessed(entry) {
+    if (entry.built.length === 0) return !deps.spool.hasAppliedChunkPrefix(`${entry.chunkId}:`);
+    return deps.spool.appliedChunkValue(transcriptManifestKey(entry.chunkId)) === transcriptManifestHash(entry.chunkId, entry.built.map((item) => item.seg));
+  }
+  function recordTranscriptManifest(entry) {
+    if (entry.built.length === 0) {
+      entry.manifestRecorded = true;
+      return true;
+    }
+    try {
+      const key = transcriptManifestKey(entry.chunkId);
+      const ours = transcriptManifestHash(entry.chunkId, entry.built.map((item) => item.seg));
+      const recorded = deps.spool.appliedChunkValue(key);
+      if (recorded === void 0) {
+        deps.spool.markApplied(key, ours);
+      } else if (recorded !== ours) {
+        return "conflict";
+      }
+      entry.manifestRecorded = true;
+      return true;
+    } catch (err) {
+      report(err, entry.event);
+      return false;
+    }
+  }
+  async function releaseReady(flushAll) {
+    let finalFailure;
+    for (; ; ) {
+      const threshold = flushAll ? Number.POSITIVE_INFINITY : watermarkSourceMs - reorderWindowMs;
+      const batch = [];
+      let manifestBlocked = false;
+      for (let i = buffer.length - 1; i >= 0; i--) {
+        const candidate = buffer[i];
+        if (candidate.endMs > threshold) continue;
+        const manifest = candidate.manifestRecorded ? true : recordTranscriptManifest(candidate);
+        if (manifest === "conflict") {
+          buffer.splice(i, 1);
+          bufferedIds.delete(candidate.chunkId);
+          trackRetention(candidate.chunkId, true, resumableConversations());
+          report(
+            new Error(
+              `transcript for chunk ${candidate.chunkId} does not match the recorded manifest; raw audio retained`
+            ),
+            candidate.event
+          );
+          continue;
+        }
+        if (!manifest) {
+          manifestBlocked = true;
+          break;
+        }
+        buffer.splice(i, 1);
+        bufferedIds.delete(candidate.chunkId);
+        batch.push(candidate);
+      }
+      if (manifestBlocked) {
+        for (const entry of batch) {
+          buffer.push(entry);
+          bufferedIds.add(entry.chunkId);
+        }
+        if (flushAll) {
+          throw new Error("flush-plan manifest could not be persisted; chunks are retained for replay");
+        }
+        return;
+      }
+      if (batch.length === 0) {
+        if (flushAll && buffer.length > 0) {
+          throw new Error("buffered chunks could not be released; they are retained for replay");
+        }
+        return;
+      }
+      batch.sort(
+        (left, right) => left.startMs - right.startMs || left.endMs - right.endMs || (left.chunkId < right.chunkId ? -1 : left.chunkId > right.chunkId ? 1 : 0)
+      );
+      const checkpoint = {
+        assembler: deps.assembler.checkpoint(),
+        recovered,
+        openConversationId
+      };
+      const progress = { persisted: false };
+      try {
+        await applyBatch(batch, progress);
+      } catch (error) {
+        if (!progress.persisted) {
+          deps.assembler.rewind(checkpoint.assembler);
+          recovered = checkpoint.recovered;
+          openConversationId = checkpoint.openConversationId;
+        }
+        for (const entry of batch) {
+          if (processedThisRun.has(entry.chunkId) || bufferedIds.has(entry.chunkId)) continue;
+          buffer.push(entry);
+          bufferedIds.add(entry.chunkId);
+        }
+        if (flushAll) finalFailure ??= error;
+        report(error, batch[0].event);
+        if (finalFailure !== void 0) throw finalFailure;
+        return;
       }
+      deps.assembler.pruneFinalized();
     }
   }
   function enqueue(event) {
@@ -2187,10 +2670,31 @@ function createChunkProcessor(deps) {
     return tail.then(() => void 0);
   }
   async function finalize() {
-    await drain();
-    deps.assembler.finalize();
-    for (const id of deps.spool.capturingConversationIds()) dedupeConversation(id);
-    return deps.spool.finalizeOpenConversations();
+    const flush = tail.then(() => releaseReady(true));
+    tail = flush.catch(() => void 0);
+    let flushFailure;
+    try {
+      await flush;
+    } catch (error) {
+      flushFailure = error;
+    }
+    const holdOpen = flushFailure !== void 0;
+    if (!holdOpen) deps.assembler.finalize();
+    let sweepFailure;
+    let closed = 0;
+    for (const id of deps.spool.capturingConversationIds()) {
+      try {
+        dedupeConversation(id);
+        if (!holdOpen && !isHeldForReplay(id)) diarizeConversation(id);
+        if (!holdOpen && !isHeldForReplay(id) && deps.spool.finalizeConversation(id)) closed++;
+      } catch (error) {
+        sweepFailure ??= error;
+      }
+    }
+    const total = sweepFailure === void 0 && !holdOpen && retainedChunks.size === 0 ? closed + deps.spool.finalizeOpenConversations() : closed;
+    if (flushFailure !== void 0) throw flushFailure;
+    if (sweepFailure !== void 0) throw sweepFailure;
+    return total;
   }
   return { enqueue, drain, finalize };
 }
@@ -2350,6 +2854,13 @@ function createLiveCapture(options) {
     resolveModel,
     transcribe,
     cleanupRawAudio,
+    // Cross-channel arrival skew: hold each transcribed chunk until the
+    // watermark passes it, so a delayed system chunk still assembles into the
+    // conversation it belongs to (issue #2145).
+    // Only "both" has two independent chunk streams to interleave. A single
+    // channel is already ordered, so buffering would add latency and widen the
+    // crash window for nothing (issue #2145).
+    reorderWindowMs: config.captureChannel === "both" ? config.reorderWindowSeconds * 1e3 : 0,
     ...options.detectSpeech ? { detectSpeech: options.detectSpeech } : {},
     ...options.embed ? { embed: options.embed } : {},
     ...diarizer ? { diarizer } : {},
@@ -2869,7 +3380,12 @@ async function cmdStart(paths, flags, env, stdout, stderr, spawnArgvPrefix) {
       if (closing) return;
       closing = true;
       replayAbort.abort();
-      void replayTask.catch(() => void 0).then(() => live ? live.stop().then(() => void 0) : void 0).catch(() => void 0).then(() => {
+      void replayTask.catch(() => void 0).then(() => live ? live.stop().then(() => void 0) : void 0).catch((error) => {
+        process.stderr.write(
+          `[capture-audio] shutdown flush failed; retained raw audio was NOT ingested: ${describeError(error)}
+`
+        );
+      }).then(() => {
         spool.finalizeOpenConversations();
         return handle.close().catch(() => void 0);
       }).finally(() => {
@@ -3184,4 +3700,4 @@ export {
   superviseReplay,
   runCapture
 };
-//# sourceMappingURL=chunk-BRVXKUZY.js.map
+//# sourceMappingURL=chunk-MFWH245M.js.map