@remnic/capture-audio 9.24.0

package/dist/chunk-BRVXKUZY.js

@@ -0,0 +1,3187 @@
+// openclaw-engram: Local-first memory plugin
+
+// src/constants.ts
+var CAPTURE_AUDIO_VERSION = "9.14.0";
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 4340;
+var SPOOL_SCHEMA_VERSION = 1;
+var MAX_CONVERSATIONS_LIMIT = 500;
+var DEFAULT_CONVERSATIONS_LIMIT = 50;
+
+// src/errors.ts
+var CaptureConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CaptureConfigError";
+  }
+};
+var CaptureInputError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CaptureInputError";
+  }
+};
+
+// src/config.ts
+import { readFileSync } from "fs";
+
+// src/util.ts
+import { randomFillSync } from "crypto";
+var CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function ulid(time = Date.now()) {
+  return encodeTime(time) + encodeRandom();
+}
+function encodeTime(time) {
+  if (!Number.isFinite(time) || time < 0) {
+    throw new Error("ulid: time must be a non-negative finite number");
+  }
+  let out = "";
+  let t = Math.floor(time);
+  for (let i = 0; i < 10; i++) {
+    out = CROCKFORD[t % 32] + out;
+    t = Math.floor(t / 32);
+  }
+  return out;
+}
+function encodeRandom() {
+  const bytes = new Uint8Array(16);
+  randomFillSync(bytes);
+  let out = "";
+  for (let i = 0; i < 16; i++) out += CROCKFORD[bytes[i] % 32];
+  return out;
+}
+function dateInTimezone(date, timezone) {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(date);
+  const get = (type) => parts.find((part) => part.type === type)?.value ?? "";
+  return `${get("year")}-${get("month")}-${get("day")}`;
+}
+var LOOPBACK_HOSTS = {
+  "127.0.0.1": true,
+  "::1": true,
+  localhost: true,
+  "::ffff:127.0.0.1": true
+};
+function stripIpv6Brackets(host) {
+  const h = host.trim();
+  return h.startsWith("[") && h.endsWith("]") ? h.slice(1, -1) : h;
+}
+function isLoopbackHost(host) {
+  return Object.hasOwn(LOOPBACK_HOSTS, stripIpv6Brackets(host).toLowerCase());
+}
+function describeValue(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  const t = typeof value;
+  if (t === "string") return `a string`;
+  if (t === "object") return "an object";
+  return `${t} (${String(value)})`;
+}
+function formatHostForUrl(host) {
+  return host.includes(":") ? `[${host}]` : host;
+}
+
+// src/coerce.ts
+function coerceNumber(value, label, bounds = {}) {
+  let n;
+  if (typeof value === "number") {
+    n = value;
+  } else if (typeof value === "string" && value.trim() !== "") {
+    n = Number(value);
+  } else {
+    throw new CaptureConfigError(`${label}: expected a number, got ${describeValue(value)}`);
+  }
+  if (!Number.isFinite(n)) {
+    throw new CaptureConfigError(`${label}: '${String(value)}' is not a finite number`);
+  }
+  if (bounds.integer && !Number.isInteger(n)) {
+    throw new CaptureConfigError(`${label}: expected an integer, got ${n}`);
+  }
+  if (bounds.min !== void 0 && n < bounds.min) {
+    throw new CaptureConfigError(`${label}: must be >= ${bounds.min}, got ${n}`);
+  }
+  if (bounds.max !== void 0 && n > bounds.max) {
+    throw new CaptureConfigError(`${label}: must be <= ${bounds.max}, got ${n}`);
+  }
+  return n;
+}
+
+// src/config.ts
+function defaultDaemonConfig() {
+  return {
+    host: DEFAULT_HOST,
+    port: DEFAULT_PORT,
+    chunkSeconds: 30,
+    captureChannel: "both",
+    conversationGapMinutes: 10,
+    rawRetentionHours: 0,
+    spoolRetentionDays: 30,
+    vad: {
+      modelPath: null,
+      minSpeechMs: 500,
+      minSilenceMs: 500,
+      maxSpeechMs: 3e4,
+      threshold: 0.5,
+      threads: 1
+    },
+    diarization: { similarityThreshold: 0.4 },
+    stt: { engine: "whisper-cpp", modelPath: null, threads: null },
+    denyApps: [],
+    devices: { mic: null, system: null }
+  };
+}
+var KNOWN_TOP_KEYS = {
+  host: true,
+  port: true,
+  chunkSeconds: true,
+  captureChannel: true,
+  conversationGapMinutes: true,
+  rawRetentionHours: true,
+  spoolRetentionDays: true,
+  vad: true,
+  diarization: true,
+  stt: true,
+  denyApps: true,
+  devices: true
+};
+function asObject(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new CaptureConfigError(`${label}: expected an object, got ${describeValue(value)}`);
+  }
+  return value;
+}
+function warnUnknownKeys(obj, known, label) {
+  for (const key of Object.keys(obj)) {
+    if (!Object.hasOwn(known, key)) {
+      console.warn(`remnic-capture-audio: ${label}: ignoring unknown key '${key}'`);
+    }
+  }
+}
+function requireString(value, label) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new CaptureConfigError(`${label}: expected a non-empty string, got ${describeValue(value)}`);
+  }
+  return value.trim();
+}
+function parseDaemonConfig(raw) {
+  const cfg = defaultDaemonConfig();
+  const obj = asObject(raw, "config");
+  warnUnknownKeys(obj, KNOWN_TOP_KEYS, "config");
+  if (obj.host !== void 0) cfg.host = requireString(obj.host, "host");
+  if (obj.port !== void 0) {
+    cfg.port = coerceNumber(obj.port, "port", { integer: true, min: 1, max: 65535 });
+  }
+  if (obj.chunkSeconds !== void 0) {
+    cfg.chunkSeconds = coerceNumber(obj.chunkSeconds, "chunkSeconds", { integer: true, min: 1, max: 3600 });
+  }
+  if (obj.captureChannel !== void 0) {
+    if (obj.captureChannel !== "mic" && obj.captureChannel !== "system" && obj.captureChannel !== "both") {
+      throw new CaptureConfigError(
+        `captureChannel: expected 'mic' | 'system' | 'both', got ${describeValue(obj.captureChannel)}`
+      );
+    }
+    cfg.captureChannel = obj.captureChannel;
+  }
+  if (obj.conversationGapMinutes !== void 0) {
+    cfg.conversationGapMinutes = coerceNumber(obj.conversationGapMinutes, "conversationGapMinutes", { min: 0 });
+  }
+  if (obj.rawRetentionHours !== void 0) {
+    cfg.rawRetentionHours = coerceNumber(obj.rawRetentionHours, "rawRetentionHours", { min: 0 });
+  }
+  if (obj.spoolRetentionDays !== void 0) {
+    cfg.spoolRetentionDays = coerceNumber(obj.spoolRetentionDays, "spoolRetentionDays", { integer: true, min: 1 });
+  }
+  if (obj.vad !== void 0) {
+    const vad = asObject(obj.vad, "vad");
+    warnUnknownKeys(
+      vad,
+      {
+        modelPath: true,
+        minSpeechMs: true,
+        minSilenceMs: true,
+        maxSpeechMs: true,
+        threshold: true,
+        threads: true
+      },
+      "vad"
+    );
+    if (vad.modelPath !== void 0) {
+      cfg.vad.modelPath = vad.modelPath === null ? null : requireString(vad.modelPath, "vad.modelPath");
+    }
+    if (vad.minSpeechMs !== void 0) {
+      cfg.vad.minSpeechMs = coerceNumber(vad.minSpeechMs, "vad.minSpeechMs", { integer: true, min: 1 });
+    }
+    if (vad.minSilenceMs !== void 0) {
+      cfg.vad.minSilenceMs = coerceNumber(vad.minSilenceMs, "vad.minSilenceMs", { integer: true, min: 0 });
+    }
+    if (vad.maxSpeechMs !== void 0) {
+      cfg.vad.maxSpeechMs = coerceNumber(vad.maxSpeechMs, "vad.maxSpeechMs", { integer: true, min: 1 });
+    }
+    if (vad.threshold !== void 0) {
+      const threshold = coerceNumber(vad.threshold, "vad.threshold", { max: 1 });
+      if (threshold <= 0 || threshold >= 1) {
+        throw new CaptureConfigError("vad.threshold must be between 0 and 1");
+      }
+      cfg.vad.threshold = threshold;
+    }
+    if (vad.threads !== void 0) {
+      cfg.vad.threads = coerceNumber(vad.threads, "vad.threads", { integer: true, min: 1, max: 256 });
+    }
+    if (cfg.vad.minSpeechMs > cfg.vad.maxSpeechMs) {
+      throw new CaptureConfigError("vad.maxSpeechMs must be greater than or equal to vad.minSpeechMs");
+    }
+  }
+  if (obj.diarization !== void 0) {
+    const dia = asObject(obj.diarization, "diarization");
+    warnUnknownKeys(dia, { similarityThreshold: true }, "diarization");
+    if (dia.similarityThreshold !== void 0) {
+      const threshold = coerceNumber(dia.similarityThreshold, "diarization.similarityThreshold", { max: 1 });
+      if (threshold <= 0 || threshold >= 1) {
+        throw new CaptureConfigError("diarization.similarityThreshold must be between 0 and 1");
+      }
+      cfg.diarization.similarityThreshold = threshold;
+    }
+  }
+  if (obj.stt !== void 0) {
+    const stt = asObject(obj.stt, "stt");
+    warnUnknownKeys(stt, { engine: true, modelPath: true, threads: true }, "stt");
+    if (stt.engine !== void 0 && stt.engine !== "whisper-cpp") {
+      throw new CaptureConfigError(`stt.engine: only 'whisper-cpp' is supported, got ${describeValue(stt.engine)}`);
+    }
+    if (stt.modelPath !== void 0 && stt.modelPath !== null) {
+      if (typeof stt.modelPath !== "string") {
+        throw new CaptureConfigError(`stt.modelPath: expected a string, got ${describeValue(stt.modelPath)}`);
+      }
+      cfg.stt.modelPath = stt.modelPath.trim() || null;
+    }
+    if (stt.threads !== void 0 && stt.threads !== null) {
+      cfg.stt.threads = coerceNumber(stt.threads, "stt.threads", { integer: true, min: 1, max: 256 });
+    }
+  }
+  if (obj.denyApps !== void 0) {
+    if (!Array.isArray(obj.denyApps) || !obj.denyApps.every((app) => typeof app === "string")) {
+      throw new CaptureConfigError(`denyApps: expected an array of strings, got ${describeValue(obj.denyApps)}`);
+    }
+    cfg.denyApps = [...obj.denyApps];
+  }
+  if (obj.devices !== void 0) {
+    const dev = asObject(obj.devices, "devices");
+    warnUnknownKeys(dev, { mic: true, system: true }, "devices");
+    if (dev.mic !== void 0 && dev.mic !== null) {
+      if (typeof dev.mic !== "string") {
+        throw new CaptureConfigError(`devices.mic: expected a string, got ${describeValue(dev.mic)}`);
+      }
+      cfg.devices.mic = dev.mic;
+    }
+    if (dev.system !== void 0 && dev.system !== null) {
+      if (typeof dev.system !== "string") {
+        throw new CaptureConfigError(`devices.system: expected a string, got ${describeValue(dev.system)}`);
+      }
+      cfg.devices.system = dev.system;
+    }
+  }
+  return cfg;
+}
+function loadDaemonConfig(configPath) {
+  let text;
+  try {
+    text = readFileSync(configPath, "utf8");
+  } catch {
+    throw new CaptureConfigError(
+      `config not found at ${configPath} \u2014 run \`remnic-capture-audio init\` first`
+    );
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (err) {
+    throw new CaptureConfigError(`config at ${configPath} is not valid JSON: ${err.message}`);
+  }
+  return parseDaemonConfig(raw);
+}
+function serializeDaemonConfig(cfg) {
+  return `${JSON.stringify(cfg, null, 2)}
+`;
+}
+
+// src/control.ts
+import { mkdirSync, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync } from "fs";
+import { randomBytes } from "crypto";
+import path from "path";
+function writePidFile(pidPath, pid, options = {}) {
+  mkdirSync(path.dirname(pidPath), { recursive: true });
+  const record = {
+    pid,
+    instanceId: options.instanceId ?? null,
+    startedAtIso: options.startedAtIso ?? (/* @__PURE__ */ new Date()).toISOString(),
+    host: options.host ?? null,
+    port: options.port ?? null
+  };
+  const tmp = `${pidPath}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(record)}
+`, "utf8");
+  renameSync(tmp, pidPath);
+}
+function readPidRecord(pidPath) {
+  let text;
+  try {
+    text = readFileSync2(pidPath, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const record = parsed;
+  const pid = typeof record.pid === "number" ? record.pid : Number.NaN;
+  if (!Number.isInteger(pid) || pid <= 0) return null;
+  const port = typeof record.port === "number" && Number.isInteger(record.port) && record.port > 0 ? record.port : null;
+  return {
+    pid,
+    instanceId: typeof record.instanceId === "string" ? record.instanceId : null,
+    startedAtIso: typeof record.startedAtIso === "string" ? record.startedAtIso : "",
+    host: typeof record.host === "string" && record.host !== "" ? record.host : null,
+    port
+  };
+}
+function readPidFile(pidPath) {
+  return readPidRecord(pidPath)?.pid ?? null;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function removePidFile(pidPath) {
+  rmSync(pidPath, { force: true });
+}
+function removePidFileIfOwner(pidPath, pid) {
+  const record = readPidRecord(pidPath);
+  if (record && record.pid === pid) rmSync(pidPath, { force: true });
+}
+
+// src/token.ts
+import { Buffer as Buffer2 } from "buffer";
+import { randomBytes as randomBytes2, timingSafeEqual } from "crypto";
+import { chmodSync, existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import path2 from "path";
+function generateToken() {
+  return randomBytes2(32).toString("base64url");
+}
+function loadOrCreateToken(tokenPath) {
+  mkdirSync2(path2.dirname(tokenPath), { recursive: true });
+  if (existsSync(tokenPath)) {
+    chmodSync(tokenPath, 384);
+    const existing = readFileSync3(tokenPath, "utf8").trim();
+    if (existing) return existing;
+  }
+  const token = generateToken();
+  writeFileSync2(tokenPath, `${token}
+`, { mode: 384 });
+  chmodSync(tokenPath, 384);
+  return token;
+}
+function tokensMatch(expected, presented) {
+  const a = Buffer2.from(expected, "utf8");
+  const b = Buffer2.from(presented, "utf8");
+  if (a.length !== b.length) return false;
+  return timingSafeEqual(a, b);
+}
+function bearerFromHeader(header) {
+  const value = Array.isArray(header) ? header[0] : header;
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (trimmed.slice(0, 6).toLowerCase() !== "bearer") return null;
+  const separator = trimmed.charCodeAt(6);
+  if (separator !== 32 && separator !== 9) return null;
+  const token = trimmed.slice(6).trim();
+  return token || null;
+}
+
+// src/validate.ts
+import { Buffer as Buffer3 } from "buffer";
+var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+function parseTranscriptDate(value) {
+  if (typeof value !== "string" || !DATE_RE.test(value)) {
+    throw new CaptureInputError(`invalid date '${value ?? ""}' \u2014 expected YYYY-MM-DD`);
+  }
+  const [year, month, day] = value.split("-").map(Number);
+  const dt = new Date(Date.UTC(year, month - 1, day));
+  dt.setUTCFullYear(year);
+  if (dt.getUTCFullYear() !== year || dt.getUTCMonth() !== month - 1 || dt.getUTCDate() !== day) {
+    throw new CaptureInputError(`invalid date '${value}' \u2014 not a real calendar date`);
+  }
+  return value;
+}
+function assertValidTimezone(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new CaptureInputError("invalid timezone '' \u2014 expected an IANA timezone");
+  }
+  try {
+    new Intl.DateTimeFormat("en-CA", { timeZone: value });
+  } catch {
+    throw new CaptureInputError(`invalid timezone '${value}' \u2014 not a known IANA timezone`);
+  }
+  return value;
+}
+function parseLimit(value) {
+  if (value === null || value === void 0) return DEFAULT_CONVERSATIONS_LIMIT;
+  const n = Number(value);
+  if (value === "" || !Number.isInteger(n) || n < 1 || n > MAX_CONVERSATIONS_LIMIT) {
+    throw new CaptureInputError(
+      `invalid limit '${value}' \u2014 expected an integer between 1 and ${MAX_CONVERSATIONS_LIMIT}`
+    );
+  }
+  return n;
+}
+function encodeCursor(startedAtUtc, id) {
+  return Buffer3.from(JSON.stringify([startedAtUtc, id]), "utf8").toString("base64url");
+}
+function decodeCursor(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer3.from(value, "base64url").toString("utf8"));
+  } catch {
+    throw new CaptureInputError("invalid cursor \u2014 not a recognized pagination token");
+  }
+  if (Array.isArray(parsed) && parsed.length === 2 && typeof parsed[0] === "string" && typeof parsed[1] === "string" && parsed[1] !== "" && /^\d{4}-\d{2}-\d{2}T/.test(parsed[0]) && Number.isFinite(Date.parse(parsed[0]))) {
+    return { startedAtUtc: parsed[0], id: parsed[1] };
+  }
+  throw new CaptureInputError("invalid cursor \u2014 not a recognized pagination token");
+}
+
+// src/daemon.ts
+import http from "http";
+import { Buffer as Buffer4 } from "buffer";
+function sendJson(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": Buffer4.byteLength(payload)
+  });
+  res.end(payload);
+}
+function handleHealth(deps, res) {
+  sendJson(res, 200, {
+    ok: true,
+    version: CAPTURE_AUDIO_VERSION,
+    platform: process.platform,
+    capturing: typeof deps.capturing === "function" ? deps.capturing() : deps.capturing ?? false,
+    sttModel: deps.config.stt.modelPath,
+    pendingChunks: deps.spool.pendingChunkCount(),
+    instanceId: deps.spool.meta("instance_id"),
+    replayStatus: deps.spool.meta("replay_status"),
+    pid: process.pid
+  });
+}
+function handleConversations(deps, url, res) {
+  const date = parseTranscriptDate(url.searchParams.get("date"));
+  const timezone = assertValidTimezone(url.searchParams.get("timezone"));
+  const limit = parseLimit(url.searchParams.get("limit"));
+  const cursor = url.searchParams.get("cursor");
+  const page = deps.spool.queryFinalConversations({ date, timezone, cursor, limit });
+  sendJson(res, 200, page);
+}
+function handleSpeakers(deps, res) {
+  const speakers = deps.spool.listSpeakers().map((s) => ({ id: s.id, label: s.label, isSelf: s.isSelf }));
+  sendJson(res, 200, { speakers });
+}
+function createRequestHandler(deps) {
+  if (!isLoopbackHost(deps.config.host)) {
+    throw new CaptureConfigError(
+      `refusing to bind non-loopback host '${deps.config.host}': capture-audio serves plain HTTP with no TLS contract; bind a loopback address (127.0.0.1 or ::1) only`
+    );
+  }
+  if (!deps.token) {
+    throw new CaptureConfigError("daemon requires a bearer token");
+  }
+  return (req, res) => {
+    try {
+      const presented = bearerFromHeader(req.headers["authorization"]);
+      if (!presented || !tokensMatch(deps.token, presented)) {
+        sendJson(res, 401, { error: "unauthorized" });
+        return;
+      }
+      if (req.method !== "GET") {
+        sendJson(res, 405, { error: "method not allowed" });
+        return;
+      }
+      const url = new URL(req.url ?? "/", "http://localhost");
+      switch (url.pathname) {
+        case "/v1/health":
+          handleHealth(deps, res);
+          return;
+        case "/v1/conversations":
+          handleConversations(deps, url, res);
+          return;
+        case "/v1/speakers":
+          handleSpeakers(deps, res);
+          return;
+        default:
+          sendJson(res, 404, { error: "not found" });
+      }
+    } catch (err) {
+      if (err instanceof CaptureInputError) {
+        sendJson(res, 400, { error: err.message });
+        return;
+      }
+      sendJson(res, 500, { error: "internal error" });
+    }
+  };
+}
+function startDaemon(deps) {
+  return new Promise((resolve, reject) => {
+    let handler;
+    try {
+      handler = createRequestHandler(deps);
+    } catch (err) {
+      reject(err);
+      return;
+    }
+    const server = http.createServer(handler);
+    const onError = (err) => reject(err);
+    server.once("error", onError);
+    server.listen(deps.config.port, deps.config.host, () => {
+      server.removeListener("error", onError);
+      server.on("error", (err) => {
+        process.stderr.write(`capture-audio daemon server error: ${err.code ?? err.name}
+`);
+      });
+      const address = server.address();
+      const port = typeof address === "object" && address ? address.port : deps.config.port;
+      const host = deps.config.host;
+      resolve({
+        server,
+        host,
+        port,
+        url: `http://${formatHostForUrl(host)}:${port}`,
+        close: () => new Promise((res2, rej2) => {
+          server.close((closeErr) => closeErr ? rej2(closeErr) : res2());
+        })
+      });
+    });
+  });
+}
+
+// src/paths.ts
+import os from "os";
+import path3 from "path";
+function expandTilde(value) {
+  if (value === "~") return os.homedir();
+  if (value.startsWith("~/")) return path3.join(os.homedir(), value.slice(2));
+  return value;
+}
+function captureBaseDir(env = process.env) {
+  const override = env.REMNIC_CAPTURE_DIR?.trim();
+  if (override) return expandTilde(override);
+  return path3.join(os.homedir(), ".remnic", "capture");
+}
+function capturePaths(baseDir = captureBaseDir()) {
+  return {
+    baseDir,
+    configPath: path3.join(baseDir, "audio.json"),
+    spoolPath: path3.join(baseDir, "audio.sqlite"),
+    tokenPath: path3.join(baseDir, "token"),
+    pidPath: path3.join(baseDir, "daemon.pid"),
+    logPath: path3.join(baseDir, "daemon.log")
+  };
+}
+
+// src/replay.ts
+import { createHash } from "crypto";
+import { lstatSync, readdirSync, readFileSync as readFileSync4 } from "fs";
+import path4 from "path";
+function asObject2(value, where) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new CaptureConfigError(`${where}: expected a conversation object`);
+  }
+  return value;
+}
+var REPLAY_INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d{1,9})?)?(Z|[+-]\d{2}:\d{2})$/;
+function parseTimestamp(value, where) {
+  if (typeof value !== "string" || !REPLAY_INSTANT.test(value)) {
+    throw new CaptureConfigError(`${where}: expected an ISO instant with a Z or numeric offset`);
+  }
+  const ms = Date.parse(value);
+  if (!Number.isFinite(ms)) {
+    throw new CaptureConfigError(`${where}: expected a valid ISO timestamp`);
+  }
+  const [cy, cm, cd] = value.slice(0, 10).split("-").map(Number);
+  const probe = new Date(Date.UTC(cy, cm - 1, cd));
+  probe.setUTCFullYear(cy);
+  if (probe.getUTCFullYear() !== cy || probe.getUTCMonth() !== cm - 1 || probe.getUTCDate() !== cd) {
+    throw new CaptureConfigError(`${where}: '${value}' is not a real calendar date`);
+  }
+  return new Date(ms).toISOString();
+}
+function optionalString(value, where, fallback) {
+  if (value === void 0) return fallback;
+  if (typeof value !== "string") throw new CaptureConfigError(`${where}: expected a string`);
+  return value;
+}
+function parseSegment(raw, where) {
+  const obj = asObject2(raw, where);
+  if (typeof obj.text !== "string" || obj.text === "") {
+    throw new CaptureConfigError(`${where}.text: expected a non-empty string`);
+  }
+  const startUtc = parseTimestamp(obj.startUtc, `${where}.startUtc`);
+  const endUtc = parseTimestamp(obj.endUtc, `${where}.endUtc`);
+  if (Date.parse(endUtc) < Date.parse(startUtc)) {
+    throw new CaptureConfigError(`${where}: endUtc must not precede startUtc`);
+  }
+  if (obj.isWearer !== void 0 && typeof obj.isWearer !== "boolean") {
+    throw new CaptureConfigError(`${where}.isWearer: expected a boolean`);
+  }
+  const channel = obj.channel === void 0 ? "mic" : obj.channel;
+  if (typeof channel !== "string" || channel === "") {
+    throw new CaptureConfigError(`${where}.channel: expected a non-empty string`);
+  }
+  return {
+    speakerCluster: optionalString(obj.speakerCluster, `${where}.speakerCluster`, null),
+    isWearer: obj.isWearer === true,
+    channel,
+    text: obj.text,
+    startUtc,
+    endUtc
+  };
+}
+function parseConversation(raw, where) {
+  const obj = asObject2(raw, where);
+  const startedAtUtc = parseTimestamp(obj.startedAtUtc, `${where}.startedAtUtc`);
+  const endedAtUtc = obj.endedAtUtc === void 0 ? null : parseTimestamp(obj.endedAtUtc, `${where}.endedAtUtc`);
+  if (endedAtUtc !== null && Date.parse(endedAtUtc) < Date.parse(startedAtUtc)) {
+    throw new CaptureConfigError(`${where}: endedAtUtc must not precede startedAtUtc`);
+  }
+  if (obj.state !== void 0 && obj.state !== "capturing" && obj.state !== "final") {
+    throw new CaptureConfigError(`${where}.state: expected "capturing" or "final"`);
+  }
+  if (obj.id !== void 0 && (typeof obj.id !== "string" || obj.id === "")) {
+    throw new CaptureConfigError(`${where}.id: expected a non-empty string`);
+  }
+  if (!Array.isArray(obj.segments)) {
+    throw new CaptureConfigError(`${where}.segments: expected an array`);
+  }
+  return {
+    id: obj.id === void 0 ? void 0 : obj.id,
+    startedAtUtc,
+    endedAtUtc,
+    state: obj.state ?? "final",
+    device: optionalString(obj.device, `${where}.device`, null),
+    segments: obj.segments.map((seg, i) => parseSegment(seg, `${where}.segments[${i}]`))
+  };
+}
+function parseSpeakers(raw, where) {
+  if (raw === void 0) return [];
+  if (!Array.isArray(raw)) {
+    throw new CaptureConfigError(`${where}.speakers: expected an array`);
+  }
+  return raw.map((entry, i) => {
+    const obj = asObject2(entry, `${where}.speakers[${i}]`);
+    if (typeof obj.id !== "string" || obj.id === "") {
+      throw new CaptureConfigError(`${where}.speakers[${i}].id: expected a non-empty string`);
+    }
+    if (obj.isSelf !== void 0 && typeof obj.isSelf !== "boolean") {
+      throw new CaptureConfigError(`${where}.speakers[${i}].isSelf: expected a boolean`);
+    }
+    const speaker = { id: obj.id };
+    if (obj.label !== void 0) {
+      speaker.label = optionalString(obj.label, `${where}.speakers[${i}].label`, null);
+    }
+    if (obj.isSelf !== void 0) {
+      speaker.isSelf = obj.isSelf === true;
+    }
+    return speaker;
+  });
+}
+function listReplayFixtureFiles(dir) {
+  let entries;
+  try {
+    if (lstatSync(dir).isSymbolicLink()) {
+      throw new CaptureConfigError(`replay dir ${dir} is a symlink; refusing to follow it`);
+    }
+    entries = readdirSync(dir).filter((name) => name.endsWith(".json")).sort();
+  } catch (err) {
+    if (err instanceof CaptureConfigError) throw err;
+    throw new CaptureConfigError(`replay dir not found or unreadable: ${dir}`);
+  }
+  if (entries.length === 0) {
+    throw new CaptureConfigError(`replay dir ${dir} contains no *.json fixtures`);
+  }
+  return entries;
+}
+function parseReplayFile(dir, name, seenIds, fixtures) {
+  const filePath = path4.join(dir, name);
+  if (lstatSync(filePath).isSymbolicLink()) {
+    throw new CaptureConfigError(`replay fixture ${name} is a symlink; refusing to follow it`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync4(filePath, "utf8"));
+  } catch (err) {
+    throw new CaptureConfigError(`replay fixture ${name} is not valid JSON: ${err.message}`);
+  }
+  const docs = Array.isArray(raw) ? raw : [raw];
+  docs.forEach((doc, i) => {
+    const where = `${name}[${i}]`;
+    const conv = parseConversation(doc, where);
+    if (conv.id === void 0) {
+      const material = JSON.stringify({
+        startedAtUtc: conv.startedAtUtc,
+        endedAtUtc: conv.endedAtUtc,
+        state: conv.state,
+        segments: conv.segments
+      });
+      conv.id = `conv_${createHash("sha1").update(material).digest("hex").slice(0, 24)}`;
+    }
+    if (seenIds.has(conv.id)) {
+      throw new CaptureConfigError(`${where}: duplicate conversation id '${conv.id}' in this replay batch`);
+    }
+    seenIds.add(conv.id);
+    const speakers = parseSpeakers(asObject2(doc, where).speakers, where);
+    fixtures.push({ speakers, conv });
+  });
+}
+function parseReplayDir(dir) {
+  const entries = listReplayFixtureFiles(dir);
+  const fixtures = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const name of entries) parseReplayFile(dir, name, seenIds, fixtures);
+  return { fixtures, files: entries.length };
+}
+function commitFixture(spool, fixture, result) {
+  for (const speaker of fixture.speakers) spool.upsertSpeaker(speaker);
+  const id = spool.insertConversation(fixture.conv);
+  result.ids.push(id);
+  result.conversationsIngested += 1;
+  result.segmentsIngested += fixture.conv.segments.length;
+}
+var REPLAY_COMMIT_BATCH = 25;
+function ingestReplayDir(spool, dir) {
+  const { fixtures, files } = parseReplayDir(dir);
+  const result = { files, conversationsIngested: 0, segmentsIngested: 0, ids: [], aborted: false };
+  for (const fixture of fixtures) commitFixture(spool, fixture, result);
+  return result;
+}
+async function ingestReplayDirResponsive(spool, dir, options = {}) {
+  const entries = listReplayFixtureFiles(dir);
+  const fixtures = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const name of entries) {
+    if (options.signal?.aborted) {
+      return { files: entries.length, conversationsIngested: 0, segmentsIngested: 0, ids: [], aborted: true };
+    }
+    parseReplayFile(dir, name, seenIds, fixtures);
+    await new Promise((resolve) => setImmediate(resolve));
+  }
+  const files = entries.length;
+  const result = { files, conversationsIngested: 0, segmentsIngested: 0, ids: [], aborted: false };
+  for (let i = 0; i < fixtures.length; i += REPLAY_COMMIT_BATCH) {
+    if (options.signal?.aborted) {
+      result.aborted = true;
+      break;
+    }
+    for (const fixture of fixtures.slice(i, i + REPLAY_COMMIT_BATCH)) {
+      commitFixture(spool, fixture, result);
+    }
+    await new Promise((resolve) => setImmediate(resolve));
+  }
+  return result;
+}
+
+// src/model.ts
+import { createWriteStream, lstatSync as lstatSync2, statSync } from "fs";
+import { mkdir, rename, rm } from "fs/promises";
+import path5 from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+var MODEL_FILES = {
+  base: "ggml-base.bin",
+  small: "ggml-small.bin",
+  "large-v3-turbo-q5_0": "ggml-large-v3-turbo-q5_0.bin"
+};
+var MODEL_REPOSITORY = "https://huggingface.co/ggerganov/whisper.cpp/resolve/main";
+function responseBodyToReadable(body) {
+  const reader = body.getReader();
+  return new Readable({
+    read() {
+      void reader.read().then(({ done, value }) => this.push(done ? null : Buffer.from(value))).catch((error) => this.destroy(error));
+    }
+  });
+}
+function existingFile(destination) {
+  let entry;
+  try {
+    entry = statSync(destination);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    try {
+      lstatSync2(destination);
+    } catch (linkError) {
+      if (linkError.code === "ENOENT") return false;
+      throw linkError;
+    }
+    throw new CaptureConfigError(`Whisper model path is a broken symlink: ${destination}; remove it and retry`);
+  }
+  if (!entry.isFile()) {
+    throw new CaptureConfigError(`Whisper model path exists but is not a regular file: ${destination}`);
+  }
+  return true;
+}
+function whisperModelUrl(model) {
+  if (!Object.hasOwn(MODEL_FILES, model)) {
+    throw new CaptureConfigError(`unknown Whisper model '${model}'; expected one of ${Object.keys(MODEL_FILES).join(", ")}`);
+  }
+  const file = MODEL_FILES[model];
+  return `${MODEL_REPOSITORY}/${file}`;
+}
+async function downloadWhisperModel(input) {
+  const url = whisperModelUrl(input.model);
+  const filename = new URL(url).pathname.split("/").at(-1);
+  if (!filename) throw new CaptureConfigError("Whisper model URL has no filename");
+  await mkdir(input.directory, { recursive: true });
+  const destination = path5.join(input.directory, filename);
+  if (existingFile(destination)) return { path: destination, downloaded: false };
+  let response;
+  try {
+    response = await (input.fetch ?? ((value) => fetch(value)))(url);
+  } catch {
+    throw new CaptureConfigError(
+      `failed to download ${input.model}: the network request to Hugging Face failed (check connectivity/proxy/DNS)`
+    );
+  }
+  if (!response.ok || !response.body) {
+    throw new CaptureConfigError(`failed to download ${input.model}: HTTP ${response.status}`);
+  }
+  const temporary = path5.join(input.directory, `.${filename}.${process.pid}.${crypto.randomUUID()}.tmp`);
+  try {
+    await pipeline(responseBodyToReadable(response.body), createWriteStream(temporary, { flags: "wx", mode: 384 }));
+    await rename(temporary, destination);
+    return { path: destination, downloaded: true };
+  } catch (error) {
+    await rm(temporary, { force: true });
+    throw error;
+  }
+}
+
+// src/janitor.ts
+import { lstat, readdir, rm as rm2 } from "fs/promises";
+import path6 from "path";
+async function pruneExpiredRawAudio(rawDirectory, retentionMs, nowMs = Date.now()) {
+  if (!Number.isFinite(retentionMs) || retentionMs < 0) {
+    throw new CaptureConfigError("raw audio retention must be a non-negative duration");
+  }
+  const cutoffMs = nowMs - retentionMs;
+  let root;
+  try {
+    root = await lstat(rawDirectory);
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  if (root.isSymbolicLink() || !root.isDirectory()) {
+    throw new CaptureConfigError("raw audio directory must be a non-symlink directory");
+  }
+  const entries = await readdir(rawDirectory, { withFileTypes: true });
+  const removed = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    const location = path6.join(rawDirectory, entry.name);
+    try {
+      const stat = await lstat(location);
+      if (!stat.isFile()) continue;
+      if (stat.mtimeMs <= cutoffMs) {
+        await rm2(location);
+        removed.push(location);
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      throw error;
+    }
+  }
+  return removed.sort();
+}
+
+// src/spool.ts
+import { chmodSync as chmodSync2 } from "fs";
+import { DatabaseSync } from "sqlite";
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS conversations (
+  id TEXT PRIMARY KEY,
+  started_at_utc TEXT NOT NULL,
+  ended_at_utc TEXT,
+  state TEXT NOT NULL,
+  segment_count INTEGER NOT NULL DEFAULT 0
+);
+CREATE TABLE IF NOT EXISTS chunks (
+  id TEXT PRIMARY KEY,
+  channel TEXT NOT NULL,
+  device TEXT,
+  started_at_utc TEXT NOT NULL,
+  ended_at_utc TEXT NOT NULL,
+  status TEXT NOT NULL,
+  wav_path TEXT
+);
+CREATE TABLE IF NOT EXISTS segments (
+  id TEXT PRIMARY KEY,
+  chunk_id TEXT REFERENCES chunks(id) ON DELETE CASCADE,
+  conversation_id TEXT REFERENCES conversations(id) ON DELETE CASCADE,
+  speaker_cluster TEXT,
+  is_wearer INTEGER NOT NULL DEFAULT 0,
+  channel TEXT NOT NULL,
+  text TEXT NOT NULL,
+  start_utc TEXT NOT NULL,
+  end_utc TEXT NOT NULL,
+  ordinal INTEGER NOT NULL DEFAULT 0
+);
+CREATE TABLE IF NOT EXISTS speaker_clusters (
+  id TEXT PRIMARY KEY,
+  label TEXT,
+  centroid BLOB,
+  example_embeddings BLOB,
+  embedding_count INTEGER NOT NULL DEFAULT 0,
+  is_self INTEGER NOT NULL DEFAULT 0
+);
+CREATE TABLE IF NOT EXISTS applied_chunks (
+  idempotency_key TEXT PRIMARY KEY,
+  conversation_id TEXT NOT NULL,
+  applied_at_utc TEXT NOT NULL
+);
+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);
+`;
+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;
+  if (!match || !Number.isFinite(Date.parse(value))) {
+    throw new CaptureConfigError(
+      `${label}: '${value}' is not a canonical ISO instant (need date, time, and Z or offset)`
+    );
+  }
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const probe = new Date(Date.UTC(year, month - 1, day));
+  probe.setUTCFullYear(year);
+  if (probe.getUTCFullYear() !== year || probe.getUTCMonth() !== month - 1 || probe.getUTCDate() !== day) {
+    throw new CaptureConfigError(`${label}: '${value}' is not a real calendar date`);
+  }
+}
+function canonicalInstant(value, label) {
+  assertIsoInstant(value, label);
+  return new Date(value).toISOString();
+}
+var CONVERSATION_STATES = { capturing: true, final: true };
+var CHUNK_STATUSES = {
+  pending: true,
+  transcribed: true,
+  failed: true,
+  deleted: true
+};
+var Spool = class {
+  #db;
+  #closed = false;
+  constructor(location) {
+    this.#db = new DatabaseSync(location);
+    this.#db.exec("PRAGMA journal_mode = WAL;");
+    this.#db.exec("PRAGMA foreign_keys = ON;");
+    this.#db.exec("PRAGMA busy_timeout = 5000;");
+    this.#db.exec(SCHEMA_SQL);
+    if (location !== ":memory:") {
+      try {
+        chmodSync2(location, 384);
+      } catch {
+      }
+    }
+    this.#db.prepare("INSERT OR IGNORE INTO meta(key, value) VALUES (?, ?)").run("schema_version", String(SPOOL_SCHEMA_VERSION));
+    this.#db.prepare("INSERT OR IGNORE INTO meta(key, value) VALUES (?, ?)").run("instance_id", ulid());
+  }
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#db.close();
+  }
+  meta(key) {
+    const row = this.#db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  setMeta(key, value) {
+    this.#db.prepare("INSERT INTO meta(key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
+  }
+  /**
+   * Insert (or replace) a whole conversation with its segments and a
+   * backing chunk row, atomically. Idempotent by conversation id:
+   * re-ingesting the same id deletes the prior rows first, so a repeated
+   * replay is a content no-op (kill-9 restart safety, acceptance criteria).
+   */
+  insertConversation(input) {
+    if (typeof input.startedAtUtc !== "string" || input.startedAtUtc.trim() === "") {
+      throw new CaptureConfigError("conversation.startedAtUtc: expected a non-empty ISO timestamp");
+    }
+    if (!Array.isArray(input.segments)) {
+      throw new CaptureConfigError("conversation.segments: expected an array");
+    }
+    const startedAtUtc = canonicalInstant(input.startedAtUtc, "conversation.startedAtUtc");
+    const endedAtUtcInput = input.endedAtUtc !== void 0 && input.endedAtUtc !== null ? canonicalInstant(input.endedAtUtc, "conversation.endedAtUtc") : null;
+    if (endedAtUtcInput !== null && Date.parse(endedAtUtcInput) < Date.parse(startedAtUtc)) {
+      throw new CaptureConfigError("conversation.endedAtUtc: must not precede startedAtUtc");
+    }
+    if (input.state !== void 0 && !Object.hasOwn(CONVERSATION_STATES, input.state)) {
+      throw new CaptureConfigError(`conversation.state: unknown value '${input.state}'`);
+    }
+    if (input.chunkStatus !== void 0 && !Object.hasOwn(CHUNK_STATUSES, input.chunkStatus)) {
+      throw new CaptureConfigError(`conversation.chunkStatus: unknown value '${input.chunkStatus}'`);
+    }
+    const segments = input.segments.map((seg, i) => {
+      const startUtc = canonicalInstant(seg.startUtc, `conversation.segments[${i}].startUtc`);
+      const endUtc = canonicalInstant(seg.endUtc, `conversation.segments[${i}].endUtc`);
+      if (Date.parse(endUtc) < Date.parse(startUtc)) {
+        throw new CaptureConfigError(`conversation.segments[${i}]: endUtc must not precede startUtc`);
+      }
+      if (typeof seg.text !== "string" || seg.text === "") {
+        throw new CaptureConfigError(`conversation.segments[${i}].text: expected a non-empty string`);
+      }
+      return { ...seg, startUtc, endUtc };
+    });
+    const convId = input.id ?? `conv_${ulid()}`;
+    const chunkId = `chk_${convId}`;
+    const state = input.state ?? "final";
+    const chunkStatus = input.chunkStatus ?? "transcribed";
+    const wavPath = input.wavPath ?? null;
+    const endedAtUtc = endedAtUtcInput ?? segments[segments.length - 1]?.endUtc ?? startedAtUtc;
+    const chunkChannel = segments[0]?.channel ?? "mic";
+    const db = this.#db;
+    db.exec("BEGIN");
+    try {
+      db.prepare("DELETE FROM conversations WHERE id = ?").run(convId);
+      db.prepare("DELETE FROM chunks WHERE id = ?").run(chunkId);
+      db.prepare(
+        "INSERT INTO chunks(id, channel, device, started_at_utc, ended_at_utc, status, wav_path) VALUES (?,?,?,?,?,?,?)"
+      ).run(chunkId, chunkChannel, input.device ?? null, startedAtUtc, endedAtUtc, chunkStatus, wavPath);
+      db.prepare(
+        "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 (?,?,?,?,?,?,?,?,?,?)"
+      );
+      for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        segStmt.run(
+          `seg_${ulid()}`,
+          chunkId,
+          convId,
+          seg.speakerCluster ?? null,
+          seg.isWearer ? 1 : 0,
+          seg.channel,
+          seg.text,
+          seg.startUtc,
+          seg.endUtc,
+          i
+        );
+      }
+      db.exec("COMMIT");
+    } catch (err) {
+      db.exec("ROLLBACK");
+      throw err;
+    }
+    return convId;
+  }
+  /** Flip every still-open conversation to `final` (daemon stop / gap timeout). */
+  finalizeOpenConversations() {
+    const result = this.#db.prepare("UPDATE conversations SET state = 'final' WHERE state = 'capturing'").run();
+    return Number(result.changes);
+  }
+  /**
+   * Durably append one transcribed chunk's segments to a conversation,
+   * idempotent on `idempotencyKey` (a replay/restart of the same chunk is a
+   * no-op). Creates the conversation as `capturing` on first append; a later
+   * `finalizeConversation`/`finalizeOpenConversations` flips it to `final`.
+   */
+  appendAssembledSegments(input) {
+    if (typeof input.idempotencyKey !== "string" || input.idempotencyKey.trim() === "") {
+      throw new CaptureConfigError("appendAssembledSegments.idempotencyKey: expected a non-empty string");
+    }
+    if (typeof input.conversationId !== "string" || input.conversationId.trim() === "") {
+      throw new CaptureConfigError("appendAssembledSegments.conversationId: expected a non-empty string");
+    }
+    if (typeof input.startedAtUtc !== "string" || input.startedAtUtc.trim() === "") {
+      throw new CaptureConfigError("appendAssembledSegments.startedAtUtc: expected a non-empty ISO timestamp");
+    }
+    if (!Array.isArray(input.segments) || input.segments.length === 0) {
+      throw new CaptureConfigError("appendAssembledSegments.segments: expected a non-empty array");
+    }
+    if (input.state !== void 0 && !Object.hasOwn(CONVERSATION_STATES, input.state)) {
+      throw new CaptureConfigError(`appendAssembledSegments.state: unknown value '${input.state}'`);
+    }
+    const startedAtUtc = canonicalInstant(input.startedAtUtc, "appendAssembledSegments.startedAtUtc");
+    const segments = input.segments.map((seg, i) => {
+      const startUtc = canonicalInstant(seg.startUtc, `appendAssembledSegments.segments[${i}].startUtc`);
+      const endUtc = canonicalInstant(seg.endUtc, `appendAssembledSegments.segments[${i}].endUtc`);
+      if (Date.parse(endUtc) < Date.parse(startUtc)) {
+        throw new CaptureConfigError(`appendAssembledSegments.segments[${i}]: endUtc must not precede startUtc`);
+      }
+      if (typeof seg.text !== "string" || seg.text === "") {
+        throw new CaptureConfigError(`appendAssembledSegments.segments[${i}].text: expected a non-empty string`);
+      }
+      return { ...seg, startUtc, endUtc };
+    });
+    const convId = input.conversationId;
+    const chunkId = input.chunkId ?? input.idempotencyKey;
+    const state = input.state ?? "capturing";
+    const chunkChannel = segments[0]?.channel ?? "mic";
+    const lastEnd = segments[segments.length - 1].endUtc;
+    const chunkStart = segments[0].startUtc;
+    const db = this.#db;
+    db.exec("BEGIN");
+    try {
+      const seen = db.prepare("SELECT conversation_id AS conversationId FROM applied_chunks WHERE idempotency_key = ?").get(input.idempotencyKey);
+      if (seen) {
+        db.exec("COMMIT");
+        return { applied: false, conversationId: seen.conversationId, segmentCount: this.#segmentCount(seen.conversationId) };
+      }
+      db.prepare(
+        "INSERT OR IGNORE INTO chunks(id, channel, device, started_at_utc, ended_at_utc, status, wav_path) VALUES (?,?,?,?,?,?,?)"
+      ).run(chunkId, chunkChannel, input.device ?? null, chunkStart, lastEnd, "transcribed", input.wavPath ?? null);
+      const existing = db.prepare("SELECT id FROM conversations WHERE id = ?").get(convId);
+      if (!existing) {
+        db.prepare(
+          "INSERT INTO conversations(id, started_at_utc, ended_at_utc, state, segment_count) VALUES (?,?,?,?,0)"
+        ).run(convId, startedAtUtc, lastEnd, state);
+      }
+      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 (?,?,?,?,?,?,?,?,?,?)"
+      );
+      for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        segStmt.run(
+          `seg_${ulid()}`,
+          chunkId,
+          convId,
+          seg.speakerCluster ?? null,
+          seg.isWearer ? 1 : 0,
+          seg.channel,
+          seg.text,
+          seg.startUtc,
+          seg.endUtc,
+          nextOrdinal + i
+        );
+      }
+      db.prepare(
+        "UPDATE conversations SET segment_count = segment_count + ?, ended_at_utc = CASE WHEN ended_at_utc IS NULL OR ? > ended_at_utc THEN ? ELSE ended_at_utc END WHERE id = ?"
+      ).run(segments.length, lastEnd, lastEnd, convId);
+      db.prepare("INSERT INTO applied_chunks(idempotency_key, conversation_id, applied_at_utc) VALUES (?,?,?)").run(
+        input.idempotencyKey,
+        convId,
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+      db.exec("COMMIT");
+    } catch (err) {
+      db.exec("ROLLBACK");
+      throw err;
+    }
+    return { applied: true, conversationId: convId, segmentCount: this.#segmentCount(convId) };
+  }
+  /** Flip one conversation to `final`; returns true when it was capturing. */
+  finalizeConversation(id) {
+    const result = this.#db.prepare("UPDATE conversations SET state = 'final' WHERE id = ? AND state = 'capturing'").run(id);
+    return Number(result.changes) > 0;
+  }
+  /**
+   * A conversation's segments in the shape cross-channel dedup needs (segment
+   * id + DedupSegment fields), chronological. Used to prune loopback duplicates
+   * at finalization, which is order-independent (all segments are present).
+   */
+  conversationSegmentsForDedup(conversationId) {
+    return this.#db.prepare(
+      "SELECT id, channel, text, start_utc AS startUtc, end_utc AS endUtc FROM segments WHERE conversation_id = ? ORDER BY start_utc ASC, ordinal ASC, id ASC"
+    ).all(conversationId);
+  }
+  /**
+   * Delete specific segments (dedup prune), keeping each owning conversation's
+   * segment_count in sync. Returns the number actually removed.
+   */
+  deleteSegments(ids) {
+    if (ids.length === 0) return 0;
+    const db = this.#db;
+    let removed = 0;
+    db.exec("BEGIN");
+    try {
+      const findConv = db.prepare("SELECT conversation_id AS conversationId FROM segments WHERE id = ?");
+      const del = db.prepare("DELETE FROM segments WHERE id = ?");
+      const dec = db.prepare("UPDATE conversations SET segment_count = MAX(segment_count - 1, 0) WHERE id = ?");
+      const affected = /* @__PURE__ */ new Set();
+      for (const id of ids) {
+        const row = findConv.get(id);
+        if (!row) continue;
+        if (Number(del.run(id).changes) > 0) {
+          dec.run(row.conversationId);
+          affected.add(row.conversationId);
+          removed++;
+        }
+      }
+      const bounds = db.prepare(
+        "SELECT MIN(start_utc) AS minStart, MAX(end_utc) AS maxEnd FROM segments WHERE conversation_id = ?"
+      );
+      const setBounds = db.prepare("UPDATE conversations SET started_at_utc = ?, ended_at_utc = ? WHERE id = ?");
+      for (const convId of affected) {
+        const b = bounds.get(convId);
+        if (b.minStart !== null && b.maxEnd !== null) setBounds.run(b.minStart, b.maxEnd, convId);
+      }
+      db.exec("COMMIT");
+    } catch (err) {
+      db.exec("ROLLBACK");
+      throw err;
+    }
+    return removed;
+  }
+  /** 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);
+  }
+  /** 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;
+  }
+  /**
+   * Record that a whole chunk finished (every group appended) via a `<id>:done`
+   * marker, so a later full replay can skip transcription + diarization. A crash
+   * before this leaves no marker, so the missing groups re-append on replay.
+   */
+  markChunkComplete(chunkId, conversationId) {
+    this.#db.prepare("INSERT OR IGNORE INTO applied_chunks(idempotency_key, conversation_id, applied_at_utc) VALUES (?,?,?)").run(`${chunkId}:done`, conversationId, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  /**
+   * The newest still-`capturing` conversation, so a chunk arriving after a
+   * process restart continues it (subject to the assembler's gap rule) instead
+   * of splitting off a new one. Null when none is open.
+   */
+  latestCapturingConversation() {
+    const row = this.#db.prepare(
+      "SELECT id, started_at_utc AS startedAtUtc, ended_at_utc AS endedAtUtc FROM conversations WHERE state = 'capturing' ORDER BY ended_at_utc DESC, id DESC LIMIT 1"
+    ).get();
+    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) {
+    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);
+    const label = Object.hasOwn(input, "label") ? input.label ?? null : current?.label ?? null;
+    const embeddingCount = Object.hasOwn(input, "embeddingCount") ? input.embeddingCount ?? 0 : current?.embeddingCount ?? 0;
+    const isSelf = Object.hasOwn(input, "isSelf") ? input.isSelf ? 1 : 0 : current?.isSelf ?? 0;
+    const centroid = Object.hasOwn(input, "centroid") ? input.centroid ? Buffer.from(JSON.stringify(input.centroid)) : null : current?.centroid ?? null;
+    const examples = Object.hasOwn(input, "examples") ? input.examples ? Buffer.from(JSON.stringify(input.examples)) : null : current?.examples ?? null;
+    this.#db.prepare(
+      "INSERT INTO speaker_clusters(id, label, embedding_count, is_self, centroid, example_embeddings) VALUES (?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET label = excluded.label, is_self = excluded.is_self, embedding_count = excluded.embedding_count, centroid = excluded.centroid, example_embeddings = excluded.example_embeddings"
+    ).run(input.id, label, embeddingCount, isSelf, centroid, examples);
+  }
+  /** Read every speaker cluster with decoded centroid + examples (diarization restart seed). */
+  readSpeakerClusters() {
+    const rows = this.#db.prepare(
+      "SELECT id, label, is_self AS isSelf, embedding_count AS embeddingCount, centroid, example_embeddings AS examples FROM speaker_clusters ORDER BY id ASC"
+    ).all();
+    const decode = (blob) => {
+      if (!blob || blob.byteLength === 0) return null;
+      try {
+        return JSON.parse(Buffer.from(blob).toString("utf8"));
+      } catch {
+        return null;
+      }
+    };
+    return rows.map((r) => {
+      const centroid = decode(r.centroid);
+      const examples = decode(r.examples);
+      return {
+        id: r.id,
+        label: r.label,
+        isSelf: r.isSelf === 1,
+        embeddingCount: r.embeddingCount,
+        centroid: Array.isArray(centroid) ? centroid : [],
+        examples: Array.isArray(examples) ? examples : []
+      };
+    });
+  }
+  listSpeakers() {
+    const rows = this.#db.prepare("SELECT id, label, is_self AS isSelf, embedding_count AS embeddingCount FROM speaker_clusters ORDER BY id ASC").all();
+    return rows.map((r) => ({ id: r.id, label: r.label, isSelf: r.isSelf === 1, embeddingCount: r.embeddingCount }));
+  }
+  pendingChunkCount() {
+    const row = this.#db.prepare("SELECT COUNT(*) AS n FROM chunks WHERE status = 'pending'").get();
+    return row.n;
+  }
+  stats() {
+    const count = (table) => this.#db.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get().n;
+    return { conversations: count("conversations"), segments: count("segments"), chunks: count("chunks") };
+  }
+  getConversation(id) {
+    const row = this.#db.prepare(
+      "SELECT id, started_at_utc AS startedAtUtc, ended_at_utc AS endedAtUtc, state, segment_count AS segmentCount FROM conversations WHERE id = ?"
+    ).get(id);
+    return row ? this.#hydrate(row) : null;
+  }
+  /**
+   * Final conversations whose local day (per `timezone`) equals `date`,
+   * paged by the stable (started_at_utc, id) keyset. Fetches all final
+   * rows after the cursor (the spool is a bounded buffer, not an archive),
+   * filters to the requested local day, then pages — so the id tiebreak
+   * keeps pagination correct across duplicate start timestamps.
+   */
+  queryFinalConversations(opts) {
+    const cursor = decodeCursor(opts.cursor ?? null);
+    const afterStarted = cursor ? cursor.startedAtUtc : "";
+    const afterId = cursor ? cursor.id : "";
+    const rows = this.#db.prepare(
+      "SELECT id, started_at_utc AS startedAtUtc, ended_at_utc AS endedAtUtc, state, segment_count AS segmentCount FROM conversations WHERE state = 'final' AND (started_at_utc > ? OR (started_at_utc = ? AND id > ?)) ORDER BY started_at_utc ASC, id ASC"
+    ).all(afterStarted, afterStarted, afterId);
+    const matches = [];
+    for (const row of rows) {
+      if (dateInTimezone(new Date(row.startedAtUtc), opts.timezone) === opts.date) {
+        matches.push(row);
+        if (matches.length > opts.limit) break;
+      }
+    }
+    const hasMore = matches.length > opts.limit;
+    const page = hasMore ? matches.slice(0, opts.limit) : matches;
+    const last = page[page.length - 1];
+    return {
+      conversations: page.map((row) => this.#hydrate(row)),
+      nextCursor: hasMore && last ? encodeCursor(last.startedAtUtc, last.id) : null
+    };
+  }
+  #hydrate(row) {
+    const segs = this.#db.prepare(
+      "SELECT text, speaker_cluster AS speakerKey, is_wearer AS isWearer, channel, start_utc AS startUtc, end_utc AS endUtc FROM segments WHERE conversation_id = ? ORDER BY start_utc ASC, ordinal ASC, id ASC"
+    ).all(row.id);
+    return {
+      id: row.id,
+      startedAtUtc: row.startedAtUtc,
+      endedAtUtc: row.endedAtUtc,
+      state: row.state,
+      segmentCount: row.segmentCount,
+      segments: segs.map((s) => ({
+        textRaw: s.text,
+        speakerKey: s.speakerKey,
+        isWearer: s.isWearer === 1,
+        channel: s.channel,
+        startUtc: s.startUtc,
+        endUtc: s.endUtc
+      }))
+    };
+  }
+};
+
+// src/assembly.ts
+function assembleConversations(segments, gapMinutes, state = "final") {
+  if (!Number.isFinite(gapMinutes) || gapMinutes < 0) {
+    throw new Error("assembleConversations: gapMinutes must be a non-negative number");
+  }
+  const gapMs = gapMinutes * 6e4;
+  const conversations = [];
+  let current = [];
+  let prevEndMs = Number.NaN;
+  const flush = () => {
+    if (current.length === 0) return;
+    const startedAtUtc = current[0].startUtc;
+    const endedAtUtc = current[current.length - 1].endUtc;
+    conversations.push({ startedAtUtc, endedAtUtc, state, segments: current });
+    current = [];
+  };
+  for (const seg of segments) {
+    const startMs = Date.parse(seg.startUtc);
+    if (current.length > 0 && Number.isFinite(prevEndMs) && Number.isFinite(startMs) && startMs - prevEndMs >= gapMs) {
+      flush();
+    }
+    current.push(seg);
+    const endMs = Date.parse(seg.endUtc);
+    prevEndMs = Number.isFinite(endMs) ? endMs : startMs;
+  }
+  flush();
+  return conversations;
+}
+var DEFAULT_CONVERSATION_GAP_MINUTES = 10;
+function epochMs(value, field) {
+  const ms = Date.parse(value);
+  if (!Number.isFinite(ms)) {
+    throw new CaptureInputError(`segment.${field}: expected an ISO-8601 timestamp`);
+  }
+  return ms;
+}
+var ConversationAssembler = class {
+  #gapMs;
+  #makeId;
+  #conversations = [];
+  constructor(options = {}) {
+    const gapMinutes = options.gapMinutes ?? DEFAULT_CONVERSATION_GAP_MINUTES;
+    if (!Number.isFinite(gapMinutes) || gapMinutes < 0) {
+      throw new CaptureConfigError("conversationGapMinutes must be a non-negative number");
+    }
+    this.#gapMs = gapMinutes * 6e4;
+    this.#makeId = options.makeId ?? (() => `conv_${ulid()}`);
+  }
+  /**
+   * Append one segment, returning the conversation it landed in. Segments
+   * arrive in non-decreasing start order; a gap of at least the threshold
+   * closes the open conversation and starts a new one.
+   */
+  add(segment) {
+    const startMs = epochMs(segment.startUtc, "startUtc");
+    epochMs(segment.endUtc, "endUtc");
+    const open = this.#open();
+    if (open) {
+      const lastEnd = epochMs(open.endedAtUtc, "endedAtUtc");
+      if (startMs - lastEnd >= this.#gapMs) {
+        open.state = "final";
+      } else {
+        open.segments.push(segment);
+        if (segment.endUtc > open.endedAtUtc) open.endedAtUtc = segment.endUtc;
+        return open;
+      }
+    }
+    return this.#start(segment);
+  }
+  /** Flip every open (`capturing`) conversation to `final`; returns the count changed. */
+  finalize() {
+    let changed = 0;
+    for (const conv of this.#conversations) {
+      if (conv.state === "capturing") {
+        conv.state = "final";
+        changed++;
+      }
+    }
+    return changed;
+  }
+  /**
+   * Re-open a conversation recovered from durable storage so a chunk arriving
+   * after a process restart continues it (subject to the same gap rule via
+   * `add`) instead of splitting off a new one. No-op when a conversation is
+   * already open in this run.
+   */
+  resume(conversation) {
+    if (this.#open()) return;
+    epochMs(conversation.endedAtUtc, "endedAtUtc");
+    this.#conversations.push({
+      id: conversation.id,
+      startedAtUtc: conversation.startedAtUtc,
+      endedAtUtc: conversation.endedAtUtc,
+      state: "capturing",
+      segments: []
+    });
+  }
+  /** Ordered snapshot; segments are cloned so callers cannot mutate internal state. */
+  conversations() {
+    return this.#conversations.map((conv) => ({ ...conv, segments: conv.segments.slice() }));
+  }
+  /**
+   * Finalize the open conversation when `nowUtc` is at least the gap past its
+   * last segment, so a run of silent chunks (which carry no segments to `add`)
+   * still closes a conversation instead of leaving it `capturing` until stop.
+   * Returns the closed conversation's id, or null when nothing closed.
+   */
+  closeIfIdle(nowUtc) {
+    const open = this.#open();
+    if (!open) return null;
+    if (epochMs(nowUtc, "nowUtc") - epochMs(open.endedAtUtc, "endedAtUtc") < this.#gapMs) return null;
+    open.state = "final";
+    return open.id;
+  }
+  #open() {
+    const last = this.#conversations[this.#conversations.length - 1];
+    return last && last.state === "capturing" ? last : void 0;
+  }
+  #start(segment) {
+    const conv = {
+      id: this.#makeId(),
+      startedAtUtc: segment.startUtc,
+      endedAtUtc: segment.endUtc,
+      state: "capturing",
+      segments: [segment]
+    };
+    this.#conversations.push(conv);
+    return conv;
+  }
+};
+
+// src/diarization.ts
+var MAX_EXAMPLES = 10;
+var SELF_ID = "self";
+function cosineSimilarity(a, b) {
+  if (a.length === 0 || a.length !== b.length) return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+var SpeakerClusterer = class {
+  #clusters = [];
+  #threshold;
+  #next = 1;
+  constructor(threshold, seed = []) {
+    if (!Number.isFinite(threshold) || threshold <= 0 || threshold >= 1) {
+      throw new CaptureConfigError("diarization.similarityThreshold must be between 0 and 1");
+    }
+    this.#threshold = threshold;
+    for (const c of seed) {
+      this.#clusters.push({
+        id: c.id,
+        centroid: [...c.centroid],
+        examples: c.examples.map((e) => [...e]),
+        embeddingCount: c.embeddingCount,
+        isSelf: c.isSelf,
+        label: c.label
+      });
+      const n = /^spk_(\d+)$/.exec(c.id);
+      if (n) this.#next = Math.max(this.#next, Number(n[1]) + 1);
+    }
+  }
+  /** Register an enrolled self profile (its embedding seeds the `self` cluster). */
+  enrollSelf(embedding) {
+    const existing = this.#clusters.find((c) => c.id === SELF_ID);
+    if (existing) {
+      this.#update(existing, embedding);
+      existing.isSelf = true;
+      return;
+    }
+    this.#clusters.unshift({
+      id: SELF_ID,
+      centroid: [...embedding],
+      examples: [[...embedding]],
+      embeddingCount: 1,
+      isSelf: true,
+      label: null
+    });
+  }
+  /** Best cosine over a cluster's centroid + examples. */
+  #score(cluster, embedding) {
+    let best = cosineSimilarity(cluster.centroid, embedding);
+    for (const ex of cluster.examples) {
+      const s = cosineSimilarity(ex, embedding);
+      if (s > best) best = s;
+    }
+    return best;
+  }
+  #update(cluster, embedding) {
+    const n = cluster.embeddingCount;
+    for (let i = 0; i < cluster.centroid.length && i < embedding.length; i++) {
+      cluster.centroid[i] = (cluster.centroid[i] * n + embedding[i]) / (n + 1);
+    }
+    cluster.embeddingCount = n + 1;
+    if (cluster.examples.length < MAX_EXAMPLES) {
+      cluster.examples.push([...embedding]);
+    } else {
+      let mostSimilar = 0;
+      let mostSimilarScore = -Infinity;
+      for (let i = 0; i < cluster.examples.length; i++) {
+        const s = cosineSimilarity(cluster.examples[i], embedding);
+        if (s > mostSimilarScore) {
+          mostSimilarScore = s;
+          mostSimilar = i;
+        }
+      }
+      cluster.examples[mostSimilar] = [...embedding];
+    }
+  }
+  /** Match `embedding` to an existing cluster or create a new `spk_<n>`. */
+  assign(embedding) {
+    let best = null;
+    let bestScore = -Infinity;
+    for (const cluster2 of this.#clusters) {
+      const s = this.#score(cluster2, embedding);
+      if (s > bestScore) {
+        bestScore = s;
+        best = cluster2;
+      }
+    }
+    if (best && bestScore >= this.#threshold) {
+      this.#update(best, embedding);
+      return best.id;
+    }
+    const cluster = {
+      id: `spk_${this.#next++}`,
+      centroid: [...embedding],
+      examples: [[...embedding]],
+      embeddingCount: 1,
+      isSelf: false,
+      label: null
+    };
+    this.#clusters.push(cluster);
+    return cluster.id;
+  }
+  /** Snapshot for persistence. */
+  clusters() {
+    return this.#clusters.map((c) => ({
+      id: c.id,
+      centroid: [...c.centroid],
+      examples: c.examples.map((e) => [...e]),
+      embeddingCount: c.embeddingCount,
+      isSelf: c.isSelf,
+      label: c.label
+    }));
+  }
+};
+
+// src/native.ts
+import { spawn as nodeSpawn } from "child_process";
+import { readFileSync as readFileSync5 } from "fs";
+import { fileURLToPath } from "url";
+import path7 from "path";
+var HELPER_BIN_ENV = "REMNIC_CAPTURE_HELPER_BIN";
+var STOP_DRAIN_TIMEOUT_MS = 5e3;
+var HELPER_BIN_NAME = "remnic-capture-helper";
+function helperPackageSpecifier(platform, arch) {
+  if (platform !== "darwin") {
+    throw new CaptureConfigError(
+      `Desktop audio capture native helper is only available on macOS; platform "${platform}" is unsupported`
+    );
+  }
+  if (arch === "arm64") return "@remnic/capture-native-darwin-arm64";
+  if (arch === "x64") return "@remnic/capture-native-darwin-x64";
+  throw new CaptureConfigError(
+    `Desktop audio capture native helper is unavailable for macOS architecture "${arch}"`
+  );
+}
+function defaultResolve(specifier) {
+  return fileURLToPath(import.meta.resolve(specifier));
+}
+function resolveHelperBinary(deps = {}) {
+  const env = deps.env ?? process.env;
+  const override = env[HELPER_BIN_ENV]?.trim();
+  if (override) return { specifier: `(${HELPER_BIN_ENV})`, binaryPath: expandTilde(override) };
+  const platform = deps.platform ?? process.platform;
+  const arch = deps.arch ?? process.arch;
+  const resolve = deps.resolve ?? defaultResolve;
+  const readFile = deps.readFile ?? ((file) => readFileSync5(file, "utf8"));
+  const specifier = helperPackageSpecifier(platform, arch);
+  let entry;
+  try {
+    entry = resolve(specifier);
+  } catch {
+    throw new CaptureConfigError(
+      `Desktop audio capture requires the optional native helper ${specifier}, which is not available. Build the Swift helper from source (packages/capture-native-darwin-helper) and set ${HELPER_BIN_ENV} to the built remnic-capture-helper binary.`
+    );
+  }
+  const pkgJsonPath = path7.join(path7.dirname(entry), "package.json");
+  return { specifier, binaryPath: helperBinaryFromPackage(pkgJsonPath, readFile, specifier) };
+}
+function helperBinaryFromPackage(pkgJsonPath, readFile, specifier) {
+  let pkg;
+  try {
+    pkg = JSON.parse(readFile(pkgJsonPath));
+  } catch {
+    throw new CaptureConfigError(`native helper ${specifier} has an unreadable package.json at ${pkgJsonPath}`);
+  }
+  let bin;
+  if (pkg !== null && typeof pkg === "object" && "bin" in pkg) bin = pkg.bin;
+  let rel;
+  if (typeof bin === "string") {
+    rel = bin;
+  } else if (bin !== null && typeof bin === "object") {
+    const map = bin;
+    const named = map[HELPER_BIN_NAME];
+    const first = Object.values(map).find((v) => typeof v === "string");
+    if (typeof named === "string") rel = named;
+    else if (typeof first === "string") rel = first;
+  }
+  if (rel === void 0 || rel === "") {
+    throw new CaptureConfigError(`native helper ${specifier} does not declare an executable in its package.json "bin"`);
+  }
+  return path7.resolve(path7.dirname(pkgJsonPath), rel);
+}
+function buildHelperArgs(opts) {
+  const channel = opts.channel ?? "both";
+  const args = [
+    "audio-capture",
+    "--channel",
+    channel,
+    "--chunk-seconds",
+    String(opts.chunkSeconds),
+    "--out",
+    opts.outDir
+  ];
+  const device = opts.device;
+  if (typeof device === "string" && device !== "") args.push("--device", device);
+  return args;
+}
+var ISO_PREFIX_RE = /^\d{4}-\d{2}-\d{2}T/;
+function parseTimestamp2(value, where) {
+  if (typeof value !== "string" || !ISO_PREFIX_RE.test(value)) {
+    throw new CaptureInputError(`${where}: expected an ISO timestamp`);
+  }
+  if (!Number.isFinite(Date.parse(value))) {
+    throw new CaptureInputError(`${where}: expected a valid ISO timestamp`);
+  }
+  return value;
+}
+function parseChunkEvent(line) {
+  let raw;
+  try {
+    raw = JSON.parse(line);
+  } catch {
+    const trimmed = line.trim();
+    const preview = trimmed.length > 80 ? `${trimmed.slice(0, 77)}...` : trimmed;
+    throw new CaptureInputError(`native helper emitted a non-JSON line: ${preview}`);
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new CaptureInputError("native helper chunk: expected a JSON object");
+  }
+  const obj = raw;
+  if (typeof obj.path !== "string" || obj.path.trim() === "") {
+    throw new CaptureInputError("native helper chunk.path: expected a non-empty string");
+  }
+  if (obj.channel !== "mic" && obj.channel !== "system") {
+    throw new CaptureInputError('native helper chunk.channel: expected "mic" or "system"');
+  }
+  const startedAtUtc = parseTimestamp2(obj.startedAtUtc, "native helper chunk.startedAtUtc");
+  const endedAtUtc = parseTimestamp2(obj.endedAtUtc, "native helper chunk.endedAtUtc");
+  if (Date.parse(endedAtUtc) < Date.parse(startedAtUtc)) {
+    throw new CaptureInputError("native helper chunk.endedAtUtc: must not precede startedAtUtc");
+  }
+  let device = null;
+  if (obj.device !== void 0 && obj.device !== null) {
+    if (typeof obj.device !== "string") {
+      throw new CaptureInputError("native helper chunk.device: expected a string, null, or absent");
+    }
+    device = obj.device;
+  }
+  return { path: obj.path, channel: obj.channel, startedAtUtc, endedAtUtc, device };
+}
+function makeLineReader(onLine) {
+  let buffer = "";
+  return {
+    push(chunk) {
+      buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      let idx = buffer.indexOf("\n");
+      while (idx >= 0) {
+        onLine(buffer.slice(0, idx).replace(/\r$/, ""));
+        buffer = buffer.slice(idx + 1);
+        idx = buffer.indexOf("\n");
+      }
+    },
+    flush() {
+      if (buffer.length > 0) {
+        const line = buffer.replace(/\r$/, "");
+        buffer = "";
+        onLine(line);
+      }
+    }
+  };
+}
+var defaultSpawn = (binaryPath, args) => (
+  // node's typings make stdout/stderr nullable; our piped stdio guarantees them.
+  nodeSpawn(binaryPath, args, { shell: false, stdio: ["ignore", "pipe", "pipe"] })
+);
+var MAX_ENUMERATE_BYTES = 1024 * 1024;
+var ENUMERATE_TIMEOUT_MS = 15e3;
+function enumerateDevices(binaryPath, spawn3 = defaultSpawn, timeoutMs = ENUMERATE_TIMEOUT_MS) {
+  return new Promise((resolve, reject) => {
+    const child = spawn3(binaryPath, ["device-enumerate"]);
+    let out = "";
+    let size = 0;
+    let settled = false;
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      fail(new CaptureInputError("native helper device-enumerate timed out"));
+    }, timeoutMs);
+    timer.unref();
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(err);
+    };
+    child.stdout.on("data", (chunk) => {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      size += Buffer.byteLength(text);
+      if (size > MAX_ENUMERATE_BYTES) {
+        child.kill("SIGKILL");
+        fail(new CaptureInputError("native helper device-enumerate produced too much output"));
+        return;
+      }
+      out += text;
+    });
+    child.stderr.on("data", () => void 0);
+    child.once("error", (err) => fail(err instanceof Error ? err : new Error(String(err))));
+    child.once("close", (code) => {
+      if (settled) return;
+      if (code !== 0) {
+        fail(new CaptureInputError(`native helper device-enumerate exited with status ${code ?? "unknown"}`));
+        return;
+      }
+      if (out.trim() === "") {
+        fail(new CaptureInputError("native helper device-enumerate produced no output"));
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(out);
+      } catch {
+        fail(new CaptureInputError("native helper device-enumerate produced invalid JSON"));
+        return;
+      }
+      let list = null;
+      if (Array.isArray(parsed)) {
+        list = parsed;
+      } else if (parsed !== null && typeof parsed === "object" && "devices" in parsed) {
+        const devices = parsed.devices;
+        if (Array.isArray(devices)) list = devices;
+      }
+      if (list === null) {
+        fail(new CaptureInputError("native helper device-enumerate did not return a device array"));
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve(list);
+    });
+  });
+}
+function createNativeCaptureRunner(options) {
+  if (typeof options.outDir !== "string" || options.outDir.trim() === "") {
+    throw new CaptureConfigError("native runner outDir must be a non-empty string");
+  }
+  if (!Number.isFinite(options.chunkSeconds) || options.chunkSeconds <= 0) {
+    throw new CaptureConfigError("native runner chunkSeconds must be a positive number");
+  }
+  const spawn3 = options.spawn ?? defaultSpawn;
+  const scheduleRestart = options.scheduleRestart ?? ((fn, delayMs) => setTimeout(fn, delayMs).unref());
+  const cancelRestart = options.cancelRestart ?? ((timer) => clearTimeout(timer));
+  const resolveBinary = options.resolveBinary ?? resolveHelperBinary;
+  const maxRestarts = options.maxRestarts ?? 5;
+  const baseBackoffMs = options.baseBackoffMs ?? 500;
+  const maxBackoffMs = options.maxBackoffMs ?? 3e4;
+  const args = buildHelperArgs(options);
+  const onError = (error) => {
+    options.onError?.(error);
+  };
+  let resolution = options.resolution;
+  let stopped = true;
+  let child;
+  let restartTimer;
+  let restarts = 0;
+  let stopResolve = null;
+  function scheduleUnexpectedRestart() {
+    if (stopped) return;
+    if (restarts >= maxRestarts) {
+      stopped = true;
+      onError(new Error(`native capture helper failed ${restarts} times; giving up`));
+      return;
+    }
+    const delayMs = Math.min(maxBackoffMs, baseBackoffMs * 2 ** restarts);
+    restarts += 1;
+    restartTimer = scheduleRestart(() => {
+      restartTimer = void 0;
+      if (!stopped) spawnChild();
+    }, delayMs);
+  }
+  function spawnChild() {
+    if (resolution === void 0) {
+      resolution = resolveBinary({});
+    }
+    const current = spawn3(resolution.binaryPath, args);
+    child = current;
+    let settled = false;
+    const stdoutReader = makeLineReader((line) => {
+      if (line.trim() === "") return;
+      try {
+        const event = parseChunkEvent(line);
+        restarts = 0;
+        options.onChunk(event);
+      } catch (err) {
+        onError(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+    const stderrReader = makeLineReader((line) => {
+      if (line.trim() !== "") options.onStderr?.(line);
+    });
+    current.stdout.on("data", (chunk) => stdoutReader.push(chunk));
+    current.stderr.on("data", (chunk) => stderrReader.push(chunk));
+    const settle = () => {
+      settled = true;
+      stdoutReader.flush();
+      stderrReader.flush();
+      if (child === current) child = void 0;
+      if (stopResolve) {
+        const done = stopResolve;
+        stopResolve = null;
+        done();
+      }
+    };
+    current.once("error", (err) => {
+      if (settled) return;
+      settle();
+      onError(err instanceof Error ? err : new Error(String(err)));
+      scheduleUnexpectedRestart();
+    });
+    current.once("close", (code, signal) => {
+      if (settled) return;
+      settle();
+      if (stopped) return;
+      onError(
+        new Error(`native capture helper exited unexpectedly (code=${code ?? "null"}, signal=${signal ?? "null"})`)
+      );
+      scheduleUnexpectedRestart();
+    });
+  }
+  return {
+    get running() {
+      return !stopped;
+    },
+    start() {
+      if (!stopped) return;
+      stopped = false;
+      restarts = 0;
+      try {
+        spawnChild();
+      } catch (err) {
+        stopped = true;
+        throw err;
+      }
+    },
+    stop() {
+      if (stopped) return Promise.resolve();
+      stopped = true;
+      if (restartTimer !== void 0) {
+        cancelRestart(restartTimer);
+        restartTimer = void 0;
+      }
+      const current = child;
+      if (!current || current.killed === true) {
+        child = void 0;
+        return Promise.resolve();
+      }
+      return new Promise((resolve) => {
+        let done = false;
+        const finish = () => {
+          if (done) return;
+          done = true;
+          clearTimeout(killTimer);
+          clearTimeout(hardTimer);
+          resolve();
+        };
+        stopResolve = finish;
+        const killTimer = setTimeout(() => {
+          if (!done && current.killed !== true) current.kill("SIGKILL");
+        }, STOP_DRAIN_TIMEOUT_MS);
+        killTimer.unref();
+        const hardTimer = setTimeout(finish, STOP_DRAIN_TIMEOUT_MS + 2e3);
+        hardTimer.unref();
+        current.kill("SIGTERM");
+      });
+    }
+  };
+}
+
+// src/dedup.ts
+var OVERLAP_TOLERANCE_MS = 5e3;
+var JACCARD_THRESHOLD = 0.8;
+function wordSet(text) {
+  const words = text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter((w) => w.length > 0);
+  return new Set(words);
+}
+function wordJaccard(a, b) {
+  const setA = wordSet(a);
+  const setB = wordSet(b);
+  if (setA.size === 0 && setB.size === 0) return 1;
+  if (setA.size === 0 || setB.size === 0) return 0;
+  let intersection = 0;
+  for (const w of setA) {
+    if (setB.has(w)) intersection++;
+  }
+  const union = setA.size + setB.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+function overlapsWithin(a, b, toleranceMs) {
+  const aStart = Date.parse(a.startUtc);
+  const aEnd = Date.parse(a.endUtc);
+  const bStart = Date.parse(b.startUtc);
+  const bEnd = Date.parse(b.endUtc);
+  if (!Number.isFinite(aStart) || !Number.isFinite(aEnd) || !Number.isFinite(bStart) || !Number.isFinite(bEnd)) {
+    return false;
+  }
+  return aStart <= bEnd + toleranceMs && bStart <= aEnd + toleranceMs;
+}
+function dedupeCrossChannel(segments, options = {}) {
+  const toleranceMs = options.toleranceMs ?? OVERLAP_TOLERANCE_MS;
+  const threshold = options.jaccardThreshold ?? JACCARD_THRESHOLD;
+  const systemSegments = segments.filter((s) => s.channel === "system");
+  return segments.filter((seg) => {
+    if (seg.channel !== "mic") return true;
+    const duplicated = systemSegments.some(
+      (sys) => overlapsWithin(seg, sys, toleranceMs) && wordJaccard(seg.text, sys.text) >= threshold
+    );
+    return !duplicated;
+  });
+}
+
+// src/processor.ts
+import { createHash as createHash2 } from "crypto";
+function chunkStableId(event) {
+  return `chk_${createHash2("sha1").update(event.path).digest("hex")}`;
+}
+function createChunkProcessor(deps) {
+  let tail = Promise.resolve();
+  let recovered = false;
+  let openConversationId = null;
+  const processedThisRun = /* @__PURE__ */ new Set();
+  const dedupeConversation = (id) => {
+    const segs = deps.spool.conversationSegmentsForDedup(id);
+    if (segs.length === 0) return;
+    const options = deps.dedupWindowMs !== void 0 ? { toleranceMs: deps.dedupWindowMs } : {};
+    const keep = new Set(dedupeCrossChannel(segs, options).map((s) => s.id));
+    const drop = segs.filter((s) => !keep.has(s.id)).map((s) => s.id);
+    if (drop.length > 0) deps.spool.deleteSegments(drop);
+  };
+  const finalizeConv = (id) => {
+    dedupeConversation(id);
+    deps.spool.finalizeConversation(id);
+  };
+  const report = (error, event) => {
+    deps.onError?.(error instanceof Error ? error : new Error(String(error)), event);
+  };
+  async function process2(event) {
+    const chunkId = chunkStableId(event);
+    if (processedThisRun.has(chunkId)) return;
+    if (deps.spool.isChunkApplied(`${chunkId}:done`)) {
+      processedThisRun.add(chunkId);
+      try {
+        await deps.cleanupRawAudio(event);
+      } catch (err) {
+        report(err, event);
+      }
+      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 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);
+    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" },
+        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
+                });
+              }
+            }
+          }
+        }
+        deps.spool.appendAssembledSegments({
+          idempotencyKey: key,
+          chunkId: key,
+          conversationId: grp.id,
+          startedAtUtc: grp.startedAtUtc,
+          state: "capturing",
+          device: event.device,
+          wavPath: event.path,
+          segments: grp.items.map((it) => it.seg)
+        });
+        openConversationId = grp.id;
+      }
+    }
+    const chunkFullyProcessed = built.length > 0 || !deps.spool.isChunkApplied(`${chunkId}:0`);
+    processedThisRun.add(chunkId);
+    if (chunkFullyProcessed) {
+      deps.spool.markChunkComplete(chunkId, openConversationId ?? "-");
+      try {
+        await deps.cleanupRawAudio(event);
+      } catch (err) {
+        report(err, event);
+      }
+    }
+  }
+  function enqueue(event) {
+    tail = tail.then(() => process2(event)).catch((error) => report(error, event));
+  }
+  function drain() {
+    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();
+  }
+  return { enqueue, drain, finalize };
+}
+
+// src/stt.ts
+import { statSync as statSync2 } from "fs";
+import { spawn } from "child_process";
+function isRegularFile(filePath) {
+  try {
+    return statSync2(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function timestampAt(chunkStartedAtUtc, offsetMs) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{1,2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?Z$/.exec(chunkStartedAtUtc);
+  if (!match) {
+    throw new CaptureConfigError("chunk start timestamp is invalid");
+  }
+  const [, year, month, day, hour, minute, second, millisecond = "0"] = match;
+  const startMs = Date.UTC(
+    Number(year),
+    Number(month) - 1,
+    Number(day),
+    Number(hour),
+    Number(minute),
+    Number(second),
+    Number(millisecond.padEnd(3, "0"))
+  );
+  const start = new Date(startMs);
+  if (start.getUTCFullYear() !== Number(year) || start.getUTCMonth() !== Number(month) - 1 || start.getUTCDate() !== Number(day) || start.getUTCHours() !== Number(hour) || start.getUTCMinutes() !== Number(minute) || start.getUTCSeconds() !== Number(second) || start.getUTCMilliseconds() !== Number(millisecond.padEnd(3, "0"))) {
+    throw new CaptureConfigError("chunk start timestamp is invalid");
+  }
+  const timestampMs = startMs + offsetMs;
+  if (!Number.isFinite(timestampMs) || Math.abs(timestampMs) > 864e13) {
+    throw new CaptureConfigError("whisper-cli segment offset produces an invalid timestamp");
+  }
+  return new Date(timestampMs).toISOString();
+}
+function parseWhisperJson(output, chunkStartedAtUtc) {
+  let parsed;
+  try {
+    parsed = JSON.parse(output);
+  } catch {
+    throw new CaptureConfigError("whisper-cli returned malformed JSON");
+  }
+  if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.transcription)) {
+    throw new CaptureConfigError("whisper-cli JSON must contain a transcription array");
+  }
+  return parsed.transcription.map((value, index) => {
+    if (!value || typeof value !== "object") {
+      throw new CaptureConfigError(`whisper-cli transcription[${index}] is invalid`);
+    }
+    const segment = value;
+    if (typeof segment.text !== "string" || segment.text.trim() === "" || !segment.offsets || typeof segment.offsets.from !== "number" || typeof segment.offsets.to !== "number" || !Number.isFinite(segment.offsets.from) || !Number.isFinite(segment.offsets.to) || segment.offsets.from < 0 || segment.offsets.to < segment.offsets.from) {
+      throw new CaptureConfigError(`whisper-cli transcription[${index}] is invalid`);
+    }
+    return {
+      text: segment.text.trim(),
+      startUtc: timestampAt(chunkStartedAtUtc, segment.offsets.from),
+      endUtc: timestampAt(chunkStartedAtUtc, segment.offsets.to)
+    };
+  });
+}
+function resolveModelPath(configuredPath, defaultPath, exists = isRegularFile) {
+  const modelPath = expandTilde(configuredPath?.trim() || defaultPath);
+  if (!exists(modelPath)) {
+    throw new CaptureConfigError(
+      `whisper model not found at ${modelPath}; run 'remnic-capture-audio download-model --model base' or set stt.modelPath`
+    );
+  }
+  return modelPath;
+}
+function buildWhisperArgs(wavPath, modelPath, threads) {
+  const args = ["-m", modelPath, "-f", wavPath, "--no-prints", "--output-json", "--output-file", "-"];
+  if (typeof threads === "number" && Number.isInteger(threads) && threads > 0) {
+    args.push("-t", String(threads));
+  }
+  return args;
+}
+async function transcribeWithWhisper(input) {
+  const result = await input.run("whisper-cli", buildWhisperArgs(input.wavPath, input.modelPath, input.threads));
+  if (result.code !== 0) {
+    throw new CaptureConfigError(`whisper-cli failed with exit code ${result.code}`);
+  }
+  return parseWhisperJson(result.stdout, input.chunkStartedAtUtc);
+}
+function runWhisperCli(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { shell: false, stdio: ["ignore", "pipe", "pipe"] });
+    const stdout = [];
+    const stderr = [];
+    child.stdout.on("data", (chunk) => stdout.push(chunk));
+    child.stderr.on("data", (chunk) => stderr.push(chunk));
+    child.once("error", (error) => {
+      const code = error.code;
+      if (code === "ENOENT") {
+        reject(
+          new CaptureConfigError(
+            `whisper-cli executable '${command}' not found on PATH; install whisper.cpp or configure its path before transcribing`
+          )
+        );
+        return;
+      }
+      reject(new CaptureConfigError(`failed to launch whisper-cli '${command}'${code ? ` (${code})` : ""}`));
+    });
+    child.once("close", (code) => {
+      resolve({
+        code: code ?? 1,
+        stdout: Buffer.concat(stdout).toString("utf8"),
+        stderr: Buffer.concat(stderr).toString("utf8")
+      });
+    });
+  });
+}
+
+// src/capture.ts
+import { realpathSync } from "fs";
+import { rm as rm3 } from "fs/promises";
+import path8 from "path";
+function createLiveCapture(options) {
+  const { spool, config, outDir, defaultModelPath } = options;
+  const resolveModel = options.resolveModel ?? (() => resolveModelPath(config.stt.modelPath ?? void 0, defaultModelPath));
+  const transcribe = options.transcribe ?? ((input) => transcribeWithWhisper({
+    wavPath: input.wavPath,
+    modelPath: input.modelPath,
+    chunkStartedAtUtc: input.chunkStartedAtUtc,
+    threads: config.stt.threads,
+    run: runWhisperCli
+  }));
+  const rawBase = path8.resolve(outDir);
+  const realOrResolved = (p) => {
+    try {
+      return realpathSync(path8.resolve(p));
+    } catch {
+      return path8.resolve(p);
+    }
+  };
+  const rawBaseReal = realOrResolved(rawBase);
+  const withinRawDir = (p) => {
+    const real = realOrResolved(p);
+    return real === rawBaseReal || real.startsWith(rawBaseReal + path8.sep);
+  };
+  const cleanupRawAudio = options.cleanupRawAudio ?? (async (event) => {
+    if (config.rawRetentionHours > 0) return;
+    if (!withinRawDir(event.path)) return;
+    await rm3(path8.resolve(event.path), { force: true });
+  });
+  const assembler = new ConversationAssembler({
+    gapMinutes: config.conversationGapMinutes,
+    ...options.makeConversationId ? { makeId: options.makeConversationId } : {}
+  });
+  const diarizer = options.embed ? new SpeakerClusterer(config.diarization.similarityThreshold, spool.readSpeakerClusters()) : void 0;
+  const processor = createChunkProcessor({
+    spool,
+    assembler,
+    resolveModel,
+    transcribe,
+    cleanupRawAudio,
+    ...options.detectSpeech ? { detectSpeech: options.detectSpeech } : {},
+    ...options.embed ? { embed: options.embed } : {},
+    ...diarizer ? { diarizer } : {},
+    ...options.onError ? { onError: (error) => options.onError?.(error) } : {}
+  });
+  const runner = createNativeCaptureRunner({
+    outDir,
+    chunkSeconds: config.chunkSeconds,
+    // Channels to record (config.captureChannel, default "both"). With "both",
+    // the processor's finalize-time cross-channel dedup drops mic segments that
+    // duplicate system (loopback) speech, so it is stored once (the cleaner
+    // system copy). Operators without system-audio permission can set "mic" so
+    // microphone capture never depends on the system-audio path being available.
+    channel: config.captureChannel,
+    device: config.devices.mic,
+    onChunk: (event) => {
+      if (!withinRawDir(event.path)) {
+        options.onError?.(new CaptureInputError(`native helper chunk path escapes the capture directory: ${event.path}`));
+        return;
+      }
+      processor.enqueue({ ...event, path: path8.resolve(event.path) });
+    },
+    ...options.onError ? { onError: options.onError } : {},
+    ...options.onStderr ? { onStderr: options.onStderr } : {},
+    ...options.resolution ? { resolution: options.resolution } : {},
+    ...options.resolveBinary ? { resolveBinary: options.resolveBinary } : {},
+    ...options.spawn ? { spawn: options.spawn } : {},
+    ...options.scheduleRestart ? { scheduleRestart: options.scheduleRestart } : {},
+    ...options.cancelRestart ? { cancelRestart: options.cancelRestart } : {}
+  });
+  return {
+    get running() {
+      return runner.running;
+    },
+    processor,
+    start() {
+      resolveModel();
+      runner.start();
+    },
+    async stop() {
+      await runner.stop();
+      return processor.finalize();
+    }
+  };
+}
+
+// src/enroll.ts
+var SELF_SPEAKER_ID = "self";
+function enrollSelf(input) {
+  const label = input.label ?? "You";
+  if (input.embedding !== void 0) {
+    if (!Array.isArray(input.embedding) || input.embedding.length === 0) {
+      throw new CaptureConfigError("enroll-self embedding must be a non-empty number array");
+    }
+    for (const value of input.embedding) {
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new CaptureConfigError("enroll-self embedding must contain only finite numbers");
+      }
+    }
+    const clusterer = new SpeakerClusterer(0.5);
+    clusterer.enrollSelf(input.embedding);
+    const self = clusterer.clusters().find((c) => c.isSelf);
+    if (!self) {
+      throw new CaptureConfigError("enroll-self failed to build the self speaker cluster");
+    }
+    input.spool.upsertSpeaker({
+      id: self.id,
+      isSelf: true,
+      label,
+      embeddingCount: self.embeddingCount,
+      centroid: self.centroid,
+      examples: self.examples
+    });
+    return { speakerId: self.id, label, hasEmbedding: true, dimensions: input.embedding.length };
+  }
+  input.spool.upsertSpeaker({ id: SELF_SPEAKER_ID, isSelf: true, label });
+  const stored = input.spool.readSpeakerClusters().find((c) => c.id === SELF_SPEAKER_ID);
+  const dimensions = stored?.centroid.length ?? 0;
+  return { speakerId: SELF_SPEAKER_ID, label, hasEmbedding: dimensions > 0, dimensions };
+}
+
+// src/service.ts
+import path9 from "path";
+var DEFAULT_SERVICE_LABEL = "com.remnic.capture-audio";
+var SYSTEMD_UNIT_NAME = "remnic-capture-audio.service";
+function xmlEscape(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+var SAFE_LABEL = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function validateLabel(label) {
+  if (!SAFE_LABEL.test(label)) {
+    throw new CaptureConfigError(
+      `install-service label must match ${SAFE_LABEL.source} (got: ${JSON.stringify(label)})`
+    );
+  }
+  return label;
+}
+function renderLaunchAgent(spec) {
+  const label = spec.label ?? DEFAULT_SERVICE_LABEL;
+  const args = spec.programArguments.map((a) => `    <string>${xmlEscape(a)}</string>`).join("\n");
+  const envEntries = Object.entries(spec.environment ?? {}).map(([k, v]) => `    <key>${xmlEscape(k)}</key>
+    <string>${xmlEscape(v)}</string>`).join("\n");
+  const envBlock = envEntries === "" ? "" : `  <key>EnvironmentVariables</key>
+  <dict>
+${envEntries}
+  </dict>
+`;
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${xmlEscape(label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+${envBlock}  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ProcessType</key>
+  <string>Background</string>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(spec.logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(spec.logPath)}</string>
+</dict>
+</plist>
+`;
+}
+function systemdArg(value) {
+  const escaped = value.replace(/%/g, "%%");
+  if (escaped === "" || /[\s"'\\]/.test(escaped)) {
+    return `"${escaped.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  return escaped;
+}
+function renderSystemdUnit(spec) {
+  const execStart = spec.programArguments.map(systemdArg).join(" ");
+  const logPath = spec.logPath.replace(/%/g, "%%");
+  const envLines = Object.entries(spec.environment ?? {}).map(([k, v]) => `Environment=${systemdArg(`${k}=${v}`)}`).join("\n");
+  const envBlock = envLines === "" ? "" : `${envLines}
+`;
+  return `[Unit]
+Description=Remnic desktop audio capture daemon
+After=default.target
+
+[Service]
+Type=simple
+ExecStart=${execStart}
+StandardOutput=append:${logPath}
+StandardError=append:${logPath}
+${envBlock}Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+`;
+}
+function planService(deps) {
+  const label = validateLabel(deps.spec.label ?? DEFAULT_SERVICE_LABEL);
+  if (deps.platform === "darwin") {
+    const target = path9.join(deps.home, "Library", "LaunchAgents", `${label}.plist`);
+    return {
+      platform: deps.platform,
+      path: target,
+      contents: renderLaunchAgent(deps.spec),
+      loadHint: `launchctl load ${target}`
+    };
+  }
+  if (deps.platform === "linux") {
+    const unitName = deps.spec.label ? `${label}.service` : SYSTEMD_UNIT_NAME;
+    const target = path9.join(deps.home, ".config", "systemd", "user", unitName);
+    return {
+      platform: deps.platform,
+      path: target,
+      contents: renderSystemdUnit(deps.spec),
+      loadHint: `systemctl --user enable --now ${unitName}`
+    };
+  }
+  throw new CaptureConfigError(`install-service is unsupported on platform "${deps.platform}"`);
+}
+function installService(deps) {
+  const plan = planService(deps);
+  if (!deps.force && deps.exists?.(plan.path)) {
+    throw new CaptureConfigError(`a capture-audio service is already installed at ${plan.path} (use --force to replace)`);
+  }
+  deps.mkdir(path9.dirname(plan.path));
+  deps.writeFile(plan.path, plan.contents);
+  return plan;
+}
+function uninstallService(deps) {
+  const plan = planService(deps);
+  if (!deps.exists(plan.path)) return { plan, removed: false };
+  deps.remove(plan.path);
+  return { plan, removed: true };
+}
+
+// src/cli.ts
+import { spawn as spawn2 } from "child_process";
+import { chmodSync as chmodSync3, existsSync as existsSync2, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import path10 from "path";
+import { setTimeout as delay } from "timers/promises";
+import { homedir } from "os";
+var VALUE_FLAGS = {
+  replay: true,
+  host: true,
+  port: true,
+  listen: true,
+  "base-dir": true,
+  model: true,
+  lines: true,
+  label: true
+};
+var BOOLEAN_FLAGS = {
+  foreground: true,
+  force: true,
+  help: true,
+  capture: true,
+  uninstall: true
+};
+var COMMAND_FLAGS = {
+  init: { force: true },
+  start: { foreground: true, replay: true, host: true, port: true, listen: true, capture: true },
+  stop: { force: true },
+  status: {},
+  devices: {},
+  logs: { lines: true },
+  "download-model": { model: true },
+  janitor: {},
+  "install-service": { force: true, uninstall: true, label: true },
+  "enroll-self": { label: true },
+  help: {}
+};
+var GLOBAL_FLAGS = { "base-dir": true, help: true };
+var READINESS_TIMEOUT_MS = 1e4;
+var STOP_TIMEOUT_MS = 1e4;
+function parseArgs(argv) {
+  const tokens = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      if (Object.hasOwn(VALUE_FLAGS, key)) {
+        const next = argv[i + 1];
+        if (next === void 0 || next.startsWith("--")) {
+          throw new CaptureInputError(`flag --${key} requires a value`);
+        }
+        flags[key] = next;
+        i += 1;
+      } else if (Object.hasOwn(BOOLEAN_FLAGS, key)) {
+        flags[key] = true;
+      } else {
+        throw new CaptureInputError(`unknown flag --${key}`);
+      }
+    } else {
+      tokens.push(arg);
+    }
+  }
+  const command = tokens.length > 0 ? tokens[0] : "help";
+  return { command, positionals: tokens.slice(1), flags };
+}
+function resolvePaths(flags, env) {
+  const baseDir = typeof flags["base-dir"] === "string" ? captureBaseDir({ ...env, REMNIC_CAPTURE_DIR: flags["base-dir"] }) : captureBaseDir(env);
+  return capturePaths(baseDir);
+}
+function loadConfigOrDefault(paths, stderr) {
+  if (existsSync2(paths.configPath)) return loadDaemonConfig(paths.configPath);
+  stderr(`no config at ${paths.configPath}; using defaults (run \`init\` to customize)`);
+  return defaultDaemonConfig();
+}
+function applyBindingOverrides(config, flags) {
+  const next = { ...config };
+  if (typeof flags.listen === "string") {
+    const idx = flags.listen.lastIndexOf(":");
+    if (idx <= 0) throw new CaptureInputError(`--listen expects host:port, got '${flags.listen}'`);
+    next.host = flags.listen.slice(0, idx);
+    next.port = coerceNumber(flags.listen.slice(idx + 1), "--listen port", { integer: true, min: 1, max: 65535 });
+  }
+  if (typeof flags.host === "string") next.host = flags.host;
+  if (typeof flags.port === "string") {
+    next.port = coerceNumber(flags.port, "--port", { integer: true, min: 1, max: 65535 });
+  }
+  next.host = stripIpv6Brackets(next.host);
+  return next;
+}
+function healthUrlFor(host, port) {
+  return `http://${formatHostForUrl(host)}:${port}/v1/health`;
+}
+function recordHealthUrl(record, paths, stderr) {
+  if (record.host !== null && record.port !== null) return healthUrlFor(record.host, record.port);
+  const config = loadConfigOrDefault(paths, stderr);
+  return healthUrlFor(config.host, config.port);
+}
+function tokenHeader(paths) {
+  if (!existsSync2(paths.tokenPath)) return {};
+  return { authorization: `Bearer ${readFileSync6(paths.tokenPath, "utf8").trim()}` };
+}
+function ensurePrivateDir(dir) {
+  mkdirSync3(dir, { recursive: true, mode: 448 });
+  try {
+    chmodSync3(dir, 448);
+  } catch {
+  }
+}
+function describeError(err) {
+  const code = err.code;
+  if (typeof code === "string" && code) return code;
+  return err instanceof Error ? err.name : "unknown error";
+}
+async function probeIdentity(paths, url) {
+  try {
+    const res = await fetch(url, { headers: tokenHeader(paths), signal: AbortSignal.timeout(2e3) });
+    if (!res.ok) return null;
+    const body = await res.json();
+    if (typeof body.instanceId === "string" && typeof body.pid === "number") {
+      return { instanceId: body.instanceId, pid: body.pid };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function recordChildPidOrTerminate(pid, paths, binding, stderr) {
+  const existing = readPidRecord(paths.pidPath);
+  if (existing !== null && existing.pid === pid && existing.instanceId !== null) {
+    return true;
+  }
+  try {
+    writePidFile(paths.pidPath, pid, binding);
+    return true;
+  } catch (err) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+    stderr(`failed to record daemon pid: ${describeError(err)}; terminated child pid ${pid}`);
+    return false;
+  }
+}
+async function isOwnRunningDaemon(record, paths, stderr) {
+  if (record.instanceId === null) return true;
+  const live = await probeIdentity(paths, recordHealthUrl(record, paths, stderr));
+  if (live === null) return true;
+  return live.instanceId === record.instanceId && live.pid === record.pid;
+}
+async function recordedDaemonIsRunning(record, paths, stderr) {
+  if (record.pid === process.pid) return false;
+  if (!isProcessAlive(record.pid)) return false;
+  return isOwnRunningDaemon(record, paths, stderr);
+}
+async function superviseReplay(spool, replayDir, io, signal) {
+  await Promise.resolve();
+  spool.setMeta("replay_status", "running");
+  try {
+    const summary = await ingestReplayDirResponsive(spool, replayDir, { signal });
+    if (summary.aborted) {
+      spool.setMeta("replay_status", "cancelled");
+      io.stdout(`replay: cancelled after ${summary.conversationsIngested} conversation(s)`);
+    } else {
+      spool.setMeta("replay_status", "ok");
+      io.stdout(
+        `replay: ingested ${summary.conversationsIngested} conversation(s), ${summary.segmentsIngested} segment(s) from ${summary.files} fixture file(s)`
+      );
+    }
+  } catch (err) {
+    const message = err instanceof CaptureConfigError || err instanceof CaptureInputError ? err.message : describeError(err);
+    const sanitized = message.replace(/\/\S+/g, "<path>");
+    spool.setMeta("replay_status", `failed: ${sanitized}`);
+    io.stderr(`replay ingestion failed: ${message}`);
+  }
+}
+function cmdInit(paths, flags, stdout) {
+  ensurePrivateDir(paths.baseDir);
+  if (existsSync2(paths.configPath) && flags.force !== true) {
+    stdout(`config already exists at ${paths.configPath} (use --force to overwrite)`);
+  } else {
+    writeFileSync3(paths.configPath, serializeDaemonConfig(defaultDaemonConfig()), "utf8");
+    stdout(`wrote default config to ${paths.configPath}`);
+  }
+  const token = loadOrCreateToken(paths.tokenPath);
+  stdout(`token ready at ${paths.tokenPath} (${token.length} chars, mode 0600)`);
+  stdout(`spool will be created at ${paths.spoolPath} on first start`);
+  return 0;
+}
+async function cmdDownloadModel(paths, flags, stdout, downloadModel) {
+  if (typeof flags.model !== "string") throw new CaptureInputError("flag --model requires a value");
+  const result = await downloadModel({ model: flags.model, directory: path10.join(paths.baseDir, "models") });
+  stdout(`${result.downloaded ? "downloaded" : "model already present"} ${flags.model} to ${result.path}`);
+  return 0;
+}
+async function cmdJanitor(paths, stdout, stderr) {
+  const config = loadConfigOrDefault(paths, stderr);
+  const removed = await pruneExpiredRawAudio(path10.join(paths.baseDir, "raw"), config.rawRetentionHours * 60 * 60 * 1e3);
+  stdout(`janitor: removed ${removed.length} expired raw audio file(s)`);
+  return 0;
+}
+async function cmdStart(paths, flags, env, stdout, stderr, spawnArgvPrefix) {
+  const config = applyBindingOverrides(loadConfigOrDefault(paths, stderr), flags);
+  if (!isLoopbackHost(config.host)) {
+    stderr(
+      `refusing to bind non-loopback host '${config.host}': capture-audio serves plain HTTP with no TLS contract; use a loopback address (127.0.0.1 or ::1)`
+    );
+    return 1;
+  }
+  const replayDir = typeof flags.replay === "string" ? expandTilde(flags.replay) : null;
+  const previousRecord = readPidRecord(paths.pidPath);
+  if (previousRecord !== null) {
+    if (await recordedDaemonIsRunning(previousRecord, paths, stderr)) {
+      stdout(`daemon already running (pid ${previousRecord.pid})`);
+      return 0;
+    }
+    if (previousRecord.pid !== process.pid) {
+      removePidFile(paths.pidPath);
+    }
+  }
+  if (flags.foreground !== true) {
+    const relaunch = spawnArgvPrefix.length > 0 ? [...spawnArgvPrefix] : [process.argv[1]];
+    const forwarded = ["start", "--foreground"];
+    if (replayDir) forwarded.push("--replay", replayDir);
+    if (typeof flags["base-dir"] === "string") forwarded.push("--base-dir", flags["base-dir"]);
+    if (typeof flags.host === "string") forwarded.push("--host", flags.host);
+    if (typeof flags.port === "string") forwarded.push("--port", flags.port);
+    if (typeof flags.listen === "string") forwarded.push("--listen", flags.listen);
+    if (flags.capture === true) forwarded.push("--capture");
+    ensurePrivateDir(paths.baseDir);
+    const logFd = openSync(paths.logPath, "a");
+    const child = spawn2(process.execPath, [...relaunch, ...forwarded], {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      env: { ...process.env, ...env }
+    });
+    child.on("error", (err) => stderr(`daemon failed to launch: ${describeError(err)}`));
+    child.unref();
+    if (typeof child.pid !== "number") {
+      stderr("failed to spawn daemon process");
+      return 1;
+    }
+    if (!recordChildPidOrTerminate(child.pid, paths, { host: config.host, port: config.port }, stderr)) {
+      return 1;
+    }
+    const deadline = Date.now() + READINESS_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      if (!isProcessAlive(child.pid)) {
+        removePidFileIfOwner(paths.pidPath, child.pid);
+        stderr(`daemon exited during startup; see ${paths.logPath}`);
+        return 1;
+      }
+      if (readPidRecord(paths.pidPath)?.instanceId) {
+        stdout(`started daemon (pid ${child.pid}); listening; logs at ${paths.logPath}`);
+        return 0;
+      }
+      await delay(100);
+    }
+    try {
+      process.kill(child.pid, "SIGTERM");
+    } catch {
+    }
+    removePidFileIfOwner(paths.pidPath, child.pid);
+    stderr(
+      `daemon did not become ready within ${READINESS_TIMEOUT_MS / 1e3}s; terminated pid ${child.pid}. See ${paths.logPath}.`
+    );
+    return 1;
+  }
+  ensurePrivateDir(paths.baseDir);
+  const token = loadOrCreateToken(paths.tokenPath);
+  const spool = new Spool(paths.spoolPath);
+  let live = null;
+  if (flags.capture === true) {
+    try {
+      const rawDir = path10.join(paths.baseDir, "raw");
+      mkdirSync3(rawDir, { recursive: true });
+      live = createLiveCapture({
+        spool,
+        config,
+        outDir: rawDir,
+        defaultModelPath: path10.join(paths.baseDir, "models", "ggml-base.bin"),
+        onError: (e) => stderr(`capture: ${describeError(e)}`),
+        onStderr: (l) => stderr(`helper: ${l}`)
+      });
+      live.start();
+    } catch (err) {
+      const detail = err instanceof CaptureConfigError || err instanceof CaptureInputError ? err.message : describeError(err);
+      stderr(`live capture unavailable: ${detail}; serving without capture`);
+      live = null;
+    }
+  }
+  let handle;
+  try {
+    handle = await startDaemon({ spool, config, token, capturing: () => live !== null && live.running });
+  } catch (err) {
+    if (live) await live.stop().catch(() => void 0);
+    spool.close();
+    throw err;
+  }
+  try {
+    writePidFile(paths.pidPath, process.pid, {
+      instanceId: spool.meta("instance_id"),
+      host: handle.host,
+      port: handle.port
+    });
+  } catch (err) {
+    if (live) await live.stop().catch(() => void 0);
+    await handle.close();
+    spool.close();
+    throw err;
+  }
+  stdout(`listening on ${handle.url}`);
+  if (live) stdout("live capture started");
+  const replayAbort = new AbortController();
+  const replayTask = replayDir ? superviseReplay(spool, replayDir, { stdout, stderr }, replayAbort.signal) : Promise.resolve();
+  return await new Promise((resolve) => {
+    let closing = false;
+    const shutdown = () => {
+      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(() => {
+        spool.finalizeOpenConversations();
+        return handle.close().catch(() => void 0);
+      }).finally(() => {
+        spool.close();
+        removePidFileIfOwner(paths.pidPath, process.pid);
+        resolve(0);
+      });
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  });
+}
+async function cmdStop(paths, flags, stdout, stderr) {
+  const record = readPidRecord(paths.pidPath);
+  if (record === null || !isProcessAlive(record.pid)) {
+    removePidFile(paths.pidPath);
+    stdout("daemon not running");
+    return 0;
+  }
+  if (record.instanceId !== null) {
+    const live = await probeIdentity(paths, recordHealthUrl(record, paths, stderr));
+    if (live !== null && (live.instanceId !== record.instanceId || live.pid !== record.pid)) {
+      stderr(
+        `recorded pid ${record.pid} does not match the daemon serving this endpoint (identity/pid mismatch); not signalling and preserving ${paths.pidPath}. Stop the serving daemon via its own controls, or remove the pid file after verifying it is stale.`
+      );
+      return 1;
+    }
+    if (live === null && flags.force !== true) {
+      stderr(
+        `cannot confirm daemon identity for pid ${record.pid} (health unreachable); not signalling. Re-run \`stop --force\` to stop it anyway, or remove ${paths.pidPath}.`
+      );
+      return 1;
+    }
+  } else if (flags.force !== true) {
+    stderr(
+      `cannot verify daemon identity for pid ${record.pid} (no recorded instance id); not signalling. Re-run \`stop --force\` to stop it anyway, or remove ${paths.pidPath}.`
+    );
+    return 1;
+  }
+  try {
+    process.kill(record.pid, "SIGTERM");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ESRCH") {
+      removePidFile(paths.pidPath);
+      stdout("daemon not running");
+      return 0;
+    }
+    if (code === "EPERM") {
+      stderr(`daemon (pid ${record.pid}) is running but not controllable from this user`);
+      return 1;
+    }
+    throw err;
+  }
+  const deadline = Date.now() + STOP_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(record.pid) || readPidRecord(paths.pidPath) === null) {
+      stdout(`daemon (pid ${record.pid}) stopped`);
+      return 0;
+    }
+    await delay(100);
+  }
+  stdout(
+    `sent SIGTERM to daemon (pid ${record.pid}); still shutting down after ${STOP_TIMEOUT_MS / 1e3}s`
+  );
+  return 0;
+}
+async function cmdStatus(paths, stdout, stderr) {
+  const record = readPidRecord(paths.pidPath);
+  if (record === null || !isProcessAlive(record.pid)) {
+    stdout("status: not running");
+    return 0;
+  }
+  try {
+    const res = await fetch(recordHealthUrl(record, paths, stderr), {
+      headers: tokenHeader(paths),
+      signal: AbortSignal.timeout(2e3)
+    });
+    const body = await res.text();
+    stdout(`status: running (pid ${record.pid}) \u2014 HTTP ${res.status} ${body}`);
+  } catch (err) {
+    stdout(`status: process alive (pid ${record.pid}) but health check failed (${describeError(err)})`);
+  }
+  return 0;
+}
+async function cmdDevices(env, stdout) {
+  const { binaryPath } = resolveHelperBinary({ env });
+  const devices = await enumerateDevices(binaryPath);
+  stdout(JSON.stringify({ devices }, null, 2));
+  return 0;
+}
+function cmdInstallService(paths, flags, env, stdout, spawnArgvPrefix) {
+  const platform = process.platform;
+  const home = homedir();
+  const label = typeof flags.label === "string" ? flags.label : void 0;
+  const environment = {};
+  if (typeof env.PATH === "string" && env.PATH !== "") environment.PATH = env.PATH;
+  const helperBin = env.REMNIC_CAPTURE_HELPER_BIN;
+  if (typeof helperBin === "string" && helperBin !== "") environment.REMNIC_CAPTURE_HELPER_BIN = helperBin;
+  const spec = {
+    programArguments: [
+      process.execPath,
+      ...spawnArgvPrefix.length > 0 ? [...spawnArgvPrefix] : [process.argv[1]],
+      "start",
+      "--foreground",
+      "--capture",
+      "--base-dir",
+      paths.baseDir
+    ],
+    logPath: paths.logPath,
+    ...label ? { label } : {},
+    ...Object.keys(environment).length > 0 ? { environment } : {}
+  };
+  if (flags.uninstall === true) {
+    const { plan: plan2, removed } = uninstallService({
+      platform,
+      home,
+      spec,
+      exists: existsSync2,
+      remove: (f) => rmSync2(f, { force: true })
+    });
+    stdout(removed ? `removed ${plan2.path}` : `no capture-audio service installed at ${plan2.path}`);
+    return 0;
+  }
+  ensurePrivateDir(paths.baseDir);
+  const plan = installService({
+    platform,
+    home,
+    spec,
+    force: flags.force === true,
+    exists: existsSync2,
+    mkdir: (dir) => mkdirSync3(dir, { recursive: true }),
+    writeFile: (file, contents) => writeFileSync3(file, contents, { mode: 420 })
+  });
+  stdout(`installed ${plan.platform} service at ${plan.path}`);
+  stdout(`enable it with: ${plan.loadHint}`);
+  return 0;
+}
+function cmdEnrollSelf(paths, flags, stdout) {
+  ensurePrivateDir(paths.baseDir);
+  const spool = new Spool(paths.spoolPath);
+  try {
+    const label = typeof flags.label === "string" ? flags.label : void 0;
+    const result = enrollSelf({ spool, label });
+    stdout(`enrolled self speaker '${result.speakerId}' (${result.label})`);
+    if (!result.hasEmbedding) {
+      stdout("no voice embedding stored yet; voice-based diarization refinement lands with the diarization slice");
+    }
+    return 0;
+  } finally {
+    spool.close();
+  }
+}
+function cmdLogs(paths, flags, stdout) {
+  if (!existsSync2(paths.logPath)) {
+    stdout(`no log file at ${paths.logPath}`);
+    return 0;
+  }
+  const lines = typeof flags.lines === "string" ? coerceNumber(flags.lines, "--lines", { integer: true, min: 1 }) : 200;
+  const all = readFileSync6(paths.logPath, "utf8").split("\n");
+  stdout(all.slice(Math.max(0, all.length - lines)).join("\n"));
+  return 0;
+}
+function usage(stdout) {
+  stdout(
+    [
+      `remnic-capture-audio v${CAPTURE_AUDIO_VERSION}`,
+      "usage: remnic-capture-audio <command> [flags]",
+      "commands: init | start | stop | status | devices | logs | download-model | janitor | install-service | enroll-self",
+      "start flags: --foreground --capture --replay <dir> --host <h> --port <n> --listen <host:port> --base-dir <dir>",
+      "download-model flags: --model <base|small|large-v3-turbo-q5_0> --base-dir <dir>",
+      "install-service flags: --force --uninstall --label <id>; enroll-self flags: --label <name>",
+      "janitor uses rawRetentionHours from audio.json to remove expired files under raw/"
+    ].join("\n")
+  );
+  return 0;
+}
+async function runCapture(io) {
+  const env = io.env ?? process.env;
+  const stdout = io.stdout ?? ((line) => console.log(line));
+  const stderr = io.stderr ?? ((line) => console.error(line));
+  try {
+    const parsed = parseArgs(io.argv);
+    const paths = resolvePaths(parsed.flags, env);
+    if (parsed.flags.help === true || parsed.positionals.includes("-h") || parsed.positionals.includes("--help")) {
+      return usage(stdout);
+    }
+    if (parsed.positionals.length > 0) {
+      stderr(`unexpected argument(s): ${parsed.positionals.join(" ")}`);
+      usage(stderr);
+      return 2;
+    }
+    const allowedFlags = COMMAND_FLAGS[parsed.command];
+    if (allowedFlags !== void 0) {
+      for (const key of Object.keys(parsed.flags)) {
+        if (!Object.hasOwn(GLOBAL_FLAGS, key) && !Object.hasOwn(allowedFlags, key)) {
+          stderr(`flag --${key} is not valid for command '${parsed.command}'`);
+          usage(stderr);
+          return 2;
+        }
+      }
+    }
+    switch (parsed.command) {
+      case "init":
+        return cmdInit(paths, parsed.flags, stdout);
+      case "start":
+        return await cmdStart(paths, parsed.flags, env, stdout, stderr, io.spawnArgvPrefix ?? [process.argv[1]]);
+      case "stop":
+        return await cmdStop(paths, parsed.flags, stdout, stderr);
+      case "status":
+        return await cmdStatus(paths, stdout, stderr);
+      case "devices":
+        return await cmdDevices(env, stdout);
+      case "logs":
+        return cmdLogs(paths, parsed.flags, stdout);
+      case "download-model":
+        return await cmdDownloadModel(paths, parsed.flags, stdout, io.downloadModel ?? downloadWhisperModel);
+      case "janitor":
+        return await cmdJanitor(paths, stdout, stderr);
+      case "install-service":
+        return cmdInstallService(paths, parsed.flags, env, stdout, io.spawnArgvPrefix ?? [process.argv[1]]);
+      case "enroll-self":
+        return cmdEnrollSelf(paths, parsed.flags, stdout);
+      case "help":
+      case "--help":
+      case "-h":
+        return usage(stdout);
+      default:
+        stderr(`unknown command '${parsed.command}'`);
+        usage(stderr);
+        return 2;
+    }
+  } catch (err) {
+    if (err instanceof CaptureConfigError || err instanceof CaptureInputError) {
+      stderr(`error: ${err.message}`);
+      return err instanceof CaptureInputError ? 2 : 1;
+    }
+    stderr(`error: ${describeError(err)}`);
+    return 1;
+  }
+}
+
+export {
+  CAPTURE_AUDIO_VERSION,
+  DEFAULT_HOST,
+  DEFAULT_PORT,
+  SPOOL_SCHEMA_VERSION,
+  CaptureConfigError,
+  CaptureInputError,
+  isLoopbackHost,
+  defaultDaemonConfig,
+  parseDaemonConfig,
+  loadDaemonConfig,
+  serializeDaemonConfig,
+  writePidFile,
+  readPidRecord,
+  readPidFile,
+  isProcessAlive,
+  removePidFile,
+  removePidFileIfOwner,
+  generateToken,
+  loadOrCreateToken,
+  tokensMatch,
+  bearerFromHeader,
+  parseTranscriptDate,
+  assertValidTimezone,
+  parseLimit,
+  encodeCursor,
+  decodeCursor,
+  createRequestHandler,
+  startDaemon,
+  expandTilde,
+  captureBaseDir,
+  capturePaths,
+  REPLAY_COMMIT_BATCH,
+  ingestReplayDir,
+  ingestReplayDirResponsive,
+  whisperModelUrl,
+  downloadWhisperModel,
+  pruneExpiredRawAudio,
+  Spool,
+  assembleConversations,
+  DEFAULT_CONVERSATION_GAP_MINUTES,
+  ConversationAssembler,
+  cosineSimilarity,
+  SpeakerClusterer,
+  HELPER_BIN_ENV,
+  helperPackageSpecifier,
+  resolveHelperBinary,
+  buildHelperArgs,
+  parseChunkEvent,
+  enumerateDevices,
+  createNativeCaptureRunner,
+  wordJaccard,
+  dedupeCrossChannel,
+  chunkStableId,
+  createChunkProcessor,
+  parseWhisperJson,
+  resolveModelPath,
+  buildWhisperArgs,
+  transcribeWithWhisper,
+  runWhisperCli,
+  createLiveCapture,
+  SELF_SPEAKER_ID,
+  enrollSelf,
+  DEFAULT_SERVICE_LABEL,
+  renderLaunchAgent,
+  renderSystemdUnit,
+  planService,
+  installService,
+  uninstallService,
+  superviseReplay,
+  runCapture
+};
+//# sourceMappingURL=chunk-BRVXKUZY.js.map