@remnic/core 9.3.630 → 9.3.631

package/dist/{chunk-YJOWWRRS.js → chunk-WLZBVYC6.js}

@@ -1,3 +1,10 @@
+import {
+  WEARABLE_SOURCE_PREFIX,
+  defaultTimezone,
+  loadSyncState,
+  syncWearableSource,
+  wearableSourceLabel
+} from "./chunk-KVDUDYEN.js";
 import {
   migrateFromEngram
 } from "./chunk-4HFJQCJZ.js";
@@ -22,7 +29,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-UE57H4MA.js";
+} from "./chunk-UXFOGILU.js";
 import {
   SharedContextManager
 } from "./chunk-DRD2Q7HQ.js";
@@ -168,7 +175,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-6LBQL5US.js";
+} from "./chunk-JCLECECB.js";
 import {
   buildEventOrderRecallSection,
   shouldRecallEventOrderEvidence
@@ -203,7 +210,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-OOFBE62K.js";
+} from "./chunk-X7EJF46S.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-2PRQG7PV.js";
@@ -212,13 +219,13 @@ import {
 } from "./chunk-X6IRLNOO.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-ZZSXUZF3.js";
+} from "./chunk-YROCXMCK.js";
 import {
   ThreadingManager
 } from "./chunk-W4RVMTHR.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-SACS6KE6.js";
+} from "./chunk-4S3N6HFG.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -237,7 +244,7 @@ import {
 } from "./chunk-CYEPCZN5.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-S5W37FPX.js";
+} from "./chunk-LEG7XWS2.js";
 import {
   namespaceIdentityFromToken
 } from "./chunk-ZFXCQPNO.js";
@@ -286,14 +293,9 @@ import {
   fallbackLlmRuntimeContextFromConfig
 } from "./chunk-723OMPUI.js";
 import {
-  applyCorrections,
-  applyOffTheRecord,
   compileCorrectionRule,
-  compileCorrectionRules,
-  compileRedactionPatterns,
   correctionsFilePath,
   loadCorrectionsFile,
-  redactText,
   saveCorrectionsFile
 } from "./chunk-NDAH7BJ5.js";
 import {
@@ -351,27 +353,24 @@ import {
 } from "./chunk-XL7FK7PJ.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-GXWFZYSR.js";
+} from "./chunk-CMN5AWAZ.js";
 import {
   ContentHashIndex,
   StorageManager,
   compareEntityTimestamps,
-  composeDayTranscriptBody,
-  composeDayTranscriptMeta,
   fingerprintEntityStructuredFacts,
-  hashTranscriptBody,
-  isValidTranscriptDate,
-  loadSpeakerRegistry,
   normalizeAttributePairs,
   normalizeEntityName,
-  parseDayTranscript,
   parseEntityFile,
-  resolveSpeaker,
-  saveSpeakerRegistry,
-  serializeDayTranscript,
-  speakerRegistryKey,
   stripAttributesSuffix
-} from "./chunk-RSKUUEBA.js";
+} from "./chunk-QYGIQ5NM.js";
+import {
+  isValidTranscriptDate,
+  loadSpeakerRegistry,
+  parseDayTranscript,
+  saveSpeakerRegistry,
+  speakerRegistryKey
+} from "./chunk-M7XQSUBB.js";
 import {
   attachCitation,
   hasCitationForTemplate,
@@ -410,10 +409,6 @@ import {
   decideLifecycleTransition,
   resolveLifecycleState
 } from "./chunk-TBBDFYXW.js";
-import {
-  countRecallTokenOverlap,
-  normalizeRecallTokens
-} from "./chunk-ZBJMUXZH.js";
 import {
   log
 } from "./chunk-2ODBA7MQ.js";
@@ -429,7 +424,7 @@ import {
 } from "./chunk-AC5LO7IU.js";
 
 // src/orchestrator.ts
-import path3 from "path";
+import path2 from "path";
 import os from "os";
 import { createHash, randomBytes } from "crypto";
 import { existsSync } from "fs";
@@ -971,1096 +966,6 @@ function getTaxonomyFilePath(memoryDir) {
   return path.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
-// 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 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,
-    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;
-      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,
-          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;
-        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`
-          );
-        }
-      }
-    }
-  }
-  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";
-  }
-}
-
 // src/wearables/registry.ts
 var registrations = /* @__PURE__ */ new Map();
 function registerWearableConnector(registration) {
@@ -2763,7 +1668,7 @@ async function qmdStartupCollectionCheckWithTimeout(promise, controller, label)
   return await Promise.race([checkedPromise, timeoutPromise]);
 }
 function defaultWorkspaceDir() {
-  return path3.join(os.homedir(), ".openclaw", "workspace");
+  return path2.join(os.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -3072,11 +1977,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path3.isAbsolute(candidatePath) ? candidatePath : path3.resolve(storageDir, candidatePath);
-  const rel = path3.relative(storageDir, absolutePath);
+  const absolutePath = path2.isAbsolute(candidatePath) ? candidatePath : path2.resolve(storageDir, candidatePath);
+  const rel = path2.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path3.sep).join("/");
+  return rel.split(path2.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -3218,7 +2123,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path3.relative(storageDir, mem.path));
+    pathById.set(id, path2.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -3226,7 +2131,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path3.join(options.storageDir, options.memoryRelPath),
+    path: path2.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -3246,16 +2151,16 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path3.join("corrections", `${options.memoryId}.md`);
+    return path2.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 path3.join(subtree, day, `${options.memoryId}.md`);
+    return path2.join(subtree, day, `${options.memoryId}.md`);
   }
-  return path3.join(subtree, `${options.memoryId}.md`);
+  return path2.join(subtree, `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -3375,6 +2280,7 @@ var Orchestrator = class _Orchestrator {
   consolidationObservers = /* @__PURE__ */ new Set();
   qmdMaintenanceTimer = null;
   wearablesServiceInstance = null;
+  wearablesAutoSyncHandle = null;
   qmdMaintenancePending = false;
   qmdMaintenanceInFlight = false;
   lastQmdEmbedAtMs = 0;
@@ -3449,6 +2355,10 @@ var Orchestrator = class _Orchestrator {
    */
   async destroy() {
     this.abortDeferredInit();
+    if (this.wearablesAutoSyncHandle) {
+      await this.wearablesAutoSyncHandle.stop();
+      this.wearablesAutoSyncHandle = null;
+    }
     if (this.qmdMaintenanceTimer) {
       clearTimeout(this.qmdMaintenanceTimer);
       this.qmdMaintenanceTimer = null;
@@ -3693,7 +2603,7 @@ var Orchestrator = class _Orchestrator {
     this.config = config;
     this.profiler = new ProfilingCollector({
       enabled: config.profilingEnabled,
-      storageDir: config.profilingStorageDir || path3.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path2.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.storageRouter = new NamespaceStorageRouter(config);
@@ -3728,7 +2638,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 = path3.join(
+    this.conversationIndexDir = path2.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -3785,7 +2695,7 @@ var Orchestrator = class _Orchestrator {
       this.modelRegistry
     );
     this.threading = new ThreadingManager(
-      path3.join(config.memoryDir, "threads"),
+      path2.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     this.tmtBuilder = new TmtBuilder(config.memoryDir, {
@@ -4083,7 +2993,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 = path3.join(wsDir, f);
+            const fp = path2.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(() => {
@@ -4338,6 +3248,36 @@ var Orchestrator = class _Orchestrator {
         log.warn(`first-start lifecycle migration failed (non-fatal): ${err}`);
       }
     }
+    if (signal.aborted) return;
+    if (!this.wearablesAutoSyncHandle && this.config.wearables.enabled && this.config.wearables.autoSyncEnabled && Object.values(this.config.wearables.sources).some((source) => source.enabled)) {
+      try {
+        const { startWearablesAutoSync } = await import("./auto-sync-RFADEHIQ.js");
+        if (signal.aborted) return;
+        this.wearablesAutoSyncHandle = startWearablesAutoSync(
+          {
+            intervalMinutes: this.config.wearables.autoSyncIntervalMinutes,
+            days: this.config.wearables.autoSyncDays,
+            deepDays: this.config.wearables.autoSyncDeepDays,
+            ...this.config.wearables.timezone !== void 0 ? { timezone: this.config.wearables.timezone } : {}
+          },
+          {
+            sync: (options) => this.getWearablesService().sync(options),
+            log: {
+              info: (message) => log.info(message),
+              warn: (message) => log.warn(message)
+            }
+          }
+        );
+        log.info(
+          `wearables auto-sync started: every ${this.config.wearables.autoSyncIntervalMinutes}m over ${this.config.wearables.autoSyncDays}d (deep ${this.config.wearables.autoSyncDeepDays}d daily)`
+        );
+      } catch (err) {
+        const { displayErrorDetail } = await import("./runtime/better-sqlite.js");
+        log.warn(
+          `wearables auto-sync failed to start (non-fatal): ${displayErrorDetail(err)}`
+        );
+      }
+    }
     log.info("orchestrator initialized (full \u2014 deferred steps complete)");
   }
   /**
@@ -4445,7 +3385,7 @@ var Orchestrator = class _Orchestrator {
    */
   async autoRegisterDaySummaryCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path2.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug(
@@ -4469,7 +3409,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterNightlyGovernanceCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path2.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("nightly governance cron: jobs.json not found, skipping auto-register");
@@ -4491,7 +3431,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterProceduralMiningCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path2.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("procedural mining cron: jobs.json not found, skipping auto-register");
@@ -4511,7 +3451,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterContradictionScanCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path2.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("contradiction scan cron: jobs.json not found, skipping auto-register");
@@ -4531,7 +3471,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterPatternReinforcementCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path2.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("pattern reinforcement cron: jobs.json not found, skipping auto-register");
@@ -4593,7 +3533,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterGraphEdgeDecayCron() {
     const home = resolveHomeDir();
-    const jobsPath = path3.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path2.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync(jobsPath)) {
         log.debug("graph edge decay cron: jobs.json not found, skipping auto-register");
@@ -4650,15 +3590,15 @@ ${doc.content}` : doc.content,
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path3.isAbsolute(rel) ? rel : path3.join(this.config.workspaceDir, rel);
+        const abs = path2.isAbsolute(rel) ? rel : path2.join(this.config.workspaceDir, rel);
         try {
           const raw = await readFile2(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path3.join(
+            const archiveDir = path2.join(
               this.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path3.basename(abs);
+            const base = path2.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -4683,8 +3623,8 @@ ${doc.content}` : doc.content,
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path3.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir2(path3.dirname(fp), { recursive: true });
+        const fp = path2.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir2(path2.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -5153,16 +4093,16 @@ ${evidenceText}`
     const datesToScan = [yesterday, utcToday].filter(
       (v, i, a) => a.indexOf(v) === i
     );
-    const factsBaseDir = path3.join(storage.dir, "facts");
+    const factsBaseDir = path2.join(storage.dir, "facts");
     const MAX_CHARS = 1e5;
     const facts = [];
     for (const date of datesToScan) {
-      const factsDir = path3.join(factsBaseDir, date);
+      const factsDir = path2.join(factsBaseDir, date);
       try {
         const entries = await readdir(factsDir, { withFileTypes: true });
         for (const entry of entries) {
           if (!entry.name.endsWith(".md")) continue;
-          const fullPath = path3.join(factsDir, entry.name);
+          const fullPath = path2.join(factsDir, entry.name);
           try {
             const raw = await readFile2(fullPath, "utf-8");
             const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
@@ -5178,7 +4118,7 @@ ${evidenceText}`
             facts.push({
               path: fullPath,
               frontmatter: {
-                id: fm.id || path3.basename(entry.name, ".md"),
+                id: fm.id || path2.basename(entry.name, ".md"),
                 category: fm.category || "fact",
                 created: fm.created || "unknown",
                 updated: fm.updated || fm.created || "unknown",
@@ -5199,13 +4139,13 @@ ${evidenceText}`
       (a, b) => a.frontmatter.created < b.frontmatter.created ? -1 : 1
     );
     const hourlySummaries = [];
-    const hourlyBaseDir = path3.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path2.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 = path3.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path2.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile2(summaryFile, "utf-8");
             if (raw.trim().length > 0) {
@@ -5303,7 +4243,7 @@ ${evidenceText}`
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path3.join(
+    const snapshotPath = path2.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
@@ -5342,7 +4282,7 @@ ${evidenceText}`
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path3.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path2.join(storage.dir, "state", "last_intent.json");
     try {
       const raw = await readFile2(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -5375,7 +4315,7 @@ ${evidenceText}`
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path3.join(
+    const snapshotPath = path2.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
@@ -5528,7 +4468,7 @@ ${r.snippet.trim()}
       const entries = await readdir(dir, { withFileTypes: true });
       let total = 0;
       for (const entry of entries) {
-        const fullPath = path3.join(dir, entry.name);
+        const fullPath = path2.join(dir, entry.name);
         if (entry.isDirectory()) {
           total += await this.countConversationChunkDocs(fullPath);
           continue;
@@ -6424,7 +5364,7 @@ ${r.snippet.trim()}
         0
       );
       seedPaths.push(
-        ...seedRelativePaths.map((rel) => path3.join(storage.dir, rel))
+        ...seedRelativePaths.map((rel) => path2.join(storage.dir, rel))
       );
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
@@ -6435,7 +5375,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 = path3.resolve(storage.dir, candidate.path);
+        const memoryPath = path2.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (!memory) continue;
         if (isArtifactMemoryPath(memory.path)) continue;
@@ -6459,7 +5399,7 @@ ${r.snippet.trim()}
           path: memory.path,
           score,
           namespace,
-          seed: path3.resolve(storage.dir, candidate.seed),
+          seed: path2.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType,
@@ -6480,12 +5420,12 @@ ${r.snippet.trim()}
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path3.join(
+      const snapshotPath = path2.join(
         options.storage.dir,
         "state",
         "last_graph_recall.json"
       );
-      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
+      await mkdir2(path2.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -6519,12 +5459,12 @@ ${r.snippet.trim()}
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path3.join(
+      const snapshotPath = path2.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
+      await mkdir2(path2.dirname(snapshotPath), { recursive: true });
       await writeFile2(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -6536,12 +5476,12 @@ ${r.snippet.trim()}
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path3.join(
+      const snapshotPath = path2.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
+      await mkdir2(path2.dirname(snapshotPath), { recursive: true });
       await writeFile2(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -6556,8 +5496,8 @@ ${r.snippet.trim()}
       const stateDir = await this.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path3.join(stateDir, "last_intent.json");
-      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path2.join(stateDir, "last_intent.json");
+      await mkdir2(path2.dirname(snapshotPath), { recursive: true });
       await writeFile2(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -6569,12 +5509,12 @@ ${r.snippet.trim()}
   }
   async resolveStateDirForNamespace(namespace) {
     if (!this.config.namespacesEnabled) {
-      return path3.join(this.config.memoryDir, "state");
+      return path2.join(this.config.memoryDir, "state");
     }
     if (namespace !== this.config.defaultNamespace) {
-      return path3.join(this.config.memoryDir, "namespaces", namespace, "state");
+      return path2.join(this.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path3.join(
+    const candidate = path2.join(
       this.config.memoryDir,
       "namespaces",
       this.config.defaultNamespace
@@ -6582,11 +5522,11 @@ ${r.snippet.trim()}
     try {
       const candidateStat = await stat(candidate);
       if (candidateStat.isDirectory()) {
-        return path3.join(candidate, "state");
+        return path2.join(candidate, "state");
       }
     } catch {
     }
-    return path3.join(this.config.memoryDir, "state");
+    return path2.join(this.config.memoryDir, "state");
   }
   buildGraphRecallRankedResults(results, sourceLabelResolver, limit = 64) {
     return results.slice(0, limit).map((result) => ({
@@ -6972,7 +5912,7 @@ ${r.snippet.trim()}
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path3.sep).join("/");
+        const normalizedPath = resultPath.split(path2.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -8287,11 +7227,11 @@ ${formatted}`;
         if (!this.config.compactionResetEnabled) return null;
         const workspaceDir = compactionWorkspaceDir || this.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path3.join(
+        const signalPath = path2.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path3.join(workspaceDir, "BOOT.md");
+        const bootPath = path2.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
@@ -10772,7 +9712,7 @@ ${normalized}`).digest("hex");
     );
     this.tierMigrationInFlight = true;
     try {
-      const coldStorage = new StorageManager(path3.join(storage.dir, "cold"));
+      const coldStorage = new StorageManager(path2.join(storage.dir, "cold"));
       const [hotMemories, coldMemories] = await Promise.all([
         storage.readAllMemories(),
         coldStorage.readAllMemories()
@@ -11975,7 +10915,7 @@ ${normalized}`).digest("hex");
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path3.relative(storage.dir, m.path);
+            const rel = path2.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -12275,7 +11215,7 @@ ${normalized}`).digest("hex");
     }
     if (this.config.semanticConsolidationEnabled) {
       try {
-        const stateFilePath = path3.join(
+        const stateFilePath = path2.join(
           this.config.memoryDir,
           "state",
           "semantic-consolidation-last-run.json"
@@ -12323,7 +11263,7 @@ ${normalized}`).digest("hex");
             );
           }
           if (semResult.errors === 0 || semResult.memoriesArchived > 0) {
-            const stateDir = path3.join(this.config.memoryDir, "state");
+            const stateDir = path2.join(this.config.memoryDir, "state");
             await mkdir2(stateDir, { recursive: true });
             await writeFile2(
               stateFilePath,
@@ -12818,12 +11758,12 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
         protectedCategories: this.config.lifecycleProtectedCategories
       }
     };
-    const metricsPath = path3.join(
+    const metricsPath = path2.join(
       storage.dir,
       "state",
       "lifecycle-metrics.json"
     );
-    await mkdir2(path3.dirname(metricsPath), { recursive: true });
+    await mkdir2(path2.dirname(metricsPath), { recursive: true });
     await writeFile2(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
   }
   /**
@@ -13351,7 +12291,7 @@ ${lines.join("\n\n")}`;
           nsMap = buildMemoryWorthCounterMap(memories);
           this.memoryWorthCounterCache.set(ns, { at: nowMs, counters: nsMap });
         }
-        for (const [path4, c] of nsMap) counters.set(path4, c);
+        for (const [path3, c] of nsMap) counters.set(path3, c);
       } catch (err) {
         log.debug("memory-worth: failed to read namespace, skipping", {
           namespace: ns,
@@ -13522,12 +12462,12 @@ ${lines.join("\n\n")}`;
    */
   semanticDedupScopeFor(targetStorage) {
     if (!this.config.namespacesEnabled) return {};
-    const memoryDir = path3.resolve(this.config.memoryDir);
-    const storageDir = path3.resolve(targetStorage.dir);
+    const memoryDir = path2.resolve(this.config.memoryDir);
+    const storageDir = path2.resolve(targetStorage.dir);
     if (storageDir === memoryDir) {
       return { pathExcludePrefixes: ["namespaces/"] };
     }
-    let rel = path3.relative(memoryDir, storageDir);
+    let rel = path2.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`
@@ -13546,7 +12486,7 @@ ${lines.join("\n\n")}`;
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path3.isAbsolute(hit.path) ? hit.path : path3.join(this.config.memoryDir, hit.path);
+      const fullPath = path2.isAbsolute(hit.path) ? hit.path : path2.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -14189,8 +13129,8 @@ ${lines.join("\n\n")}`;
   }
   namespaceFromStorageDir(storageDir) {
     if (!this.config.namespacesEnabled) return this.config.defaultNamespace;
-    const resolvedStorageDir = path3.resolve(storageDir);
-    const resolvedMemoryDir = path3.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path2.resolve(storageDir);
+    const resolvedMemoryDir = path2.resolve(this.config.memoryDir);
     if (resolvedStorageDir === resolvedMemoryDir)
       return this.config.defaultNamespace;
     const m = resolvedStorageDir.match(/[\\/]namespaces[\\/]([^\\/]+)$/);
@@ -14230,27 +13170,6 @@ 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,
@@ -14287,4 +13206,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-YJOWWRRS.js.map
+//# sourceMappingURL=chunk-WLZBVYC6.js.map