@remnic/core 9.3.629 → 9.3.631

package/dist/chunk-KVDUDYEN.js

@@ -0,0 +1,1164 @@
+import {
+  getVerdictKind
+} from "./chunk-K47C6M2C.js";
+import {
+  scoreImportance
+} from "./chunk-JXS5PDQ7.js";
+import {
+  applyCorrections,
+  applyOffTheRecord,
+  compileCorrectionRules,
+  compileRedactionPatterns,
+  loadCorrectionsFile,
+  redactText
+} from "./chunk-NDAH7BJ5.js";
+import {
+  WearablesInputError,
+  describeErrorForOperator
+} from "./chunk-7WV3F5DQ.js";
+import {
+  composeDayTranscriptBody,
+  composeDayTranscriptMeta,
+  hashTranscriptBody,
+  isValidTranscriptDate,
+  loadSpeakerRegistry,
+  resolveSpeaker,
+  serializeDayTranscript
+} from "./chunk-M7XQSUBB.js";
+import {
+  countRecallTokenOverlap,
+  normalizeRecallTokens
+} from "./chunk-ZBJMUXZH.js";
+
+// src/wearables/trust.ts
+var TRUST_JUDGE_ACCEPT_BOOST = 0.15;
+var TRUST_CROSS_SOURCE_BOOST = 0.15;
+var TRUST_SUPPORTING_MEMORY_BOOST = 0.1;
+var MIN_FACT_TOKENS = 4;
+var CROSS_SOURCE_COVERAGE = 0.6;
+var MEMORY_SUPPORT_COVERAGE = 0.7;
+var MAX_MEMORIES_SCANNED = 5e3;
+function computeTrustScore(input) {
+  const confidence = typeof input.extractionConfidence === "number" && Number.isFinite(input.extractionConfidence) ? Math.min(1, Math.max(0, input.extractionConfidence)) : 0.7;
+  let trust = confidence * Math.min(1, Math.max(0, input.sourceTrust));
+  if (input.judgeVerdict === "accept") trust += TRUST_JUDGE_ACCEPT_BOOST;
+  if (input.evidence.corroboratedBySources.length > 0) {
+    trust += TRUST_CROSS_SOURCE_BOOST;
+  }
+  if (input.evidence.supportingMemoryId !== void 0) {
+    trust += TRUST_SUPPORTING_MEMORY_BOOST;
+  }
+  return Math.min(1, Math.max(0, trust));
+}
+function tokenizeDayBody(body) {
+  return new Set(normalizeRecallTokens(body));
+}
+function findCorroboration(factText, context) {
+  const factTokens = normalizeRecallTokens(factText);
+  const evidence = { corroboratedBySources: [] };
+  if (factTokens.length < MIN_FACT_TOKENS) return evidence;
+  const factTokenSet = new Set(factTokens);
+  for (const [sourceId, dayTokens] of context.otherSourceDayTokens) {
+    let matches = 0;
+    for (const token of factTokenSet) {
+      if (dayTokens.has(token)) matches += 1;
+    }
+    if (matches / factTokenSet.size >= CROSS_SOURCE_COVERAGE) {
+      evidence.corroboratedBySources.push(sourceId);
+    }
+  }
+  evidence.corroboratedBySources.sort();
+  let scanned = 0;
+  for (const memory of context.existingMemories) {
+    if (scanned >= MAX_MEMORIES_SCANNED) break;
+    scanned += 1;
+    const matches = countRecallTokenOverlap(factTokenSet, memory.content);
+    if (matches / factTokenSet.size >= MEMORY_SUPPORT_COVERAGE) {
+      evidence.supportingMemoryId = memory.id;
+      break;
+    }
+  }
+  return evidence;
+}
+function decideSmart(trust, judgeVerdict, thresholds) {
+  if (judgeVerdict === "reject") {
+    return { outcome: "drop", reason: "judge-rejected", trust };
+  }
+  if (judgeVerdict === "defer") {
+    return { outcome: "review", reason: "judge-deferred", trust };
+  }
+  if (trust >= thresholds.autoApproveTrust) {
+    return { outcome: "active", reason: "auto-approved", trust };
+  }
+  if (trust >= thresholds.reviewTrust) {
+    return { outcome: "review", reason: "queued-for-review", trust };
+  }
+  return { outcome: "drop", reason: "below-trust", trust };
+}
+
+// src/wearables/memory-gen.ts
+function memoryStatusForMode(mode) {
+  return mode === "auto" || mode === "smart" ? "active" : "pending_review";
+}
+var WEARABLE_SOURCE_PREFIX = "wearable";
+function wearableSourceLabel(sourceId) {
+  return `${WEARABLE_SOURCE_PREFIX}:${sourceId}`;
+}
+function wearableDayTag(date) {
+  return `wearable-day:${date}`;
+}
+var IMPORTANCE_RANK = {
+  trivial: 0,
+  low: 1,
+  normal: 2,
+  high: 3,
+  critical: 4
+};
+var MAX_EXTRACTION_CHUNK_CHARS = 6e3;
+var MIN_CONVERSATION_CHARS = 80;
+function buildExtractionTurns(sourceId, date, conversation, registry) {
+  const headerParts = [
+    `Wearable transcript (${sourceId}) \u2014 ${date}`,
+    conversation.title ? `"${conversation.title}"` : void 0,
+    conversation.location ? `at ${conversation.location}` : void 0
+  ].filter((part) => typeof part === "string");
+  const header = `[${headerParts.join(" \u2014 ")}]`;
+  const lines = [];
+  for (const segment of conversation.segments) {
+    const { label } = resolveSpeaker(sourceId, segment, registry);
+    lines.push(`${label}: ${segment.text}`);
+  }
+  const transcript = lines.join("\n");
+  if (transcript.trim().length < MIN_CONVERSATION_CHARS) return [];
+  const sessionKey = `wearables:${sourceId}:${date}:${conversation.id}`;
+  const timestamp = conversation.startIso;
+  const turns = [];
+  let chunkLines = [];
+  let chunkChars = 0;
+  const flush = () => {
+    if (chunkLines.length === 0) return;
+    turns.push({
+      role: "user",
+      content: `${header}
+${chunkLines.join("\n")}`,
+      timestamp,
+      sourceValidAt: timestamp,
+      sessionKey
+    });
+    chunkLines = [];
+    chunkChars = 0;
+  };
+  for (const line of transcript.split("\n")) {
+    if (chunkChars + line.length + 1 > MAX_EXTRACTION_CHUNK_CHARS) flush();
+    chunkLines.push(line);
+    chunkChars += line.length + 1;
+  }
+  flush();
+  return turns;
+}
+async function scoreCandidates(novel, settings, deps, result) {
+  const scored = /* @__PURE__ */ new Map();
+  if (novel.length === 0) return scored;
+  let verdicts;
+  if (deps.judgeFacts) {
+    const judgeCandidates = novel.map((candidate) => ({
+      text: candidate.fact.content,
+      category: candidate.fact.category,
+      confidence: typeof candidate.fact.confidence === "number" ? candidate.fact.confidence : 0.7,
+      tags: candidate.fact.tags ?? [],
+      importanceLevel: candidate.importance.level
+    }));
+    try {
+      const judgeResult = await deps.judgeFacts(judgeCandidates);
+      verdicts = /* @__PURE__ */ new Map();
+      for (const [index, verdict] of judgeResult.verdicts) {
+        verdicts.set(index, getVerdictKind(verdict));
+      }
+    } catch (err) {
+      result.warnings.push(
+        `extraction judge unavailable for this pass: ${describeErrorForOperator(err)} \u2014 trust scoring continued without judge verdicts`
+      );
+    }
+  }
+  const corroboration = deps.corroboration ?? {
+    otherSourceDayTokens: /* @__PURE__ */ new Map(),
+    existingMemories: []
+  };
+  novel.forEach((candidate, index) => {
+    const evidence = findCorroboration(candidate.fact.content, corroboration);
+    const verdict = verdicts?.get(index);
+    const trust = computeTrustScore({
+      extractionConfidence: candidate.fact.confidence,
+      sourceTrust: settings.sourceTrust,
+      judgeVerdict: verdict,
+      evidence
+    });
+    scored.set(index, { trust, ...verdict !== void 0 ? { verdict } : {}, evidence });
+  });
+  return scored;
+}
+async function generateWearableMemories(sourceId, date, conversations, settings, registry, deps) {
+  const result = {
+    created: 0,
+    promoted: 0,
+    demoted: 0,
+    skipped: 0,
+    skippedByReason: {},
+    warnings: [],
+    completed: true
+  };
+  if (settings.memoryMode === "off") return result;
+  const skip = (reason, count = 1) => {
+    result.skipped += count;
+    result.skippedByReason[reason] = (result.skippedByReason[reason] ?? 0) + count;
+  };
+  const candidates = [];
+  const seenContent = /* @__PURE__ */ new Set();
+  for (const conversation of conversations) {
+    const turns = buildExtractionTurns(sourceId, date, conversation, registry);
+    if (turns.length === 0) continue;
+    let extraction;
+    try {
+      extraction = await deps.extract(turns);
+    } catch (err) {
+      result.warnings.push(
+        `extraction failed for ${sourceId}/${date} (conversation ${conversation.id}): ${describeErrorForOperator(err)} \u2014 the memory pass for this day retries on the next sync`
+      );
+      result.completed = false;
+      break;
+    }
+    for (const fact of extraction.facts) {
+      const content = fact.content?.trim();
+      if (!content) {
+        skip("empty");
+        continue;
+      }
+      if (fact.category === "procedure" || fact.category === "reasoning_trace") {
+        skip("unsupported-category");
+        continue;
+      }
+      if (settings.memoryMode !== "smart" && typeof fact.confidence === "number" && fact.confidence < settings.minConfidence) {
+        skip("below-confidence");
+        continue;
+      }
+      const importance = scoreImportance(content, fact.category, fact.tags ?? []);
+      if (IMPORTANCE_RANK[importance.level] < IMPORTANCE_RANK[settings.minImportance]) {
+        skip("below-importance");
+        continue;
+      }
+      const dedupKey = content.toLowerCase();
+      if (seenContent.has(dedupKey)) {
+        skip("duplicate-in-run");
+        continue;
+      }
+      seenContent.add(dedupKey);
+      candidates.push({ fact: { ...fact, content }, importance, conversation });
+    }
+  }
+  const novel = [];
+  const promotable = [];
+  for (const candidate of candidates) {
+    if (await deps.writer.hasFactContentHash(candidate.fact.content)) {
+      if (settings.memoryMode === "smart" && deps.writer.findWearableMemoryByContent !== void 0 && deps.writer.promoteWearableMemory !== void 0) {
+        promotable.push(candidate);
+      } else {
+        skip("duplicate-existing");
+      }
+      continue;
+    }
+    novel.push(candidate);
+  }
+  if (promotable.length > 0) {
+    const promoteScores = await scoreCandidates(promotable, settings, deps, result);
+    for (const [index, candidate] of promotable.entries()) {
+      const scored = promoteScores.get(index);
+      const decision = scored ? decideSmart(scored.trust, scored.verdict, settings) : void 0;
+      if (!scored || !decision) {
+        skip("duplicate-existing");
+        continue;
+      }
+      if (scored.verdict === "reject") {
+        if (deps.writer.demoteWearableMemory !== void 0) {
+          const existingForDemote = await deps.writer.findWearableMemoryByContent(
+            candidate.fact.content
+          );
+          if (existingForDemote && existingForDemote.status === "pending_review" && await deps.writer.demoteWearableMemory(existingForDemote.id, {
+            trustScore: scored.trust.toFixed(3),
+            trustDecision: "demoted-by-rejection",
+            judgeVerdict: "reject"
+          })) {
+            result.demoted += 1;
+            continue;
+          }
+        }
+        skip("duplicate-existing");
+        continue;
+      }
+      if (decision.outcome !== "active") {
+        skip("duplicate-existing");
+        continue;
+      }
+      const existing = await deps.writer.findWearableMemoryByContent(
+        candidate.fact.content
+      );
+      if (!existing || existing.status !== "pending_review") {
+        skip("duplicate-existing");
+        continue;
+      }
+      const promoted = await deps.writer.promoteWearableMemory(
+        existing.id,
+        {
+          trustScore: scored.trust.toFixed(3),
+          trustDecision: "promoted-by-corroboration",
+          ...scored.verdict !== void 0 ? { judgeVerdict: scored.verdict } : {},
+          ...scored.evidence.corroboratedBySources.length > 0 ? { corroboratedBySources: scored.evidence.corroboratedBySources.join(",") } : {},
+          ...scored.evidence.supportingMemoryId !== void 0 ? { supportingMemoryId: scored.evidence.supportingMemoryId } : {}
+        },
+        scored.trust
+      );
+      if (promoted) {
+        result.promoted += 1;
+      } else {
+        skip("duplicate-existing");
+      }
+    }
+  }
+  let trustById = /* @__PURE__ */ new Map();
+  if (settings.memoryMode === "smart") {
+    trustById = await scoreCandidates(novel, settings, deps, result);
+  }
+  const modeStatus = memoryStatusForMode(settings.memoryMode);
+  const writable = [];
+  novel.forEach((candidate, index) => {
+    if (settings.memoryMode !== "smart") {
+      writable.push({ candidate, index, status: modeStatus, trustAttributes: {} });
+      return;
+    }
+    const scored = trustById.get(index);
+    if (!scored) return;
+    const decision = decideSmart(scored.trust, scored.verdict, settings);
+    if (decision.outcome === "drop") {
+      skip(decision.reason);
+      return;
+    }
+    writable.push({
+      candidate,
+      index,
+      status: decision.outcome === "active" ? "active" : "pending_review",
+      trustAttributes: {
+        trustScore: scored.trust.toFixed(3),
+        trustDecision: decision.reason,
+        ...scored.verdict !== void 0 ? { judgeVerdict: scored.verdict } : {},
+        ...scored.evidence.corroboratedBySources.length > 0 ? { corroboratedBySources: scored.evidence.corroboratedBySources.join(",") } : {},
+        ...scored.evidence.supportingMemoryId !== void 0 ? { supportingMemoryId: scored.evidence.supportingMemoryId } : {}
+      }
+    });
+  });
+  const strength = (entry) => settings.memoryMode === "smart" ? trustById.get(entry.index)?.trust ?? 0 : entry.candidate.importance.score;
+  writable.sort((a, b) => {
+    const sa = strength(a);
+    const sb = strength(b);
+    if (sa > sb) return -1;
+    if (sa < sb) return 1;
+    if (a.candidate.fact.content < b.candidate.fact.content) return -1;
+    if (a.candidate.fact.content > b.candidate.fact.content) return 1;
+    return 0;
+  });
+  const cap = settings.maxMemoriesPerDay;
+  const kept = cap > 0 ? writable.slice(0, cap) : writable;
+  if (writable.length > kept.length) {
+    skip("over-day-cap", writable.length - kept.length);
+  }
+  for (const { candidate, index, status, trustAttributes } of kept) {
+    const tags = [
+      .../* @__PURE__ */ new Set([
+        ...candidate.fact.tags ?? [],
+        WEARABLE_SOURCE_PREFIX,
+        wearableSourceLabel(sourceId),
+        wearableDayTag(date)
+      ])
+    ];
+    await deps.writer.writeMemory(candidate.fact.category, candidate.fact.content, {
+      confidence: settings.memoryMode === "smart" ? trustById.get(index)?.trust : candidate.fact.confidence,
+      tags,
+      source: wearableSourceLabel(sourceId),
+      importance: candidate.importance,
+      validAt: candidate.conversation.startIso,
+      structuredAttributes: {
+        ...candidate.fact.structuredAttributes ?? {},
+        wearableSource: sourceId,
+        wearableDate: date,
+        wearableConversationId: candidate.conversation.id,
+        ...trustAttributes
+      },
+      contentHashSource: candidate.fact.content,
+      status
+    });
+    result.created += 1;
+  }
+  return result;
+}
+async function writeDailyDigestMemory(sourceId, date, conversations, settings, registry, writer) {
+  if (settings.memoryMode === "off") return false;
+  if (conversations.length === 0) return false;
+  const lines = conversations.map((conversation) => {
+    const title = conversation.title?.trim() || "Untitled conversation";
+    const speakers = new Set(
+      conversation.segments.map(
+        (segment) => resolveSpeaker(sourceId, segment, registry).label
+      )
+    );
+    return `- ${title} (${speakers.size} speaker${speakers.size === 1 ? "" : "s"})`;
+  });
+  const content = `Wearable day digest \u2014 ${sourceId}, ${date}: ${conversations.length} recorded conversation${conversations.length === 1 ? "" : "s"}.
+` + lines.join("\n");
+  if (await writer.hasFactContentHash(content)) return false;
+  await writer.writeMemory("moment", content, {
+    confidence: 0.9,
+    tags: [
+      WEARABLE_SOURCE_PREFIX,
+      wearableSourceLabel(sourceId),
+      wearableDayTag(date),
+      "daily-digest"
+    ],
+    source: wearableSourceLabel(sourceId),
+    importance: scoreImportance(content, "moment", ["daily-digest"]),
+    validAt: `${date}T00:00:00.000Z`,
+    structuredAttributes: {
+      wearableSource: sourceId,
+      wearableDate: date
+    },
+    contentHashSource: content,
+    status: memoryStatusForMode(settings.memoryMode),
+    memoryKind: "episode"
+  });
+  return true;
+}
+var NATIVE_TRUST_FACTOR = 0.9;
+async function importNativeMemories(sourceId, memories, alreadyImportedIds, settings, deps) {
+  let imported = 0;
+  const importedIds = [];
+  const warnings = [];
+  const seenContent = /* @__PURE__ */ new Set();
+  const smart = settings.importNativeMemories === "smart";
+  const novel = [];
+  for (const memory of memories) {
+    const content = memory.content?.trim();
+    if (!content) continue;
+    if (alreadyImportedIds.has(memory.id)) continue;
+    if (seenContent.has(content) || await deps.writer.hasFactContentHash(content)) {
+      importedIds.push(memory.id);
+      continue;
+    }
+    seenContent.add(content);
+    novel.push({ ...memory, content });
+  }
+  let verdicts;
+  if (smart && deps.judgeFacts && novel.length > 0) {
+    try {
+      const judgeResult = await deps.judgeFacts(
+        novel.map((memory) => ({
+          text: memory.content,
+          category: "fact",
+          confidence: 0.7,
+          tags: memory.tags ?? []
+        }))
+      );
+      verdicts = /* @__PURE__ */ new Map();
+      for (const [index, verdict] of judgeResult.verdicts) {
+        verdicts.set(index, getVerdictKind(verdict));
+      }
+    } catch (err) {
+      warnings.push(
+        `extraction judge unavailable for native import: ${describeErrorForOperator(err)} \u2014 trust scoring continued without judge verdicts`
+      );
+    }
+  }
+  const corroboration = deps.corroboration ?? {
+    otherSourceDayTokens: /* @__PURE__ */ new Map(),
+    existingMemories: []
+  };
+  for (const [index, memory] of novel.entries()) {
+    const content = memory.content;
+    let status = "pending_review";
+    let trustAttributes = {};
+    let confidence = 0.6;
+    if (smart) {
+      const evidence = findCorroboration(content, corroboration);
+      const verdict = verdicts?.get(index);
+      const trust = computeTrustScore({
+        extractionConfidence: void 0,
+        sourceTrust: settings.sourceTrust * NATIVE_TRUST_FACTOR,
+        judgeVerdict: verdict,
+        evidence
+      });
+      const decision = decideSmart(trust, verdict, settings);
+      if (decision.outcome === "drop") {
+        continue;
+      }
+      status = decision.outcome === "active" ? "active" : "pending_review";
+      confidence = trust;
+      trustAttributes = {
+        trustScore: trust.toFixed(3),
+        trustDecision: decision.reason,
+        ...verdict !== void 0 ? { judgeVerdict: verdict } : {},
+        ...evidence.corroboratedBySources.length > 0 ? { corroboratedBySources: evidence.corroboratedBySources.join(",") } : {},
+        ...evidence.supportingMemoryId !== void 0 ? { supportingMemoryId: evidence.supportingMemoryId } : {}
+      };
+    }
+    await deps.writer.writeMemory("fact", content, {
+      confidence,
+      tags: [
+        .../* @__PURE__ */ new Set([
+          ...memory.tags ?? [],
+          WEARABLE_SOURCE_PREFIX,
+          wearableSourceLabel(sourceId),
+          "native-import"
+        ])
+      ],
+      source: `${wearableSourceLabel(sourceId)}:native`,
+      importance: scoreImportance(content, "fact", memory.tags ?? []),
+      validAt: memory.createdIso,
+      structuredAttributes: {
+        wearableSource: sourceId,
+        wearableNativeId: memory.id,
+        ...trustAttributes
+      },
+      contentHashSource: content,
+      status
+    });
+    imported += 1;
+    importedIds.push(memory.id);
+  }
+  return { imported, importedIds, warnings };
+}
+
+// src/wearables/cleanup.ts
+var MERGE_GAP_MS = 3e4;
+var FILLER_TOKENS = ["um", "uh", "uhm", "umm", "uhh", "erm", "hmm", "mhm"];
+var FILLER_PATTERN = new RegExp(
+  // Leading/trailing punctuation around the filler collapses with it so
+  // "Um, so we should" -> "so we should" rather than ", so we should".
+  `(?:^|\\s)(?:${FILLER_TOKENS.join("|")})[,.]?(?=\\s|$)`,
+  "gi"
+);
+function cleanConversation(conversation, settings) {
+  let segments = conversation.segments.map((segment) => ({ ...segment }));
+  let droppedSegments = 0;
+  let mergedSegments = 0;
+  if (settings.stripFillers) {
+    for (const segment of segments) {
+      segment.text = stripFillerTokens(segment.text);
+    }
+  }
+  if (settings.collapseRepeats) {
+    for (const segment of segments) {
+      segment.text = collapseImmediateRepeats(segment.text);
+    }
+  }
+  for (const segment of segments) {
+    segment.text = normalizeWhitespace(segment.text);
+  }
+  if (settings.dropLowQuality) {
+    const kept = [];
+    for (const segment of segments) {
+      if (isLowQualitySegment(segment.text)) {
+        droppedSegments += 1;
+      } else {
+        kept.push(segment);
+      }
+    }
+    segments = kept;
+  } else {
+    const kept = segments.filter((segment) => segment.text.length > 0);
+    droppedSegments += segments.length - kept.length;
+    segments = kept;
+  }
+  if (settings.mergeSameSpeaker) {
+    const merged = [];
+    for (const segment of segments) {
+      const previous = merged[merged.length - 1];
+      if (previous && canMerge(previous, segment)) {
+        previous.text = `${previous.text} ${segment.text}`.trim();
+        if (segment.endIso) previous.endIso = segment.endIso;
+        mergedSegments += 1;
+      } else {
+        merged.push(segment);
+      }
+    }
+    segments = merged;
+  }
+  return {
+    conversation: { ...conversation, segments },
+    droppedSegments,
+    mergedSegments
+  };
+}
+function canMerge(previous, next) {
+  if (previous.speakerKey !== next.speakerKey) return false;
+  const previousEnd = previous.endIso ? Date.parse(previous.endIso) : NaN;
+  const nextStart = next.startIso ? Date.parse(next.startIso) : NaN;
+  if (Number.isNaN(previousEnd) || Number.isNaN(nextStart)) return true;
+  return nextStart - previousEnd <= MERGE_GAP_MS;
+}
+function stripFillerTokens(text) {
+  return normalizeWhitespace(text.replace(FILLER_PATTERN, " "));
+}
+function collapseImmediateRepeats(text) {
+  const words = text.split(/\s+/).filter((word) => word.length > 0);
+  if (words.length < 2) return text.trim();
+  const out = [];
+  let index = 0;
+  while (index < words.length) {
+    out.push(words[index]);
+    index += 1;
+    let matched = true;
+    while (matched) {
+      matched = false;
+      for (let size = 4; size >= 1; size--) {
+        if (out.length < size || index + size > words.length) continue;
+        const tail = out.slice(-size).join(" ").toLowerCase();
+        if (!/\p{L}/u.test(tail)) continue;
+        const ahead = words.slice(index, index + size).join(" ").toLowerCase();
+        if (tail === ahead) {
+          index += size;
+          matched = true;
+          break;
+        }
+      }
+    }
+  }
+  return out.join(" ");
+}
+function isLowQualitySegment(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return true;
+  if (/^(.)\1{4,}$/.test(trimmed)) return true;
+  const letters = trimmed.replace(/[^\p{L}\p{N}]/gu, "");
+  if (letters.length === 0) return true;
+  if (trimmed.length >= 12 && letters.length / trimmed.length < 0.3) {
+    return true;
+  }
+  const words = trimmed.toLowerCase().split(/\s+/);
+  if (words.length >= 5) {
+    const unique = new Set(words);
+    if (unique.size === 1) return true;
+  }
+  return false;
+}
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+
+// src/wearables/sync-state.ts
+import { promises as fsPromises } from "fs";
+import * as path from "path";
+var MAX_TRACKED_NATIVE_IDS = 5e3;
+var MAX_TRACKED_DAY_HASHES = 800;
+function syncStateFilePath(memoryDir) {
+  return path.join(memoryDir, "state", "wearables", "sync.json");
+}
+function emptySyncState() {
+  return { version: 1, sources: {} };
+}
+async function loadSyncState(memoryDir) {
+  const filePath = syncStateFilePath(memoryDir);
+  let raw;
+  try {
+    raw = await fsPromises.readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return emptySyncState();
+    }
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return emptySyncState();
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || typeof parsed.sources !== "object" || parsed.sources === null) {
+    return emptySyncState();
+  }
+  return { version: 1, sources: parsed.sources };
+}
+async function saveSyncState(memoryDir, state) {
+  const filePath = syncStateFilePath(memoryDir);
+  await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now().toString(36)}`;
+  await fsPromises.writeFile(
+    tmpPath,
+    `${JSON.stringify(state, null, 2)}
+`,
+    "utf-8"
+  );
+  try {
+    await fsPromises.rename(tmpPath, filePath);
+  } catch (err) {
+    await fsPromises.unlink(tmpPath).catch(() => void 0);
+    throw err;
+  }
+}
+function updateSourceSyncState(state, sourceId, update) {
+  const previous = state.sources[sourceId];
+  const mergedHashes = {
+    ...previous?.dayHashes ?? {},
+    ...update.dayHashes
+  };
+  const hashKeys = Object.keys(mergedHashes).sort();
+  while (hashKeys.length > MAX_TRACKED_DAY_HASHES) {
+    const oldest = hashKeys.shift();
+    if (oldest === void 0) break;
+    delete mergedHashes[oldest];
+  }
+  const mergedMemoryHashes = {
+    ...previous?.memoryDayHashes ?? {},
+    ...update.memoryDayHashes ?? {}
+  };
+  for (const day of update.clearMemoryDays ?? []) {
+    if (!(day in (update.memoryDayHashes ?? {}))) {
+      delete mergedMemoryHashes[day];
+    }
+  }
+  const memoryHashKeys = Object.keys(mergedMemoryHashes).sort();
+  while (memoryHashKeys.length > MAX_TRACKED_DAY_HASHES) {
+    const oldest = memoryHashKeys.shift();
+    if (oldest === void 0) break;
+    delete mergedMemoryHashes[oldest];
+  }
+  const mergedNativeIds = [
+    ...previous?.importedNativeMemoryIds ?? [],
+    ...update.importedNativeMemoryIds ?? []
+  ];
+  const dedupedNativeIds = [...new Set(mergedNativeIds)];
+  const boundedNativeIds = dedupedNativeIds.length > MAX_TRACKED_NATIVE_IDS ? dedupedNativeIds.slice(dedupedNativeIds.length - MAX_TRACKED_NATIVE_IDS) : dedupedNativeIds;
+  const sortedDays = [...update.days].sort();
+  const latestDay = sortedDays[sortedDays.length - 1];
+  const lastDateSynced = latestDay !== void 0 && (!previous || previous.lastDateSynced < latestDay) ? latestDay : previous?.lastDateSynced ?? latestDay ?? "";
+  return {
+    version: 1,
+    sources: {
+      ...state.sources,
+      [sourceId]: {
+        lastSyncAt: update.syncedAt,
+        lastDateSynced,
+        dayHashes: mergedHashes,
+        memoryDayHashes: mergedMemoryHashes,
+        importedNativeMemoryIds: boundedNativeIds
+      }
+    }
+  };
+}
+
+// src/wearables/pipeline.ts
+var PAGE_SAFETY_CEILING = 1e4;
+var DEFAULT_SYNC_DAYS = 2;
+var MAX_SYNC_DAYS = 90;
+function dateInTimezone(date, timezone) {
+  try {
+    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")}`;
+  } catch {
+    return date.toISOString().slice(0, 10);
+  }
+}
+function resolveSyncDates(options, timezone, now) {
+  if (options.date !== void 0) {
+    if (!isValidTranscriptDate(options.date)) {
+      throw new WearablesInputError(
+        `wearables sync: invalid date '${options.date}' \u2014 expected YYYY-MM-DD`
+      );
+    }
+    return [options.date];
+  }
+  let days = DEFAULT_SYNC_DAYS;
+  if (options.days !== void 0) {
+    if (!Number.isFinite(options.days) || !Number.isInteger(options.days) || options.days < 1 || options.days > MAX_SYNC_DAYS) {
+      throw new WearablesInputError(
+        `wearables sync: invalid days '${options.days}' \u2014 expected an integer between 1 and ${MAX_SYNC_DAYS}`
+      );
+    }
+    days = options.days;
+  }
+  const dates = [];
+  let cursor = dateInTimezone(now, timezone);
+  for (let count = 0; count < days; count++) {
+    dates.unshift(cursor);
+    cursor = previousIsoDate(cursor);
+  }
+  return dates;
+}
+function previousIsoDate(date) {
+  const parsed = /* @__PURE__ */ new Date(`${date}T00:00:00Z`);
+  parsed.setUTCDate(parsed.getUTCDate() - 1);
+  return parsed.toISOString().slice(0, 10);
+}
+async function fetchAllConversationsForDate(connector, date, timezone, signal, warnings) {
+  const byId = /* @__PURE__ */ new Map();
+  let cursor = void 0;
+  const seenCursors = /* @__PURE__ */ new Set();
+  const collect = () => [...byId.values()];
+  for (let page = 0; page < PAGE_SAFETY_CEILING; page++) {
+    const result = await connector.fetchConversations({
+      date,
+      timezone,
+      cursor,
+      signal
+    });
+    for (const conversation of result.conversations) {
+      byId.set(conversation.id, conversation);
+    }
+    if (!result.nextCursor) return { conversations: collect(), partial: false };
+    if (seenCursors.has(result.nextCursor)) {
+      warnings.push(
+        `${connector.id}: provider pagination repeated cursor on ${date} \u2014 stopped to avoid an infinite loop; day may be partially synced (every sync refetches and re-warns while the provider misbehaves)`
+      );
+      return { conversations: collect(), partial: true };
+    }
+    seenCursors.add(result.nextCursor);
+    cursor = result.nextCursor;
+  }
+  warnings.push(
+    `${connector.id}: stopped paginating ${date} after the ${PAGE_SAFETY_CEILING}-page safety ceiling \u2014 day may be partially synced (every sync refetches and re-warns while this persists)`
+  );
+  return { conversations: collect(), partial: true };
+}
+var PARTIAL_DAY_MARKER = "\n*Note: pagination safety cap reached during sync \u2014 this day may be incomplete.*\n";
+function emptyDayBody(sourceId, date) {
+  return `# ${sourceId} transcript \u2014 ${date}
+
+_No storable conversation content for this day (all segments were elided or dropped)._
+`;
+}
+function cleanDay(raw, sourceId, settings, config, userRedaction, correctionRules) {
+  const out = {
+    conversations: [],
+    segmentsKept: 0,
+    segmentsDropped: 0,
+    redactions: 0,
+    correctionsApplied: 0
+  };
+  for (const conversation of raw) {
+    let current = conversation;
+    if (config.offTheRecordEnabled) {
+      const otr = applyOffTheRecord(current);
+      current = otr.conversation;
+      out.segmentsDropped += otr.droppedSegments;
+    }
+    const cleaned = cleanConversation(current, settings.cleanup);
+    current = cleaned.conversation;
+    out.segmentsDropped += cleaned.droppedSegments;
+    const segments = current.segments.map((segment) => {
+      let text = segment.text;
+      if (config.redactionEnabled) {
+        const redacted = redactText(text, userRedaction);
+        text = redacted.text;
+        out.redactions += redacted.redactions;
+      }
+      const corrected = applyCorrections(text, correctionRules, sourceId);
+      out.correctionsApplied += corrected.applied;
+      return { ...segment, text: corrected.text };
+    });
+    current = { ...current, segments };
+    if (current.segments.length > 0) {
+      out.conversations.push(current);
+      out.segmentsKept += current.segments.length;
+    }
+  }
+  return out;
+}
+async function syncWearableSource(connector, settings, config, options, deps) {
+  const now = deps.now ? deps.now() : /* @__PURE__ */ new Date();
+  const timezone = config.timezone ?? defaultTimezone();
+  const dates = resolveSyncDates(options, timezone, now);
+  const summary = {
+    source: connector.id,
+    days: dates,
+    conversations: 0,
+    segmentsKept: 0,
+    segmentsDropped: 0,
+    redactions: 0,
+    correctionsApplied: 0,
+    transcriptsWritten: [],
+    memoriesCreated: 0,
+    memoriesPromoted: 0,
+    memoriesDemoted: 0,
+    memoriesSkipped: 0,
+    nativeMemoriesImported: 0,
+    warnings: []
+  };
+  const registry = await loadSpeakerRegistry(deps.memoryDir);
+  const stateRules = await loadCorrectionsFile(deps.memoryDir);
+  const correctionRules = [
+    ...compileCorrectionRules(config.corrections, "wearables.corrections"),
+    ...compileCorrectionRules(stateRules, "state corrections")
+  ];
+  const userRedaction = compileRedactionPatterns(config.redactionPatterns);
+  let syncState = await loadSyncState(deps.memoryDir);
+  const previousState = syncState.sources[connector.id];
+  const dayHashes = {};
+  const memoryDayHashes = {};
+  const failedMemoryDays = [];
+  const importedNativeIds = [];
+  for (const date of dates) {
+    const fetched = await fetchAllConversationsForDate(
+      connector,
+      date,
+      timezone,
+      options.signal,
+      summary.warnings
+    );
+    const cleaned = cleanDay(
+      fetched.conversations,
+      connector.id,
+      settings,
+      config,
+      userRedaction,
+      correctionRules
+    );
+    summary.conversations += cleaned.conversations.length;
+    summary.segmentsKept += cleaned.segmentsKept;
+    summary.segmentsDropped += cleaned.segmentsDropped;
+    summary.redactions += cleaned.redactions;
+    summary.correctionsApplied += cleaned.correctionsApplied;
+    if (fetched.conversations.length === 0) {
+      const existing = await deps.readDayContentHash(connector.id, date);
+      if (existing !== null) {
+        summary.warnings.push(
+          `${connector.id}: provider returned no conversations for ${date} but a stored transcript exists \u2014 leaving it in place; delete the day file manually if the recordings were intentionally removed upstream`
+        );
+      }
+      continue;
+    }
+    const allElided = cleaned.conversations.length === 0;
+    let body = allElided ? emptyDayBody(connector.id, date) : composeDayTranscriptBody(
+      connector.id,
+      date,
+      timezone,
+      cleaned.conversations,
+      registry
+    );
+    if (fetched.partial && !allElided) {
+      body += PARTIAL_DAY_MARKER;
+    }
+    const bodyHash = hashTranscriptBody(body);
+    const existingHash = await deps.readDayContentHash(connector.id, date);
+    const changed = existingHash !== bodyHash;
+    const shouldWrite = changed && (!allElided || existingHash !== null);
+    if (shouldWrite) {
+      const meta = composeDayTranscriptMeta(
+        connector.id,
+        date,
+        timezone,
+        cleaned.conversations,
+        registry,
+        body,
+        now.toISOString()
+      );
+      await deps.writeDayTranscript(
+        connector.id,
+        date,
+        serializeDayTranscript(meta, body)
+      );
+      summary.transcriptsWritten.push(date);
+    }
+    dayHashes[date] = bodyHash;
+    if (allElided) continue;
+    const needsSmartContext = settings.memoryMode === "smart" || settings.importNativeMemories === "smart";
+    const memoryPassComplete = previousState?.memoryDayHashes?.[date] === bodyHash;
+    if (settings.memoryMode !== "off" && (changed || options.forceMemories === true || !memoryPassComplete)) {
+      if (!deps.memoryGen) {
+        summary.warnings.push(
+          `${connector.id}: memoryMode is '${settings.memoryMode}' but no extraction engine is available in this context \u2014 transcripts synced, memories skipped`
+        );
+      } else {
+        let passClean = false;
+        try {
+          const corroboration = needsSmartContext ? await buildCorroborationContext(connector.id, date, deps) : void 0;
+          const dayMemoryGen = {
+            ...deps.memoryGen,
+            ...corroboration !== void 0 ? { corroboration } : {}
+          };
+          const generated = await generateWearableMemories(
+            connector.id,
+            date,
+            cleaned.conversations,
+            settings,
+            registry,
+            dayMemoryGen
+          );
+          summary.memoriesCreated += generated.created;
+          summary.memoriesPromoted += generated.promoted;
+          summary.memoriesDemoted += generated.demoted;
+          summary.memoriesSkipped += generated.skipped;
+          summary.warnings.push(...generated.warnings);
+          passClean = generated.completed;
+          if (config.digestEnabled) {
+            const wrote = await writeDailyDigestMemory(
+              connector.id,
+              date,
+              cleaned.conversations,
+              settings,
+              registry,
+              deps.memoryGen.writer
+            );
+            if (wrote) summary.memoriesCreated += 1;
+          }
+        } catch (err) {
+          passClean = false;
+          summary.warnings.push(
+            `${connector.id}: memory pass failed for ${date}: ${describeErrorForOperator(err)} \u2014 retries on the next sync`
+          );
+        }
+        if (passClean) {
+          memoryDayHashes[date] = bodyHash;
+        } else {
+          failedMemoryDays.push(date);
+        }
+      }
+    } else if (settings.memoryMode !== "off" && memoryPassComplete) {
+      memoryDayHashes[date] = bodyHash;
+    }
+  }
+  if (settings.importNativeMemories !== "off" && typeof connector.fetchNativeMemories === "function") {
+    if (!deps.memoryGen) {
+      summary.warnings.push(
+        `${connector.id}: importNativeMemories is enabled but no memory writer is available in this context`
+      );
+    } else {
+      const alreadyImported = new Set(
+        previousState?.importedNativeMemoryIds ?? []
+      );
+      const nativeCorroboration = settings.importNativeMemories === "smart" ? {
+        otherSourceDayTokens: /* @__PURE__ */ new Map(),
+        existingMemories: deps.listSupportMemories ? await deps.listSupportMemories() : []
+      } : void 0;
+      const nativeMemoryGen = {
+        ...deps.memoryGen,
+        ...nativeCorroboration !== void 0 ? { corroboration: nativeCorroboration } : {}
+      };
+      let cursor = void 0;
+      const seenNativeCursors = /* @__PURE__ */ new Set();
+      for (let page = 0; page < PAGE_SAFETY_CEILING; page++) {
+        const result = await connector.fetchNativeMemories({
+          cursor,
+          signal: options.signal
+        });
+        const imported = await importNativeMemories(
+          connector.id,
+          result.memories,
+          alreadyImported,
+          settings,
+          nativeMemoryGen
+        );
+        summary.warnings.push(...imported.warnings);
+        summary.nativeMemoriesImported += imported.imported;
+        importedNativeIds.push(...imported.importedIds);
+        for (const id of imported.importedIds) alreadyImported.add(id);
+        if (!result.nextCursor) break;
+        if (seenNativeCursors.has(result.nextCursor)) {
+          summary.warnings.push(
+            `${connector.id}: provider pagination repeated cursor during native-memory import \u2014 stopped to avoid an infinite loop; remaining items import on the next sync`
+          );
+          break;
+        }
+        seenNativeCursors.add(result.nextCursor);
+        cursor = result.nextCursor;
+        if (page === PAGE_SAFETY_CEILING - 1) {
+          summary.warnings.push(
+            `${connector.id}: stopped native-memory import at the ${PAGE_SAFETY_CEILING}-page safety ceiling \u2014 remaining items import on the next sync`
+          );
+        }
+      }
+    }
+  }
+  const wroteAnything = summary.transcriptsWritten.length > 0 || summary.memoriesCreated > 0 || summary.memoriesPromoted > 0 || summary.memoriesDemoted > 0 || summary.nativeMemoriesImported > 0;
+  if (wroteAnything && deps.afterWrites) {
+    try {
+      await deps.afterWrites();
+    } catch (err) {
+      summary.warnings.push(
+        `search reindex failed (writes are stored and will index on the next update): ${describeErrorForOperator(err)}`
+      );
+    }
+  }
+  syncState = updateSourceSyncState(syncState, connector.id, {
+    syncedAt: now.toISOString(),
+    days: dates,
+    dayHashes,
+    memoryDayHashes,
+    clearMemoryDays: failedMemoryDays,
+    importedNativeMemoryIds: importedNativeIds
+  });
+  if (summary.transcriptsWritten.length > 0) {
+    const cleared = {};
+    for (const [otherId, otherState] of Object.entries(syncState.sources)) {
+      if (otherId === connector.id || otherState.memoryDayHashes === void 0) {
+        cleared[otherId] = otherState;
+        continue;
+      }
+      const memoryDays = { ...otherState.memoryDayHashes };
+      let touched = false;
+      for (const date of summary.transcriptsWritten) {
+        if (date in memoryDays) {
+          delete memoryDays[date];
+          touched = true;
+        }
+      }
+      cleared[otherId] = touched ? { ...otherState, memoryDayHashes: memoryDays } : otherState;
+    }
+    syncState = { version: 1, sources: cleared };
+  }
+  await saveSyncState(deps.memoryDir, syncState);
+  return summary;
+}
+async function buildCorroborationContext(sourceId, date, deps) {
+  const otherSourceDayTokens = /* @__PURE__ */ new Map();
+  if (deps.readOtherSourceDayBodies) {
+    const bodies = await deps.readOtherSourceDayBodies(date, sourceId);
+    for (const [otherSource, body] of bodies) {
+      otherSourceDayTokens.set(otherSource, tokenizeDayBody(body));
+    }
+  }
+  const existingMemories = deps.listSupportMemories ? await deps.listSupportMemories() : [];
+  return { otherSourceDayTokens, existingMemories };
+}
+function defaultTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+
+export {
+  memoryStatusForMode,
+  WEARABLE_SOURCE_PREFIX,
+  wearableSourceLabel,
+  wearableDayTag,
+  buildExtractionTurns,
+  generateWearableMemories,
+  writeDailyDigestMemory,
+  importNativeMemories,
+  cleanConversation,
+  stripFillerTokens,
+  collapseImmediateRepeats,
+  isLowQualitySegment,
+  syncStateFilePath,
+  emptySyncState,
+  loadSyncState,
+  saveSyncState,
+  updateSourceSyncState,
+  dateInTimezone,
+  resolveSyncDates,
+  syncWearableSource,
+  defaultTimezone
+};
+//# sourceMappingURL=chunk-KVDUDYEN.js.map