@remnic/core 9.3.628 → 9.3.630

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

@@ -22,7 +22,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-UELS6WWF.js";
+} from "./chunk-UE57H4MA.js";
 import {
   SharedContextManager
 } from "./chunk-DRD2Q7HQ.js";
@@ -57,7 +57,7 @@ import {
 } from "./chunk-VOUOLGIP.js";
 import {
   HourlySummarizer
-} from "./chunk-3VONWEQB.js";
+} from "./chunk-HZVIYZYN.js";
 import {
   SessionObserverState
 } from "./chunk-MHQC2WU2.js";
@@ -147,10 +147,10 @@ import {
   getVerdictKind,
   judgeFactDurability,
   validateProcedureExtraction
-} from "./chunk-Z3CCEP6F.js";
+} from "./chunk-K47C6M2C.js";
 import {
   ExtractionEngine
-} from "./chunk-MON3LMO7.js";
+} from "./chunk-NRST7W5Q.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-ROZJACKP.js";
@@ -168,7 +168,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-LQYTQCXM.js";
+} from "./chunk-6LBQL5US.js";
 import {
   buildEventOrderRecallSection,
   shouldRecallEventOrderEvidence
@@ -203,7 +203,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-3R2UZV3U.js";
+} from "./chunk-OOFBE62K.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-2PRQG7PV.js";
@@ -212,13 +212,13 @@ import {
 } from "./chunk-X6IRLNOO.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-P2D2MM47.js";
+} from "./chunk-ZZSXUZF3.js";
 import {
   ThreadingManager
 } from "./chunk-W4RVMTHR.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-57QXN2CS.js";
+} from "./chunk-SACS6KE6.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -237,7 +237,7 @@ import {
 } from "./chunk-CYEPCZN5.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-QDV6VAD4.js";
+} from "./chunk-S5W37FPX.js";
 import {
   namespaceIdentityFromToken
 } from "./chunk-ZFXCQPNO.js";
@@ -284,7 +284,7 @@ import {
 import {
   FallbackLlmClient,
   fallbackLlmRuntimeContextFromConfig
-} from "./chunk-KGIGRNR6.js";
+} from "./chunk-723OMPUI.js";
 import {
   applyCorrections,
   applyOffTheRecord,
@@ -349,6 +349,9 @@ import {
 import {
   GraphIndex
 } from "./chunk-XL7FK7PJ.js";
+import {
+  buildChainFollowupGenerator
+} from "./chunk-GXWFZYSR.js";
 import {
   ContentHashIndex,
   StorageManager,
@@ -366,8 +369,9 @@ import {
   resolveSpeaker,
   saveSpeakerRegistry,
   serializeDayTranscript,
-  speakerRegistryKey
-} from "./chunk-UGHUNQ74.js";
+  speakerRegistryKey,
+  stripAttributesSuffix
+} from "./chunk-RSKUUEBA.js";
 import {
   attachCitation,
   hasCitationForTemplate,
@@ -377,6 +381,7 @@ import {
   confidenceTier
 } from "./chunk-FPNQF475.js";
 import {
+  inferMemoryStatus,
   isActiveMemoryStatus
 } from "./chunk-RULE4VG5.js";
 import {
@@ -405,6 +410,10 @@ import {
   decideLifecycleTransition,
   resolveLifecycleState
 } from "./chunk-TBBDFYXW.js";
+import {
+  countRecallTokenOverlap,
+  normalizeRecallTokens
+} from "./chunk-ZBJMUXZH.js";
 import {
   log
 } from "./chunk-2ODBA7MQ.js";
@@ -962,9 +971,75 @@ 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" ? "active" : "pending_review";
+  return mode === "auto" || mode === "smart" ? "active" : "pending_review";
 }
 var WEARABLE_SOURCE_PREFIX = "wearable";
 function wearableSourceLabel(sourceId) {
@@ -1022,12 +1097,56 @@ ${chunkLines.join("\n")}`,
   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: []
+    warnings: [],
+    completed: true
   };
   if (settings.memoryMode === "off") return result;
   const skip = (reason, count = 1) => {
@@ -1046,6 +1165,7 @@ async function generateWearableMemories(sourceId, date, conversations, settings,
       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) {
@@ -1058,7 +1178,7 @@ async function generateWearableMemories(sourceId, date, conversations, settings,
         skip("unsupported-category");
         continue;
       }
-      if (typeof fact.confidence === "number" && fact.confidence < settings.minConfidence) {
+      if (settings.memoryMode !== "smart" && typeof fact.confidence === "number" && fact.confidence < settings.minConfidence) {
         skip("below-confidence");
         continue;
       }
@@ -1077,27 +1197,120 @@ async function generateWearableMemories(sourceId, date, conversations, settings,
     }
   }
   const novel = [];
+  const promotable = [];
   for (const candidate of candidates) {
     if (await deps.writer.hasFactContentHash(candidate.fact.content)) {
-      skip("duplicate-existing");
+      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);
   }
-  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;
+  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 ? novel.slice(0, cap) : novel;
-  if (novel.length > kept.length) {
-    skip("over-day-cap", novel.length - kept.length);
+  const kept = cap > 0 ? writable.slice(0, cap) : writable;
+  if (writable.length > kept.length) {
+    skip("over-day-cap", writable.length - kept.length);
   }
-  const status = memoryStatusForMode(settings.memoryMode);
-  for (const candidate of kept) {
+  for (const { candidate, index, status, trustAttributes } of kept) {
     const tags = [
       .../* @__PURE__ */ new Set([
         ...candidate.fact.tags ?? [],
@@ -1107,7 +1320,7 @@ async function generateWearableMemories(sourceId, date, conversations, settings,
       ])
     ];
     await deps.writer.writeMemory(candidate.fact.category, candidate.fact.content, {
-      confidence: candidate.fact.confidence,
+      confidence: settings.memoryMode === "smart" ? trustById.get(index)?.trust : candidate.fact.confidence,
       tags,
       source: wearableSourceLabel(sourceId),
       importance: candidate.importance,
@@ -1116,7 +1329,8 @@ async function generateWearableMemories(sourceId, date, conversations, settings,
         ...candidate.fact.structuredAttributes ?? {},
         wearableSource: sourceId,
         wearableDate: date,
-        wearableConversationId: candidate.conversation.id
+        wearableConversationId: candidate.conversation.id,
+        ...trustAttributes
       },
       contentHashSource: candidate.fact.content,
       status
@@ -1161,21 +1375,80 @@ async function writeDailyDigestMemory(sourceId, date, conversations, settings, r
   });
   return true;
 }
-async function importNativeMemories(sourceId, memories, alreadyImportedIds, writer) {
+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 writer.hasFactContentHash(content)) {
+    if (seenContent.has(content) || await deps.writer.hasFactContentHash(content)) {
       importedIds.push(memory.id);
       continue;
     }
     seenContent.add(content);
-    await writer.writeMemory("fact", content, {
-      confidence: 0.6,
+    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 ?? [],
@@ -1189,15 +1462,16 @@ async function importNativeMemories(sourceId, memories, alreadyImportedIds, writ
       validAt: memory.createdIso,
       structuredAttributes: {
         wearableSource: sourceId,
-        wearableNativeId: memory.id
+        wearableNativeId: memory.id,
+        ...trustAttributes
       },
       contentHashSource: content,
-      status: "pending_review"
+      status
     });
     imported += 1;
     importedIds.push(memory.id);
   }
-  return { imported, importedIds };
+  return { imported, importedIds, warnings };
 }
 
 // src/wearables/cleanup.ts
@@ -1545,6 +1819,8 @@ async function syncWearableSource(connector, settings, config, options, deps) {
     correctionsApplied: 0,
     transcriptsWritten: [],
     memoriesCreated: 0,
+    memoriesPromoted: 0,
+    memoriesDemoted: 0,
     memoriesSkipped: 0,
     nativeMemoriesImported: 0,
     warnings: []
@@ -1626,6 +1902,7 @@ async function syncWearableSource(connector, settings, config, options, deps) {
     }
     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) {
@@ -1635,18 +1912,25 @@ async function syncWearableSource(connector, settings, config, options, deps) {
       } 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,
-            deps.memoryGen
+            dayMemoryGen
           );
           summary.memoriesCreated += generated.created;
+          summary.memoriesPromoted += generated.promoted;
+          summary.memoriesDemoted += generated.demoted;
           summary.memoriesSkipped += generated.skipped;
           summary.warnings.push(...generated.warnings);
-          passClean = generated.warnings.length === 0;
+          passClean = generated.completed;
           if (config.digestEnabled) {
             const wrote = await writeDailyDigestMemory(
               connector.id,
@@ -1674,7 +1958,7 @@ async function syncWearableSource(connector, settings, config, options, deps) {
       memoryDayHashes[date] = bodyHash;
     }
   }
-  if (settings.importNativeMemories === "review" && typeof connector.fetchNativeMemories === "function") {
+  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`
@@ -1683,6 +1967,14 @@ async function syncWearableSource(connector, settings, config, options, deps) {
       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({
@@ -1693,8 +1985,10 @@ async function syncWearableSource(connector, settings, config, options, deps) {
           connector.id,
           result.memories,
           alreadyImported,
-          deps.memoryGen.writer
+          settings,
+          nativeMemoryGen
         );
+        summary.warnings.push(...imported.warnings);
         summary.nativeMemoriesImported += imported.imported;
         importedNativeIds.push(...imported.importedIds);
         for (const id of imported.importedIds) alreadyImported.add(id);
@@ -1708,12 +2002,13 @@ async function syncWearableSource(connector, settings, config, options, deps) {
       }
     }
   }
-  if (summary.transcriptsWritten.length > 0 && deps.afterTranscriptsWritten) {
+  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.afterTranscriptsWritten();
+      await deps.afterWrites();
     } catch (err) {
       summary.warnings.push(
-        `search reindex failed (transcripts are stored and will index on the next update): ${describeErrorForOperator(err)}`
+        `search reindex failed (writes are stored and will index on the next update): ${describeErrorForOperator(err)}`
       );
     }
   }
@@ -1725,9 +2020,39 @@ async function syncWearableSource(connector, settings, config, options, deps) {
     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";
@@ -1813,12 +2138,15 @@ function isModuleNotFound(err, specifier) {
 function createWearableMemoryWriter(storage) {
   return {
     writeMemory: storage.writeMemory.bind(storage),
+    findWearableMemoryByContent: async (content) => await storage.findWearableMemoryByContent(content),
+    promoteWearableMemory: storage.promoteWearableMemory.bind(storage),
+    demoteWearableMemory: storage.demoteWearableMemory.bind(storage),
     hasFactContentHash: async (content) => {
       if (await storage.hasFactContentHash(content)) return true;
-      const needle = content.trim();
+      const needle = stripAttributesSuffix(content);
       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
+        (memory) => typeof memory.frontmatter.source === "string" && memory.frontmatter.source.startsWith(`${WEARABLE_SOURCE_PREFIX}:`) && stripAttributesSuffix(memory.content) === needle
       );
     }
   };
@@ -1916,7 +2244,8 @@ var WearablesService = class {
     }
     const memoryGen = this.deps.extract ? {
       extract: this.deps.extract,
-      writer: createWearableMemoryWriter(storage)
+      writer: createWearableMemoryWriter(storage),
+      ...this.deps.judgeFacts !== void 0 ? { judgeFacts: this.deps.judgeFacts } : {}
     } : null;
     const summaries = [];
     for (const [sourceId, settings] of targets) {
@@ -1945,8 +2274,51 @@ Install it alongside Remnic:
             return parseDayTranscript(raw)?.meta.contentHash ?? null;
           },
           writeDayTranscript: (source, date, serialized) => storage.writeWearableDayTranscript(source, date, serialized),
-          afterTranscriptsWritten: this.deps.reindexSearch,
-          memoryGen
+          afterWrites: this.deps.reindexSearch,
+          memoryGen,
+          // Cross-device corroboration evidence (smart mode): other
+          // sources' stored transcripts for the same day...
+          readOtherSourceDayBodies: async (date, excludeSource) => {
+            const bodies = /* @__PURE__ */ new Map();
+            const days = await storage.listWearableTranscriptDays();
+            for (const entry of days) {
+              if (entry.date !== date || entry.source === excludeSource) continue;
+              if (bodies.size >= 4) break;
+              const raw = await storage.readWearableDayTranscript(entry.source, entry.date);
+              if (raw === null) continue;
+              bodies.set(entry.source, parseDayTranscript(raw)?.body ?? raw);
+            }
+            return bodies;
+          },
+          // ...and existing memories for the support boost. Status
+          // resolves through the canonical inferMemoryStatus so rows
+          // archived via `archivedAt` (or an archive/ path) without an
+          // explicit status never count. Explicit allow-list: active
+          // rows AND pending_review rows — a borderline fact observed
+          // again on a later day is repetition signal and the support
+          // boost is how it earns promotion. Rejected/quarantined/
+          // superseded/archived/forgotten rows never count (CLAUDE.md
+          // rule 53). Bodies feed token matching with the
+          // "[Attributes: ...]" enrichment suffix stripped — attribute
+          // metadata must never grant corroboration.
+          listSupportMemories: async () => {
+            const memories = await storage.readAllMemories();
+            const support = [];
+            for (const memory of memories) {
+              const status = inferMemoryStatus(
+                memory.frontmatter,
+                memory.path
+              );
+              if (status !== "active" && status !== "pending_review") {
+                continue;
+              }
+              support.push({
+                id: memory.frontmatter.id,
+                content: stripAttributesSuffix(memory.content)
+              });
+            }
+            return support;
+          }
         }
       );
       summaries.push(summary);
@@ -3633,6 +4005,21 @@ var Orchestrator = class _Orchestrator {
       })
     };
   }
+  /**
+   * Build a briefing follow-up generator backed by the configured LLM chain
+   * (gateway model source or local LLM). Returns `undefined` when no chain
+   * is available so `buildBriefing` can surface a clear unavailable reason
+   * instead of failing at call time. Used by the access service and CLI as
+   * the fallback when no direct `openaiApiKey` is configured, so briefing
+   * follow-ups ride the same routing as every other fast-tier LLM feature.
+   */
+  get briefingChainFollowupGenerator() {
+    const chainAvailable = this.config.modelSource === "gateway" ? this._fastGatewayLlm?.isAvailable(
+      this.config.fastGatewayAgentId || this.config.gatewayAgentId || void 0
+    ) === true : this.config.localLlmEnabled;
+    if (!chainAvailable) return void 0;
+    return buildChainFollowupGenerator(this.fastLlmForRerank);
+  }
   async initialize() {
     this.deferredReady = new Promise((resolve) => {
       this.resolveDeferredReady = resolve;
@@ -9780,6 +10167,21 @@ _Context: ${topQuestion.context}_`
         config: this.config.wearables,
         getStorage: async () => await this.getStorageForNamespace(this.bulkImportWriteNamespace()),
         extract: (turns) => this.extraction.extract(turns),
+        // Smart memoryMode runs candidates through the SAME extraction
+        // judge (cache + defer counters included) the live extraction
+        // pipeline uses, so wearable facts get identical LLM-as-judge
+        // durability gating.
+        judgeFacts: (candidates) => judgeFactDurability(
+          candidates,
+          this.config,
+          this.localLlm,
+          new FallbackLlmClient(
+            this.config.gatewayConfig,
+            fallbackLlmRuntimeContextFromConfig(this.config)
+          ),
+          this.judgeVerdictCache,
+          this.judgeDeferCounts
+        ),
         searchBackend: {
           search: async (query, maxResults) => {
             if (!this.qmd.isAvailable()) return null;
@@ -13885,4 +14287,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-AZ4RI3QD.js.map
+//# sourceMappingURL=chunk-YJOWWRRS.js.map