@remnic/core 9.3.624 → 9.3.625

package/dist/{chunk-RKW6QR7W.js → chunk-AZ4RI3QD.js}

@@ -22,7 +22,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-2L54V4ZO.js";
+} from "./chunk-UELS6WWF.js";
 import {
   SharedContextManager
 } from "./chunk-DRD2Q7HQ.js";
@@ -168,7 +168,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-BNW5NJJH.js";
+} from "./chunk-LQYTQCXM.js";
 import {
   buildEventOrderRecallSection,
   shouldRecallEventOrderEvidence
@@ -203,7 +203,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-QFQQFX2H.js";
+} from "./chunk-3R2UZV3U.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-2PRQG7PV.js";
@@ -212,13 +212,13 @@ import {
 } from "./chunk-X6IRLNOO.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-R3OQGYOU.js";
+} from "./chunk-P2D2MM47.js";
 import {
   ThreadingManager
 } from "./chunk-W4RVMTHR.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-2UFQYU5F.js";
+} from "./chunk-57QXN2CS.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -237,7 +237,7 @@ import {
 } from "./chunk-CYEPCZN5.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-W3BKVM64.js";
+} from "./chunk-QDV6VAD4.js";
 import {
   namespaceIdentityFromToken
 } from "./chunk-ZFXCQPNO.js";
@@ -285,6 +285,17 @@ import {
   FallbackLlmClient,
   fallbackLlmRuntimeContextFromConfig
 } from "./chunk-KGIGRNR6.js";
+import {
+  applyCorrections,
+  applyOffTheRecord,
+  compileCorrectionRule,
+  compileCorrectionRules,
+  compileRedactionPatterns,
+  correctionsFilePath,
+  loadCorrectionsFile,
+  redactText,
+  saveCorrectionsFile
+} from "./chunk-NDAH7BJ5.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-LBJBNWS2.js";
@@ -306,6 +317,10 @@ import {
   isAbortError,
   throwIfAborted
 } from "./chunk-PVGDJXVK.js";
+import {
+  WearablesInputError,
+  describeErrorForOperator
+} from "./chunk-7WV3F5DQ.js";
 import {
   clusterByKey,
   combineNamespaces,
@@ -317,7 +332,7 @@ import {
 } from "./chunk-JGSKJHF7.js";
 import {
   buildXraySnapshot
-} from "./chunk-BPSGLMQ4.js";
+} from "./chunk-YQNADJCT.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
@@ -338,11 +353,21 @@ import {
   ContentHashIndex,
   StorageManager,
   compareEntityTimestamps,
+  composeDayTranscriptBody,
+  composeDayTranscriptMeta,
   fingerprintEntityStructuredFacts,
+  hashTranscriptBody,
+  isValidTranscriptDate,
+  loadSpeakerRegistry,
   normalizeAttributePairs,
   normalizeEntityName,
-  parseEntityFile
-} from "./chunk-PJGB7XRR.js";
+  parseDayTranscript,
+  parseEntityFile,
+  resolveSpeaker,
+  saveSpeakerRegistry,
+  serializeDayTranscript,
+  speakerRegistryKey
+} from "./chunk-UGHUNQ74.js";
 import {
   attachCitation,
   hasCitationForTemplate,
@@ -350,7 +375,7 @@ import {
 } from "./chunk-J6A3CX5N.js";
 import {
   confidenceTier
-} from "./chunk-4R4KTDIE.js";
+} from "./chunk-FPNQF475.js";
 import {
   isActiveMemoryStatus
 } from "./chunk-RULE4VG5.js";
@@ -395,7 +420,7 @@ import {
 } from "./chunk-AC5LO7IU.js";
 
 // src/orchestrator.ts
-import path2 from "path";
+import path3 from "path";
 import os from "os";
 import { createHash, randomBytes } from "crypto";
 import { existsSync } from "fs";
@@ -937,6 +962,1300 @@ function getTaxonomyFilePath(memoryDir) {
   return path.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
+// src/wearables/memory-gen.ts
+function memoryStatusForMode(mode) {
+  return mode === "auto" ? "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 generateWearableMemories(sourceId, date, conversations, settings, registry, deps) {
+  const result = {
+    created: 0,
+    skipped: 0,
+    skippedByReason: {},
+    warnings: []
+  };
+  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`
+      );
+      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 (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 = [];
+  for (const candidate of candidates) {
+    if (await deps.writer.hasFactContentHash(candidate.fact.content)) {
+      skip("duplicate-existing");
+      continue;
+    }
+    novel.push(candidate);
+  }
+  novel.sort((a, b) => {
+    if (a.importance.score > b.importance.score) return -1;
+    if (a.importance.score < b.importance.score) return 1;
+    if (a.fact.content < b.fact.content) return -1;
+    if (a.fact.content > b.fact.content) return 1;
+    return 0;
+  });
+  const cap = settings.maxMemoriesPerDay;
+  const kept = cap > 0 ? novel.slice(0, cap) : novel;
+  if (novel.length > kept.length) {
+    skip("over-day-cap", novel.length - kept.length);
+  }
+  const status = memoryStatusForMode(settings.memoryMode);
+  for (const candidate 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: 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
+      },
+      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;
+}
+async function importNativeMemories(sourceId, memories, alreadyImportedIds, writer) {
+  let imported = 0;
+  const importedIds = [];
+  const seenContent = /* @__PURE__ */ new Set();
+  for (const memory of memories) {
+    const content = memory.content?.trim();
+    if (!content) continue;
+    if (alreadyImportedIds.has(memory.id)) continue;
+    if (seenContent.has(content) || await writer.hasFactContentHash(content)) {
+      importedIds.push(memory.id);
+      continue;
+    }
+    seenContent.add(content);
+    await writer.writeMemory("fact", content, {
+      confidence: 0.6,
+      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
+      },
+      contentHashSource: content,
+      status: "pending_review"
+    });
+    imported += 1;
+    importedIds.push(memory.id);
+  }
+  return { imported, importedIds };
+}
+
+// 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 path2 from "path";
+var MAX_TRACKED_NATIVE_IDS = 5e3;
+var MAX_TRACKED_DAY_HASHES = 800;
+function syncStateFilePath(memoryDir) {
+  return path2.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(path2.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 MAX_PAGES_PER_DAY = 50;
+var MAX_NATIVE_PAGES = 20;
+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 conversations = [];
+  let cursor = void 0;
+  for (let page = 0; page < MAX_PAGES_PER_DAY; page++) {
+    const result = await connector.fetchConversations({
+      date,
+      timezone,
+      cursor,
+      signal
+    });
+    conversations.push(...result.conversations);
+    if (!result.nextCursor) return { conversations, partial: false };
+    cursor = result.nextCursor;
+  }
+  warnings.push(
+    `${connector.id}: stopped paginating ${date} after ${MAX_PAGES_PER_DAY} pages \u2014 day may be partially synced (every sync refetches and re-warns until the provider day fits the cap)`
+  );
+  return { conversations, 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,
+    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 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 generated = await generateWearableMemories(
+            connector.id,
+            date,
+            cleaned.conversations,
+            settings,
+            registry,
+            deps.memoryGen
+          );
+          summary.memoriesCreated += generated.created;
+          summary.memoriesSkipped += generated.skipped;
+          summary.warnings.push(...generated.warnings);
+          passClean = generated.warnings.length === 0;
+          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 === "review" && 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 ?? []
+      );
+      let cursor = void 0;
+      for (let page = 0; page < MAX_NATIVE_PAGES; page++) {
+        const result = await connector.fetchNativeMemories({
+          cursor,
+          signal: options.signal
+        });
+        const imported = await importNativeMemories(
+          connector.id,
+          result.memories,
+          alreadyImported,
+          deps.memoryGen.writer
+        );
+        summary.nativeMemoriesImported += imported.imported;
+        importedNativeIds.push(...imported.importedIds);
+        for (const id of imported.importedIds) alreadyImported.add(id);
+        if (!result.nextCursor) break;
+        cursor = result.nextCursor;
+        if (page === MAX_NATIVE_PAGES - 1) {
+          summary.warnings.push(
+            `${connector.id}: stopped native-memory import after ${MAX_NATIVE_PAGES} pages \u2014 remaining items import on the next sync`
+          );
+        }
+      }
+    }
+  }
+  if (summary.transcriptsWritten.length > 0 && deps.afterTranscriptsWritten) {
+    try {
+      await deps.afterTranscriptsWritten();
+    } catch (err) {
+      summary.warnings.push(
+        `search reindex failed (transcripts 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
+  });
+  await saveSyncState(deps.memoryDir, syncState);
+  return summary;
+}
+function defaultTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+
+// src/wearables/registry.ts
+var registrations = /* @__PURE__ */ new Map();
+function registerWearableConnector(registration) {
+  if (!registration || typeof registration !== "object") {
+    throw new Error("wearable connector registration must be an object");
+  }
+  if (typeof registration.id !== "string" || registration.id.trim().length === 0) {
+    throw new Error("wearable connector id must be a non-empty string");
+  }
+  if (typeof registration.factory !== "function") {
+    throw new Error(
+      `wearable connector '${registration.id}' must provide a factory function`
+    );
+  }
+  const key = registration.id.trim();
+  if (registrations.has(key)) {
+    throw new Error(`wearable connector '${key}' is already registered`);
+  }
+  registrations.set(key, { ...registration, id: key });
+}
+function getWearableConnector(id) {
+  if (typeof id !== "string") return void 0;
+  const key = id.trim();
+  if (key.length === 0) return void 0;
+  return registrations.get(key);
+}
+function listWearableConnectors() {
+  return [...registrations.keys()];
+}
+function clearWearableConnectors() {
+  registrations.clear();
+}
+var BUILT_IN_CONNECTOR_PACKAGES = [
+  { id: "limitless", suffix: "connector-limitless" },
+  { id: "bee", suffix: "connector-bee" },
+  { id: "omi", suffix: "connector-omi" }
+];
+var loadFailuresWarned = /* @__PURE__ */ new Set();
+async function ensureBuiltInWearableConnectors() {
+  for (const entry of BUILT_IN_CONNECTOR_PACKAGES) {
+    if (registrations.has(entry.id)) continue;
+    const specifier = "@remnic/" + entry.suffix;
+    let mod;
+    try {
+      mod = await import(specifier);
+    } catch (err) {
+      if (isModuleNotFound(err, specifier)) continue;
+      if (!loadFailuresWarned.has(specifier)) {
+        loadFailuresWarned.add(specifier);
+        log.warn(
+          `wearables: failed to load optional connector package ${specifier}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      continue;
+    }
+    const registration = mod.wearableConnectorRegistration;
+    if (!registration) continue;
+    try {
+      registerWearableConnector(registration);
+    } catch {
+    }
+  }
+}
+function isModuleNotFound(err, specifier) {
+  if (!err || typeof err !== "object") return false;
+  const code = err.code;
+  if (code !== "ERR_MODULE_NOT_FOUND" && code !== "MODULE_NOT_FOUND") {
+    return false;
+  }
+  const message = err.message;
+  return typeof message === "string" && message.includes(specifier);
+}
+
+// src/wearables/service.ts
+function createWearableMemoryWriter(storage) {
+  return {
+    writeMemory: storage.writeMemory.bind(storage),
+    hasFactContentHash: async (content) => {
+      if (await storage.hasFactContentHash(content)) return true;
+      const needle = content.trim();
+      const memories = await storage.readAllMemories();
+      return memories.some(
+        (memory) => typeof memory.frontmatter.source === "string" && memory.frontmatter.source.startsWith(`${WEARABLE_SOURCE_PREFIX}:`) && memory.content.trim() === needle
+      );
+    }
+  };
+}
+var SOURCE_ID_PATTERN = /^[a-z][a-z0-9-]{0,63}$/;
+function assertValidSourceId(source) {
+  if (!SOURCE_ID_PATTERN.test(source)) {
+    throw new WearablesInputError(
+      `invalid source id '${source}' \u2014 expected lowercase letters, digits, and dashes`
+    );
+  }
+}
+var TRANSCRIPT_SEARCH_DEFAULT_LIMIT = 10;
+var TRANSCRIPT_SEARCH_MAX_LIMIT = 50;
+var MEMORY_LIST_DEFAULT_LIMIT = 50;
+var MEMORY_LIST_MAX_LIMIT = 200;
+var WearablesService = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  get enabled() {
+    return this.deps.config.enabled;
+  }
+  assertEnabled() {
+    if (!this.deps.config.enabled) {
+      throw new WearablesInputError(
+        "wearables are not enabled \u2014 set `wearables.enabled: true` (and configure at least one source) in the plugin config"
+      );
+    }
+  }
+  timezone() {
+    return this.deps.config.timezone ?? defaultTimezone();
+  }
+  enabledSources() {
+    return Object.entries(this.deps.config.sources).filter(
+      ([, settings]) => settings.enabled
+    );
+  }
+  /** Status for every configured source (and connector availability). */
+  async status() {
+    await ensureBuiltInWearableConnectors();
+    const storage = await this.deps.getStorage();
+    const syncState = await loadSyncState(storage.dir);
+    const sources = [];
+    for (const [sourceId, settings] of Object.entries(this.deps.config.sources)) {
+      const registration = getWearableConnector(sourceId);
+      const days = await storage.listWearableTranscriptDays(sourceId).catch(() => []);
+      const state = syncState.sources[sourceId];
+      sources.push({
+        source: sourceId,
+        displayName: registration?.displayName ?? sourceId,
+        enabled: settings.enabled,
+        connectorInstalled: registration !== void 0,
+        memoryMode: settings.memoryMode,
+        lastSyncAt: state?.lastSyncAt ?? null,
+        lastDateSynced: state?.lastDateSynced ?? null,
+        transcriptDays: days.length
+      });
+    }
+    return {
+      enabled: this.deps.config.enabled,
+      timezone: this.timezone(),
+      sources,
+      connectorsInstalled: listWearableConnectors()
+    };
+  }
+  /** Run a sync for one source or all enabled sources. */
+  async sync(options) {
+    this.assertEnabled();
+    await ensureBuiltInWearableConnectors();
+    const storage = await this.deps.getStorage();
+    let targets;
+    if (options.source !== void 0) {
+      assertValidSourceId(options.source);
+      const settings = this.deps.config.sources[options.source];
+      if (!settings) {
+        throw new WearablesInputError(
+          `unknown wearable source '${options.source}' \u2014 configured sources: ${Object.keys(this.deps.config.sources).join(", ") || "(none)"}`
+        );
+      }
+      if (!settings.enabled) {
+        throw new WearablesInputError(
+          `wearable source '${options.source}' is configured but disabled \u2014 set wearables.sources.${options.source}.enabled: true`
+        );
+      }
+      targets = [[options.source, settings]];
+    } else {
+      targets = this.enabledSources();
+      if (targets.length === 0) {
+        throw new WearablesInputError(
+          "no wearable sources are enabled \u2014 configure wearables.sources.<id>.enabled: true"
+        );
+      }
+    }
+    const memoryGen = this.deps.extract ? {
+      extract: this.deps.extract,
+      writer: createWearableMemoryWriter(storage)
+    } : null;
+    const summaries = [];
+    for (const [sourceId, settings] of targets) {
+      const registration = getWearableConnector(sourceId);
+      if (!registration) {
+        throw new WearablesInputError(
+          `wearable source '${sourceId}' is enabled but its connector package is not installed.
+Install it alongside Remnic:
+  npm install @remnic/connector-${sourceId}`
+        );
+      }
+      const connector = registration.factory({
+        settings,
+        timezone: this.timezone()
+      });
+      const summary = await syncWearableSource(
+        connector,
+        settings,
+        this.deps.config,
+        options,
+        {
+          memoryDir: storage.dir,
+          readDayContentHash: async (source, date) => {
+            const raw = await storage.readWearableDayTranscript(source, date);
+            if (raw === null) return null;
+            return parseDayTranscript(raw)?.meta.contentHash ?? null;
+          },
+          writeDayTranscript: (source, date, serialized) => storage.writeWearableDayTranscript(source, date, serialized),
+          afterTranscriptsWritten: this.deps.reindexSearch,
+          memoryGen
+        }
+      );
+      summaries.push(summary);
+    }
+    return summaries;
+  }
+  /** Verify connectivity/credentials for one source. */
+  async checkAuth(sourceId) {
+    this.assertEnabled();
+    await ensureBuiltInWearableConnectors();
+    assertValidSourceId(sourceId);
+    const settings = this.deps.config.sources[sourceId];
+    if (!settings) {
+      throw new WearablesInputError(`unknown wearable source '${sourceId}'`);
+    }
+    const registration = getWearableConnector(sourceId);
+    if (!registration) {
+      return {
+        ok: false,
+        detail: `connector package @remnic/connector-${sourceId} is not installed`
+      };
+    }
+    const connector = registration.factory({
+      settings,
+      timezone: this.timezone()
+    });
+    try {
+      return await connector.verifyAuth();
+    } catch (err) {
+      return {
+        ok: false,
+        detail: describeErrorForOperator(err)
+      };
+    }
+  }
+  /**
+   * Full transcript(s) for a day. Without `source`, returns every
+   * source that recorded that day, annotated with overlap hints.
+   */
+  async dayTranscript(date, sourceId) {
+    if (!isValidTranscriptDate(date)) {
+      throw new WearablesInputError(`invalid date '${date}' \u2014 expected YYYY-MM-DD`);
+    }
+    if (sourceId !== void 0) assertValidSourceId(sourceId);
+    const storage = await this.deps.getStorage();
+    const targets = sourceId !== void 0 ? [sourceId] : (await storage.listWearableTranscriptDays()).filter((entry) => entry.date === date).map((entry) => entry.source);
+    const views = [];
+    for (const source of [...new Set(targets)]) {
+      const raw = await storage.readWearableDayTranscript(source, date);
+      if (raw === null) continue;
+      const parsed = parseDayTranscript(raw);
+      views.push({
+        source,
+        date,
+        meta: parsed?.meta ?? null,
+        body: parsed?.body ?? raw,
+        overlapsWith: []
+      });
+    }
+    for (const view of views) {
+      view.overlapsWith = views.map((other) => other.source).filter((other) => other !== view.source);
+    }
+    return views;
+  }
+  /** List days that have stored transcripts. */
+  async listDays(sourceId) {
+    if (sourceId !== void 0) assertValidSourceId(sourceId);
+    const storage = await this.deps.getStorage();
+    return storage.listWearableTranscriptDays(sourceId);
+  }
+  /**
+   * Search stored transcripts. Uses the indexed backend when available
+   * and falls back to a bounded substring scan otherwise — the two
+   * paths are distinguishable in the result (`backend`) so callers can
+   * tell "no hits" from "weaker search ran".
+   */
+  async searchTranscripts(query, options = {}) {
+    const trimmed = query.trim();
+    if (trimmed.length === 0) {
+      throw new WearablesInputError("transcript search requires a non-empty query");
+    }
+    if (options.source !== void 0) assertValidSourceId(options.source);
+    for (const [name, value] of [
+      ["from", options.from],
+      ["to", options.to]
+    ]) {
+      if (value !== void 0 && !isValidTranscriptDate(value)) {
+        throw new WearablesInputError(`invalid ${name} date '${value}' \u2014 expected YYYY-MM-DD`);
+      }
+    }
+    const limit = clampLimit(
+      options.limit,
+      TRANSCRIPT_SEARCH_DEFAULT_LIMIT,
+      TRANSCRIPT_SEARCH_MAX_LIMIT,
+      "limit"
+    );
+    const matchesScope = (source, date) => {
+      if (options.source !== void 0 && source !== options.source) return false;
+      if (options.from !== void 0 && date < options.from) return false;
+      if (options.to !== void 0 && date > options.to) return false;
+      return true;
+    };
+    if (this.deps.searchBackend) {
+      const hits = await this.deps.searchBackend.search(trimmed, limit * 5);
+      if (hits !== null) {
+        const results2 = [];
+        for (const hit of hits) {
+          const located = locateTranscriptPath(hit.path);
+          if (!located) continue;
+          if (!matchesScope(located.source, located.date)) continue;
+          results2.push({
+            source: located.source,
+            date: located.date,
+            score: hit.score,
+            snippet: hit.preview,
+            backend: "indexed"
+          });
+          if (results2.length >= limit) break;
+        }
+        if (results2.length > 0) {
+          return results2;
+        }
+      }
+    }
+    const storage = await this.deps.getStorage();
+    const days = await storage.listWearableTranscriptDays(options.source);
+    const needle = trimmed.toLowerCase();
+    const results = [];
+    for (const { source, date } of days) {
+      if (!matchesScope(source, date)) continue;
+      const raw = await storage.readWearableDayTranscript(source, date);
+      if (raw === null) continue;
+      const body = parseDayTranscript(raw)?.body ?? raw;
+      const lower = body.toLowerCase();
+      const index = lower.indexOf(needle);
+      if (index === -1) continue;
+      results.push({
+        source,
+        date,
+        score: 0,
+        snippet: extractSnippet(body, index, needle.length),
+        backend: "scan"
+      });
+      if (results.length >= limit) break;
+    }
+    return results;
+  }
+  /**
+   * Memories created from wearable transcripts, filterable by source
+   * and/or day. Includes pending_review candidates — the whole point of
+   * review mode is seeing what's queued.
+   */
+  async transcriptMemories(options = {}) {
+    if (options.date !== void 0 && !isValidTranscriptDate(options.date)) {
+      throw new WearablesInputError(`invalid date '${options.date}' \u2014 expected YYYY-MM-DD`);
+    }
+    if (options.source !== void 0) assertValidSourceId(options.source);
+    const limit = clampLimit(
+      options.limit,
+      MEMORY_LIST_DEFAULT_LIMIT,
+      MEMORY_LIST_MAX_LIMIT,
+      "limit"
+    );
+    const storage = await this.deps.getStorage();
+    const memories = await storage.readAllMemories();
+    const results = [];
+    for (const memory of memories) {
+      const source = memory.frontmatter.source;
+      if (typeof source !== "string" || !source.startsWith(`${WEARABLE_SOURCE_PREFIX}:`)) {
+        continue;
+      }
+      const attrs = memory.frontmatter.structuredAttributes ?? {};
+      const sourceId = attrs.wearableSource;
+      if (options.source !== void 0) {
+        if (sourceId !== options.source && source !== wearableSourceLabel(options.source) && source !== `${wearableSourceLabel(options.source)}:native`) {
+          continue;
+        }
+      }
+      if (options.date !== void 0 && attrs.wearableDate !== options.date) {
+        continue;
+      }
+      results.push({
+        id: memory.frontmatter.id,
+        source: sourceId ?? source,
+        date: attrs.wearableDate,
+        conversationId: attrs.wearableConversationId,
+        status: memory.frontmatter.status,
+        content: memory.content,
+        created: memory.frontmatter.created
+      });
+    }
+    results.sort((a, b) => {
+      if (a.created > b.created) return -1;
+      if (a.created < b.created) return 1;
+      if (a.id < b.id) return -1;
+      if (a.id > b.id) return 1;
+      return 0;
+    });
+    return results.slice(0, limit);
+  }
+  // -- speakers -------------------------------------------------------------
+  async listSpeakers() {
+    const storage = await this.deps.getStorage();
+    return loadSpeakerRegistry(storage.dir);
+  }
+  async setSpeaker(sourceId, speakerKey, name, opts = {}) {
+    if (typeof name !== "string" || name.trim().length === 0) {
+      throw new WearablesInputError("speaker name must be a non-empty string");
+    }
+    if (typeof speakerKey !== "string" || speakerKey.trim().length === 0) {
+      throw new WearablesInputError("speaker key must be a non-empty string");
+    }
+    const storage = await this.deps.getStorage();
+    const registry = await loadSpeakerRegistry(storage.dir);
+    registry.speakers[speakerRegistryKey(sourceId, speakerKey.trim())] = {
+      name: name.trim(),
+      ...opts.isSelf === true ? { isSelf: true } : {},
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await saveSpeakerRegistry(storage.dir, registry);
+    return registry;
+  }
+  async setSelfName(name) {
+    if (typeof name !== "string" || name.trim().length === 0) {
+      throw new WearablesInputError("self name must be a non-empty string");
+    }
+    const storage = await this.deps.getStorage();
+    const registry = await loadSpeakerRegistry(storage.dir);
+    registry.selfName = name.trim();
+    await saveSpeakerRegistry(storage.dir, registry);
+    return registry;
+  }
+  async removeSpeaker(sourceId, speakerKey) {
+    const storage = await this.deps.getStorage();
+    const registry = await loadSpeakerRegistry(storage.dir);
+    const key = speakerRegistryKey(sourceId, speakerKey.trim());
+    if (!(key in registry.speakers)) {
+      throw new WearablesInputError(`no speaker override stored for '${key}'`);
+    }
+    delete registry.speakers[key];
+    await saveSpeakerRegistry(storage.dir, registry);
+    return registry;
+  }
+  // -- corrections ----------------------------------------------------------
+  async listCorrections() {
+    const storage = await this.deps.getStorage();
+    return {
+      fromConfig: this.deps.config.corrections,
+      fromState: await loadCorrectionsFile(storage.dir),
+      stateFilePath: correctionsFilePath(storage.dir)
+    };
+  }
+  async addCorrection(rule) {
+    compileCorrectionRule(rule, "correction");
+    const storage = await this.deps.getStorage();
+    const rules = await loadCorrectionsFile(storage.dir);
+    const duplicate = rules.some(
+      (existing) => existing.match === rule.match && existing.replace === rule.replace && existing.regex === true === (rule.regex === true)
+    );
+    if (duplicate) {
+      throw new WearablesInputError(
+        `an identical correction rule already exists (match: ${JSON.stringify(rule.match)})`
+      );
+    }
+    rules.push(rule);
+    await saveCorrectionsFile(storage.dir, rules);
+  }
+  async removeCorrection(index) {
+    if (!Number.isInteger(index) || index < 0) {
+      throw new WearablesInputError(`invalid correction index '${index}'`);
+    }
+    const storage = await this.deps.getStorage();
+    const rules = await loadCorrectionsFile(storage.dir);
+    if (index >= rules.length) {
+      throw new WearablesInputError(
+        `correction index ${index} is out of range (have ${rules.length} state rule${rules.length === 1 ? "" : "s"})`
+      );
+    }
+    const [removed] = rules.splice(index, 1);
+    await saveCorrectionsFile(storage.dir, rules);
+    return removed;
+  }
+};
+function clampLimit(value, fallback, max, label) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 1 || value > max) {
+    throw new WearablesInputError(
+      `invalid ${label} '${value}' \u2014 expected an integer between 1 and ${max}`
+    );
+  }
+  return value;
+}
+function locateTranscriptPath(hitPath) {
+  const normalized = hitPath.replace(/\\/g, "/");
+  const match = normalized.match(
+    /(?:^|\/)wearables\/([a-z][a-z0-9-]{0,63})\/(\d{4}-\d{2}-\d{2})\.md$/
+  );
+  if (!match) return null;
+  if (!isValidTranscriptDate(match[2])) return null;
+  return { source: match[1], date: match[2] };
+}
+function extractSnippet(body, index, matchLength) {
+  const start = Math.max(0, index - 80);
+  const end = Math.min(body.length, index + matchLength + 80);
+  const prefix = start > 0 ? "\u2026" : "";
+  const suffix = end < body.length ? "\u2026" : "";
+  return `${prefix}${body.slice(start, end).replace(/\s+/g, " ").trim()}${suffix}`;
+}
+
 // src/orchestrator.ts
 function dedupeEntitySynthesisEvidenceEntries(entries) {
   const dedupedEvidenceEntries = [];
@@ -1072,7 +2391,7 @@ async function qmdStartupCollectionCheckWithTimeout(promise, controller, label)
   return await Promise.race([checkedPromise, timeoutPromise]);
 }
 function defaultWorkspaceDir() {
-  return path2.join(os.homedir(), ".openclaw", "workspace");
+  return path3.join(os.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -1381,11 +2700,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path2.isAbsolute(candidatePath) ? candidatePath : path2.resolve(storageDir, candidatePath);
-  const rel = path2.relative(storageDir, absolutePath);
+  const absolutePath = path3.isAbsolute(candidatePath) ? candidatePath : path3.resolve(storageDir, candidatePath);
+  const rel = path3.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path2.sep).join("/");
+  return rel.split(path3.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -1527,7 +2846,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path2.relative(storageDir, mem.path));
+    pathById.set(id, path3.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -1535,7 +2854,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path2.join(options.storageDir, options.memoryRelPath),
+    path: path3.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -1555,16 +2874,16 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path2.join("corrections", `${options.memoryId}.md`);
+    return path3.join("corrections", `${options.memoryId}.md`);
   }
   const subtree = options.category === "procedure" ? "procedures" : options.category === "reasoning_trace" ? "reasoning-traces" : "facts";
   const idParts = options.memoryId.split("-");
   const maybeTimestamp = Number(idParts[1]);
   if (Number.isFinite(maybeTimestamp) && maybeTimestamp > 0) {
     const day = new Date(maybeTimestamp).toISOString().slice(0, 10);
-    return path2.join(subtree, day, `${options.memoryId}.md`);
+    return path3.join(subtree, day, `${options.memoryId}.md`);
   }
-  return path2.join(subtree, `${options.memoryId}.md`);
+  return path3.join(subtree, `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -1683,6 +3002,7 @@ var Orchestrator = class _Orchestrator {
   consolidationInFlight = false;
   consolidationObservers = /* @__PURE__ */ new Set();
   qmdMaintenanceTimer = null;
+  wearablesServiceInstance = null;
   qmdMaintenancePending = false;
   qmdMaintenanceInFlight = false;
   lastQmdEmbedAtMs = 0;
@@ -2001,7 +3321,7 @@ var Orchestrator = class _Orchestrator {
     this.config = config;
     this.profiler = new ProfilingCollector({
       enabled: config.profilingEnabled,
-      storageDir: config.profilingStorageDir || path2.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path3.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.storageRouter = new NamespaceStorageRouter(config);
@@ -2036,7 +3356,7 @@ var Orchestrator = class _Orchestrator {
     this.compounding = config.compoundingEnabled ? new CompoundingEngine(config, this.storage) : void 0;
     this.buffer = new SmartBuffer(config, this.storage);
     this.transcript = new TranscriptManager(config);
-    this.conversationIndexDir = path2.join(
+    this.conversationIndexDir = path3.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -2093,7 +3413,7 @@ var Orchestrator = class _Orchestrator {
       this.modelRegistry
     );
     this.threading = new ThreadingManager(
-      path2.join(config.memoryDir, "threads"),
+      path3.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     this.tmtBuilder = new TmtBuilder(config.memoryDir, {
@@ -2376,7 +3696,7 @@ var Orchestrator = class _Orchestrator {
           const files = await readdir(wsDir).catch(() => []);
           for (const f of files) {
             if (!f.startsWith(".compaction-reset-signal-")) continue;
-            const fp = path2.join(wsDir, f);
+            const fp = path3.join(wsDir, f);
             const s = await stat(fp).catch(() => null);
             if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
               await unlink(fp).catch(() => {
@@ -2738,7 +4058,7 @@ var Orchestrator = class _Orchestrator {
    */
   async autoRegisterDaySummaryCron() {
     const home = resolveHomeDir();
-    const jobsPath = path2.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug(
@@ -2762,7 +4082,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterNightlyGovernanceCron() {
     const home = resolveHomeDir();
-    const jobsPath = path2.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("nightly governance cron: jobs.json not found, skipping auto-register");
@@ -2784,7 +4104,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterProceduralMiningCron() {
     const home = resolveHomeDir();
-    const jobsPath = path2.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("procedural mining cron: jobs.json not found, skipping auto-register");
@@ -2804,7 +4124,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterContradictionScanCron() {
     const home = resolveHomeDir();
-    const jobsPath = path2.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("contradiction scan cron: jobs.json not found, skipping auto-register");
@@ -2824,7 +4144,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterPatternReinforcementCron() {
     const home = resolveHomeDir();
-    const jobsPath = path2.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("pattern reinforcement cron: jobs.json not found, skipping auto-register");
@@ -2886,7 +4206,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterGraphEdgeDecayCron() {
     const home = resolveHomeDir();
-    const jobsPath = path2.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("graph edge decay cron: jobs.json not found, skipping auto-register");
@@ -2943,15 +4263,15 @@ ${doc.content}` : doc.content,
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path2.isAbsolute(rel) ? rel : path2.join(this.config.workspaceDir, rel);
+        const abs = path3.isAbsolute(rel) ? rel : path3.join(this.config.workspaceDir, rel);
         try {
           const raw = await readFile2(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path2.join(
+            const archiveDir = path3.join(
               this.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path2.basename(abs);
+            const base = path3.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -2976,8 +4296,8 @@ ${doc.content}` : doc.content,
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path2.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir2(path2.dirname(fp), { recursive: true });
+        const fp = path3.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir2(path3.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -3446,16 +4766,16 @@ ${evidenceText}`
     const datesToScan = [yesterday, utcToday].filter(
       (v, i, a) => a.indexOf(v) === i
     );
-    const factsBaseDir = path2.join(storage.dir, "facts");
+    const factsBaseDir = path3.join(storage.dir, "facts");
     const MAX_CHARS = 1e5;
     const facts = [];
     for (const date of datesToScan) {
-      const factsDir = path2.join(factsBaseDir, date);
+      const factsDir = path3.join(factsBaseDir, date);
       try {
         const entries = await readdir(factsDir, { withFileTypes: true });
         for (const entry of entries) {
           if (!entry.name.endsWith(".md")) continue;
-          const fullPath = path2.join(factsDir, entry.name);
+          const fullPath = path3.join(factsDir, entry.name);
           try {
             const raw = await readFile2(fullPath, "utf-8");
             const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
@@ -3471,7 +4791,7 @@ ${evidenceText}`
             facts.push({
               path: fullPath,
               frontmatter: {
-                id: fm.id || path2.basename(entry.name, ".md"),
+                id: fm.id || path3.basename(entry.name, ".md"),
                 category: fm.category || "fact",
                 created: fm.created || "unknown",
                 updated: fm.updated || fm.created || "unknown",
@@ -3492,13 +4812,13 @@ ${evidenceText}`
       (a, b) => a.frontmatter.created < b.frontmatter.created ? -1 : 1
     );
     const hourlySummaries = [];
-    const hourlyBaseDir = path2.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path3.join(storage.dir, "summaries", "hourly");
     try {
       const sessionKeys = await readdir(hourlyBaseDir, { withFileTypes: true });
       for (const sk of sessionKeys) {
         if (!sk.isDirectory()) continue;
         for (const date of datesToScan) {
-          const summaryFile = path2.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path3.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile2(summaryFile, "utf-8");
             if (raw.trim().length > 0) {
@@ -3596,7 +4916,7 @@ ${evidenceText}`
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path2.join(
+    const snapshotPath = path3.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
@@ -3635,7 +4955,7 @@ ${evidenceText}`
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path2.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path3.join(storage.dir, "state", "last_intent.json");
     try {
       const raw = await readFile2(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -3668,7 +4988,7 @@ ${evidenceText}`
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path2.join(
+    const snapshotPath = path3.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
@@ -3821,7 +5141,7 @@ ${r.snippet.trim()}
       const entries = await readdir(dir, { withFileTypes: true });
       let total = 0;
       for (const entry of entries) {
-        const fullPath = path2.join(dir, entry.name);
+        const fullPath = path3.join(dir, entry.name);
         if (entry.isDirectory()) {
           total += await this.countConversationChunkDocs(fullPath);
           continue;
@@ -4717,7 +6037,7 @@ ${r.snippet.trim()}
         0
       );
       seedPaths.push(
-        ...seedRelativePaths.map((rel) => path2.join(storage.dir, rel))
+        ...seedRelativePaths.map((rel) => path3.join(storage.dir, rel))
       );
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
@@ -4728,7 +6048,7 @@ ${r.snippet.trim()}
       if (expanded.length === 0) continue;
       for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
         if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path2.resolve(storage.dir, candidate.path);
+        const memoryPath = path3.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (!memory) continue;
         if (isArtifactMemoryPath(memory.path)) continue;
@@ -4752,7 +6072,7 @@ ${r.snippet.trim()}
           path: memory.path,
           score,
           namespace,
-          seed: path2.resolve(storage.dir, candidate.seed),
+          seed: path3.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType,
@@ -4773,12 +6093,12 @@ ${r.snippet.trim()}
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path2.join(
+      const snapshotPath = path3.join(
         options.storage.dir,
         "state",
         "last_graph_recall.json"
       );
-      await mkdir2(path2.dirname(snapshotPath), { recursive: true });
+      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -4812,12 +6132,12 @@ ${r.snippet.trim()}
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path2.join(
+      const snapshotPath = path3.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir2(path2.dirname(snapshotPath), { recursive: true });
+      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
       await writeFile2(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -4829,12 +6149,12 @@ ${r.snippet.trim()}
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path2.join(
+      const snapshotPath = path3.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir2(path2.dirname(snapshotPath), { recursive: true });
+      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
       await writeFile2(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -4849,8 +6169,8 @@ ${r.snippet.trim()}
       const stateDir = await this.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path2.join(stateDir, "last_intent.json");
-      await mkdir2(path2.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path3.join(stateDir, "last_intent.json");
+      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
       await writeFile2(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -4862,12 +6182,12 @@ ${r.snippet.trim()}
   }
   async resolveStateDirForNamespace(namespace) {
     if (!this.config.namespacesEnabled) {
-      return path2.join(this.config.memoryDir, "state");
+      return path3.join(this.config.memoryDir, "state");
     }
     if (namespace !== this.config.defaultNamespace) {
-      return path2.join(this.config.memoryDir, "namespaces", namespace, "state");
+      return path3.join(this.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path2.join(
+    const candidate = path3.join(
       this.config.memoryDir,
       "namespaces",
       this.config.defaultNamespace
@@ -4875,11 +6195,11 @@ ${r.snippet.trim()}
     try {
       const candidateStat = await stat(candidate);
       if (candidateStat.isDirectory()) {
-        return path2.join(candidate, "state");
+        return path3.join(candidate, "state");
       }
     } catch {
     }
-    return path2.join(this.config.memoryDir, "state");
+    return path3.join(this.config.memoryDir, "state");
   }
   buildGraphRecallRankedResults(results, sourceLabelResolver, limit = 64) {
     return results.slice(0, limit).map((result) => ({
@@ -5265,7 +6585,7 @@ ${r.snippet.trim()}
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path2.sep).join("/");
+        const normalizedPath = resultPath.split(path3.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -6580,11 +7900,11 @@ ${formatted}`;
         if (!this.config.compactionResetEnabled) return null;
         const workspaceDir = compactionWorkspaceDir || this.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path2.join(
+        const signalPath = path3.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path2.join(workspaceDir, "BOOT.md");
+        const bootPath = path3.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
@@ -8447,6 +9767,41 @@ _Context: ${topQuestion.context}_`
   bulkImportWriteNamespace() {
     return this.config.defaultNamespace;
   }
+  /**
+   * Lazily-constructed wearables service (Limitless / Bee / Omi
+   * transcript ingestion). All wearables surfaces — CLI, MCP tools,
+   * HTTP routes — share this one instance so sync state, search, and
+   * memory writes stay consistent. Writes are pinned to the same
+   * deterministic namespace bulk-import uses.
+   */
+  getWearablesService() {
+    if (!this.wearablesServiceInstance) {
+      this.wearablesServiceInstance = new WearablesService({
+        config: this.config.wearables,
+        getStorage: async () => await this.getStorageForNamespace(this.bulkImportWriteNamespace()),
+        extract: (turns) => this.extraction.extract(turns),
+        searchBackend: {
+          search: async (query, maxResults) => {
+            if (!this.qmd.isAvailable()) return null;
+            try {
+              const results = await this.qmd.search(query, void 0, maxResults);
+              return results.map((result) => ({
+                path: result.path,
+                score: result.score,
+                preview: result.snippet
+              }));
+            } catch {
+              return null;
+            }
+          }
+        },
+        reindexSearch: async () => {
+          await this.qmd.update();
+        }
+      });
+    }
+    return this.wearablesServiceInstance;
+  }
   /**
    * Ingest a batch of bulk-import turns (#460). Like ingestReplayBatch, this
    * normalizes user/assistant turns into the extraction buffer and awaits
@@ -9015,7 +10370,7 @@ ${normalized}`).digest("hex");
     );
     this.tierMigrationInFlight = true;
     try {
-      const coldStorage = new StorageManager(path2.join(storage.dir, "cold"));
+      const coldStorage = new StorageManager(path3.join(storage.dir, "cold"));
       const [hotMemories, coldMemories] = await Promise.all([
         storage.readAllMemories(),
         coldStorage.readAllMemories()
@@ -10218,7 +11573,7 @@ ${normalized}`).digest("hex");
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path2.relative(storage.dir, m.path);
+            const rel = path3.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -10518,7 +11873,7 @@ ${normalized}`).digest("hex");
     }
     if (this.config.semanticConsolidationEnabled) {
       try {
-        const stateFilePath = path2.join(
+        const stateFilePath = path3.join(
           this.config.memoryDir,
           "state",
           "semantic-consolidation-last-run.json"
@@ -10566,7 +11921,7 @@ ${normalized}`).digest("hex");
             );
           }
           if (semResult.errors === 0 || semResult.memoriesArchived > 0) {
-            const stateDir = path2.join(this.config.memoryDir, "state");
+            const stateDir = path3.join(this.config.memoryDir, "state");
             await mkdir2(stateDir, { recursive: true });
             await writeFile2(
               stateFilePath,
@@ -11061,12 +12416,12 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
         protectedCategories: this.config.lifecycleProtectedCategories
       }
     };
-    const metricsPath = path2.join(
+    const metricsPath = path3.join(
       storage.dir,
       "state",
       "lifecycle-metrics.json"
     );
-    await mkdir2(path2.dirname(metricsPath), { recursive: true });
+    await mkdir2(path3.dirname(metricsPath), { recursive: true });
     await writeFile2(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
   }
   /**
@@ -11594,7 +12949,7 @@ ${lines.join("\n\n")}`;
           nsMap = buildMemoryWorthCounterMap(memories);
           this.memoryWorthCounterCache.set(ns, { at: nowMs, counters: nsMap });
         }
-        for (const [path3, c] of nsMap) counters.set(path3, c);
+        for (const [path4, c] of nsMap) counters.set(path4, c);
       } catch (err) {
         log.debug("memory-worth: failed to read namespace, skipping", {
           namespace: ns,
@@ -11765,12 +13120,12 @@ ${lines.join("\n\n")}`;
    */
   semanticDedupScopeFor(targetStorage) {
     if (!this.config.namespacesEnabled) return {};
-    const memoryDir = path2.resolve(this.config.memoryDir);
-    const storageDir = path2.resolve(targetStorage.dir);
+    const memoryDir = path3.resolve(this.config.memoryDir);
+    const storageDir = path3.resolve(targetStorage.dir);
     if (storageDir === memoryDir) {
       return { pathExcludePrefixes: ["namespaces/"] };
     }
-    let rel = path2.relative(memoryDir, storageDir);
+    let rel = path3.relative(memoryDir, storageDir);
     if (!rel || rel.startsWith("..")) {
       log.debug(
         `semantic dedup: target storage dir ${storageDir} is outside memoryDir ${memoryDir}; scoping lookup to absolute path prefix`
@@ -11789,7 +13144,7 @@ ${lines.join("\n\n")}`;
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path2.isAbsolute(hit.path) ? hit.path : path2.join(this.config.memoryDir, hit.path);
+      const fullPath = path3.isAbsolute(hit.path) ? hit.path : path3.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -12432,8 +13787,8 @@ ${lines.join("\n\n")}`;
   }
   namespaceFromStorageDir(storageDir) {
     if (!this.config.namespacesEnabled) return this.config.defaultNamespace;
-    const resolvedStorageDir = path2.resolve(storageDir);
-    const resolvedMemoryDir = path2.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path3.resolve(storageDir);
+    const resolvedMemoryDir = path3.resolve(this.config.memoryDir);
     if (resolvedStorageDir === resolvedMemoryDir)
       return this.config.defaultNamespace;
     const m = resolvedStorageDir.match(/[\\/]namespaces[\\/]([^\\/]+)$/);
@@ -12473,6 +13828,34 @@ export {
   saveTaxonomy,
   getTaxonomyDir,
   getTaxonomyFilePath,
+  memoryStatusForMode,
+  WEARABLE_SOURCE_PREFIX,
+  wearableSourceLabel,
+  wearableDayTag,
+  buildExtractionTurns,
+  generateWearableMemories,
+  writeDailyDigestMemory,
+  importNativeMemories,
+  cleanConversation,
+  stripFillerTokens,
+  collapseImmediateRepeats,
+  isLowQualitySegment,
+  syncStateFilePath,
+  emptySyncState,
+  loadSyncState,
+  saveSyncState,
+  updateSourceSyncState,
+  dateInTimezone,
+  resolveSyncDates,
+  syncWearableSource,
+  defaultTimezone,
+  registerWearableConnector,
+  getWearableConnector,
+  listWearableConnectors,
+  clearWearableConnectors,
+  ensureBuiltInWearableConnectors,
+  WearablesService,
+  locateTranscriptPath,
   dedupeEntitySynthesisEvidenceEntries,
   defaultWorkspaceDir,
   sanitizeSessionKeyForFilename,
@@ -12502,4 +13885,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-RKW6QR7W.js.map
+//# sourceMappingURL=chunk-AZ4RI3QD.js.map