@remnic/core 9.3.629 → 9.3.631

package/src/wearables/storage-io.test.ts

@@ -90,6 +90,87 @@ test("transcript files never surface from readAllMemories", async () => {
   }
 });
 
+test("promoteWearableMemory flips status, merges evidence, and updates confidence", async () => {
+  const { storage, dir } = makeStorage();
+  try {
+    const id = await storage.writeMemory("fact", "Launch moved to September twelfth.", {
+      confidence: 0.6,
+      source: "wearable:limitless",
+      status: "pending_review",
+      structuredAttributes: { wearableSource: "limitless", trustScore: "0.600" },
+    });
+    const promoted = await storage.promoteWearableMemory(
+      id,
+      { trustScore: "0.750", trustDecision: "promoted-by-corroboration" },
+      0.75,
+    );
+    assert.equal(promoted, true);
+    const memory = (await storage.readAllMemories()).find(
+      (entry) => entry.frontmatter.id === id,
+    );
+    assert.ok(memory);
+    assert.equal(memory.frontmatter.status, "active");
+    assert.equal(memory.frontmatter.confidence, 0.75);
+    assert.equal(memory.frontmatter.structuredAttributes?.trustScore, "0.750");
+    assert.equal(
+      memory.frontmatter.structuredAttributes?.trustDecision,
+      "promoted-by-corroboration",
+    );
+
+    // Already-active rows are not re-promoted (operator decisions win).
+    assert.equal(await storage.promoteWearableMemory(id, {}, 0.9), false);
+    assert.equal(await storage.promoteWearableMemory("missing-id", {}), false);
+
+    const found = await storage.findWearableMemoryByContent(
+      "Launch moved to September twelfth.",
+    );
+    assert.equal(found?.id, id);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("demoteWearableMemory rejects only pending rows and merges evidence", async () => {
+  const { storage, dir } = makeStorage();
+  try {
+    const id = await storage.writeMemory("fact", "Vendor call moved the launch again.", {
+      confidence: 0.5,
+      source: "wearable:limitless",
+      status: "pending_review",
+      structuredAttributes: { wearableSource: "limitless", trustScore: "0.500" },
+    });
+    const demoted = await storage.demoteWearableMemory(id, {
+      trustScore: "0.310",
+      trustDecision: "demoted-by-rejection",
+      judgeVerdict: "reject",
+    });
+    assert.equal(demoted, true);
+    const memory = (await storage.readAllMemories()).find(
+      (entry) => entry.frontmatter.id === id,
+    );
+    assert.ok(memory);
+    assert.equal(memory.frontmatter.status, "rejected");
+    assert.equal(memory.frontmatter.structuredAttributes?.trustDecision, "demoted-by-rejection");
+    assert.equal(memory.frontmatter.structuredAttributes?.wearableSource, "limitless");
+
+    // Rejected rows are terminal for the wearable pipeline: no
+    // re-demote, no promote (operator surfaces own them from here).
+    assert.equal(await storage.demoteWearableMemory(id, {}), false);
+    assert.equal(await storage.promoteWearableMemory(id, {}, 0.9), false);
+    assert.equal(await storage.demoteWearableMemory("missing-id", {}), false);
+
+    // Active rows are never auto-demoted.
+    const activeId = await storage.writeMemory("fact", "Approved active row.", {
+      confidence: 0.9,
+      source: "wearable:limitless",
+      status: "active",
+    });
+    assert.equal(await storage.demoteWearableMemory(activeId, {}), false);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test("non-transcript files in the wearables tree are ignored by listing", async () => {
   const { storage, dir } = makeStorage();
   try {

package/src/wearables/trust.test.ts

@@ -0,0 +1,123 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import {
+  computeTrustScore,
+  decideSmart,
+  findCorroboration,
+  tokenizeDayBody,
+  TRUST_CROSS_SOURCE_BOOST,
+  TRUST_JUDGE_ACCEPT_BOOST,
+  TRUST_SUPPORTING_MEMORY_BOOST,
+} from "./trust.js";
+
+const NO_EVIDENCE = { corroboratedBySources: [] };
+
+test("trust = confidence x sourceTrust, clamped to [0,1]", () => {
+  assert.ok(
+    Math.abs(
+      computeTrustScore({ extractionConfidence: 0.9, sourceTrust: 0.8, evidence: NO_EVIDENCE }) -
+        0.72,
+    ) < 1e-9,
+  );
+  // Missing confidence defaults to 0.7.
+  assert.equal(
+    computeTrustScore({ extractionConfidence: undefined, sourceTrust: 1, evidence: NO_EVIDENCE }),
+    0.7,
+  );
+  // Boosts never push past 1.
+  assert.equal(
+    computeTrustScore({
+      extractionConfidence: 1,
+      sourceTrust: 1,
+      judgeVerdict: "accept",
+      evidence: { corroboratedBySources: ["bee"], supportingMemoryId: "m1" },
+    }),
+    1,
+  );
+});
+
+test("judge accept and corroboration boosts stack as documented", () => {
+  const base = computeTrustScore({
+    extractionConfidence: 0.5,
+    sourceTrust: 0.8,
+    evidence: NO_EVIDENCE,
+  });
+  const judged = computeTrustScore({
+    extractionConfidence: 0.5,
+    sourceTrust: 0.8,
+    judgeVerdict: "accept",
+    evidence: NO_EVIDENCE,
+  });
+  const corroborated = computeTrustScore({
+    extractionConfidence: 0.5,
+    sourceTrust: 0.8,
+    judgeVerdict: "accept",
+    evidence: { corroboratedBySources: ["omi"], supportingMemoryId: "m1" },
+  });
+  assert.ok(Math.abs(judged - base - TRUST_JUDGE_ACCEPT_BOOST) < 1e-9);
+  assert.ok(
+    Math.abs(
+      corroborated -
+        judged -
+        TRUST_CROSS_SOURCE_BOOST -
+        TRUST_SUPPORTING_MEMORY_BOOST,
+    ) < 1e-9,
+  );
+});
+
+test("decideSmart: judge verdicts short-circuit; trust bands otherwise", () => {
+  const thresholds = { autoApproveTrust: 0.7, reviewTrust: 0.45 };
+  assert.equal(decideSmart(0.99, "reject", thresholds).outcome, "drop");
+  assert.equal(decideSmart(0.99, "defer", thresholds).outcome, "review");
+  assert.equal(decideSmart(0.7, "accept", thresholds).outcome, "active");
+  assert.equal(decideSmart(0.7, undefined, thresholds).outcome, "active");
+  assert.equal(decideSmart(0.5, undefined, thresholds).outcome, "review");
+  assert.equal(decideSmart(0.2, undefined, thresholds).outcome, "drop");
+});
+
+test("cross-source corroboration requires high token coverage", () => {
+  const beeDay = tokenizeDayBody(
+    "We agreed the product launch moves to September twelfth after the vendor call.",
+  );
+  const context = {
+    otherSourceDayTokens: new Map([["bee", beeDay]]),
+    existingMemories: [],
+  };
+  const corroborated = findCorroboration(
+    "Launch moved to September twelfth after vendor call.",
+    context,
+  );
+  assert.deepEqual(corroborated.corroboratedBySources, ["bee"]);
+
+  const unrelated = findCorroboration(
+    "Dentist appointment is on Thursday afternoon downtown.",
+    context,
+  );
+  assert.deepEqual(unrelated.corroboratedBySources, []);
+});
+
+test("existing-memory support sets supportingMemoryId", () => {
+  const context = {
+    otherSourceDayTokens: new Map<string, Set<string>>(),
+    existingMemories: [
+      { id: "fact-1", content: "User prefers the aisle seat on long flights." },
+      { id: "fact-2", content: "The launch moved to September twelfth, vendor informed." },
+    ],
+  };
+  const supported = findCorroboration(
+    "Launch moved to September twelfth and the vendor was informed.",
+    context,
+  );
+  assert.equal(supported.supportingMemoryId, "fact-2");
+});
+
+test("very short facts never corroborate (too little signal)", () => {
+  const context = {
+    otherSourceDayTokens: new Map([["bee", tokenizeDayBody("yes ok sure fine")]]),
+    existingMemories: [{ id: "m", content: "yes ok sure fine" }],
+  };
+  const evidence = findCorroboration("yes ok", context);
+  assert.deepEqual(evidence.corroboratedBySources, []);
+  assert.equal(evidence.supportingMemoryId, undefined);
+});

package/src/wearables/trust.ts

@@ -0,0 +1,168 @@
+/**
+ * Wearable memory trust scoring — the "smart" memoryMode engine.
+ *
+ * Grounded in how production memory systems handle noisy ingest:
+ *
+ *  - **LLM-as-judge gating** (Remnic's own extraction judge,
+ *    `judgeFactDurability`): an LLM verdict on durability decides
+ *    accept / defer / reject before anything persists.
+ *  - **Provenance priors**: each source carries a configurable trust
+ *    prior (`sourceTrust`) — a noisy ASR channel contributes less
+ *    confidence than a clean one (provenance-weighted fusion).
+ *  - **Corroboration**: independent agreement raises trust. A fact
+ *    supported by a second wearable that recorded the same day, or by
+ *    an existing active memory, is far less likely to be an ASR
+ *    artifact (ensemble agreement / self-consistency).
+ *
+ * The combined score maps to a three-way decision:
+ *
+ *    trust >= autoApproveTrust  -> written ACTIVE
+ *    trust >= reviewTrust       -> written pending_review
+ *    below                      -> dropped
+ *
+ * with the judge able to short-circuit (reject -> drop,
+ * defer -> pending_review regardless of score). The score, verdict,
+ * and corroboration evidence persist on the memory (confidence +
+ * structuredAttributes + verificationState), so Remnic's existing
+ * trust machinery — memory-worth outcome counters, pattern
+ * reinforcement, temporal supersession, contradiction scans — keeps
+ * calibrating these memories after they land.
+ */
+
+import {
+  countRecallTokenOverlap,
+  normalizeRecallTokens,
+} from "../recall-tokenization.js";
+
+/** Judge adjustments and corroboration boosts (documented, fixed). */
+export const TRUST_JUDGE_ACCEPT_BOOST = 0.15;
+export const TRUST_CROSS_SOURCE_BOOST = 0.15;
+export const TRUST_SUPPORTING_MEMORY_BOOST = 0.1;
+
+/** Minimum distinct tokens before similarity is meaningful. */
+const MIN_FACT_TOKENS = 4;
+/** Fact-token coverage required to call a day-text corroborating. */
+const CROSS_SOURCE_COVERAGE = 0.6;
+/** Fact-token coverage required to call an existing memory supporting. */
+const MEMORY_SUPPORT_COVERAGE = 0.7;
+/** Bound on existing memories scanned per fact batch. */
+const MAX_MEMORIES_SCANNED = 5_000;
+
+export interface TrustEvidence {
+  /** Other-source ids whose same-day content corroborates the fact. */
+  corroboratedBySources: string[];
+  /** Id of an existing active memory whose content supports the fact. */
+  supportingMemoryId?: string;
+}
+
+export interface TrustScoreInput {
+  /** Extraction confidence for the fact (defaults to 0.7 when absent). */
+  extractionConfidence: number | undefined;
+  /** Per-source trust prior from config (0..1). */
+  sourceTrust: number;
+  /** Judge verdict kind when a judge ran; undefined when unavailable. */
+  judgeVerdict?: "accept" | "reject" | "defer";
+  evidence: TrustEvidence;
+}
+
+export function computeTrustScore(input: TrustScoreInput): number {
+  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 !== undefined) {
+    trust += TRUST_SUPPORTING_MEMORY_BOOST;
+  }
+  return Math.min(1, Math.max(0, trust));
+}
+
+export interface CorroborationContext {
+  /**
+   * Same-day transcript bodies from OTHER sources, keyed by source id.
+   * Pre-tokenized once per sync (day bodies are large).
+   */
+  otherSourceDayTokens: Map<string, Set<string>>;
+  /** Existing active memories: id + content. */
+  existingMemories: Array<{ id: string; content: string }>;
+}
+
+/** Tokenize a day body once for repeated per-fact coverage checks. */
+export function tokenizeDayBody(body: string): Set<string> {
+  return new Set(normalizeRecallTokens(body));
+}
+
+/**
+ * Find corroborating evidence for one fact. Deterministic and local:
+ * token-coverage similarity via the shared recall tokenizer — no LLM
+ * cost on the corroboration path.
+ */
+export function findCorroboration(
+  factText: string,
+  context: CorroborationContext,
+): TrustEvidence {
+  const factTokens = normalizeRecallTokens(factText);
+  const evidence: TrustEvidence = { 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;
+}
+
+export interface SmartDecision {
+  outcome: "active" | "review" | "drop";
+  reason:
+    | "judge-rejected"
+    | "judge-deferred"
+    | "auto-approved"
+    | "queued-for-review"
+    | "below-trust";
+  trust: number;
+}
+
+/** Map judge verdict + trust score to the smart-mode decision. */
+export function decideSmart(
+  trust: number,
+  judgeVerdict: "accept" | "reject" | "defer" | undefined,
+  thresholds: { autoApproveTrust: number; reviewTrust: number },
+): SmartDecision {
+  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 };
+}

package/src/wearables/types.ts

@@ -143,32 +143,59 @@ export interface WearableSourceSettings {
   userId?: string;
   /**
    * Memory creation mode (trust gate):
+   *  - "smart":  DEFAULT. Fully automated trust pipeline: the
+   *              extraction judge (LLM-as-judge) plus a per-source
+   *              trust prior, cross-device corroboration, and
+   *              existing-memory support combine into a trust score.
+   *              High-trust facts are written active; borderline facts
+   *              go to the review queue; low-trust/judge-rejected
+   *              facts are dropped. See wearables/trust.ts.
    *  - "off":    transcripts only; never create memories.
-   *  - "review": extract candidate memories but write every one with
-   *              status "pending_review" so nothing enters active
-   *              recall without operator approval. Default.
-   *  - "auto":   extracted memories that pass the quality gates are
-   *              written active, like live-conversation extraction.
+   *  - "review": every extracted candidate is written
+   *              "pending_review" — nothing enters active recall
+   *              without operator approval.
+   *  - "auto":   deterministic gates only; survivors written active
+   *              (no judge, no trust scoring).
    */
   memoryMode: WearableMemoryMode;
+  /**
+   * Trust prior for this source's transcription quality (0..1).
+   * Multiplies extraction confidence in smart mode — lower it for a
+   * device that mis-transcribes often. Default 0.8.
+   */
+  sourceTrust: number;
+  /** Smart mode: trust at/above which facts are written active. */
+  autoApproveTrust: number;
+  /**
+   * Smart mode: trust at/above which borderline facts are queued for
+   * review instead of dropped. Must be below autoApproveTrust.
+   */
+  reviewTrust: number;
   /** Drop extracted facts below this confidence (0–1). */
   minConfidence: number;
   /** Drop extracted facts scored below this importance level. */
   minImportance: ImportanceLevel;
   /**
-   * Cap on memories created per source per day. 0 disables the cap.
+   * Cap on memories created per source per day. 0 (the default)
+   * disables the cap — the smart trust pipeline is the quality gate,
+   * and a count cap would drop real memories on busy days.
    */
   maxMemoriesPerDay: number;
   /**
    * Import provider-extracted memories (Bee facts / Omi memories).
-   * "review" lands them in the review queue; "off" (default) skips.
+   *  - "smart": DEFAULT. Same trust pipeline as transcript facts
+   *    (judge + trust prior + corroboration) with a slightly reduced
+   *    prior — provider extraction quality is outside Remnic's
+   *    control.
+   *  - "review": always pending_review.
+   *  - "off": skip.
    */
-  importNativeMemories: "off" | "review";
+  importNativeMemories: "off" | "review" | "smart";
   /** Transcript cleanup toggles. */
   cleanup: WearableCleanupSettings;
 }
 
-export type WearableMemoryMode = "off" | "review" | "auto";
+export type WearableMemoryMode = "off" | "review" | "auto" | "smart";
 
 export interface WearableCleanupSettings {
   /** Merge consecutive segments from the same speaker. */
@@ -225,6 +252,23 @@ export interface WearablesConfig {
    * Default false.
    */
   digestEnabled: boolean;
+  /**
+   * Periodically refresh transcripts in-process (long-lived hosts).
+   * Every tick re-syncs `autoSyncDays` ending today — existing day
+   * files included, so the current day keeps growing while the
+   * wearable records. Default true.
+   */
+  autoSyncEnabled: boolean;
+  /** Minutes between auto-sync ticks (1-1440). Default 15. */
+  autoSyncIntervalMinutes: number;
+  /** Rolling window (days ending today) per tick (1-90). Default 2. */
+  autoSyncDays: number;
+  /**
+   * Once-per-local-day deep pass window (days, 0-90) picking up late
+   * uploads and provider re-processing. 0 disables; otherwise must be
+   * >= autoSyncDays. Default 7.
+   */
+  autoSyncDeepDays: number;
   /** Correction rules from config (merged with CLI-managed rules). */
   corrections: WearableCorrectionRule[];
   /** Per-source settings, keyed by connector id. */
@@ -244,6 +288,10 @@ export interface WearableSyncSummary {
   /** Day files written (skipped-unchanged days are not listed). */
   transcriptsWritten: string[];
   memoriesCreated: number;
+  /** Earlier borderline writes promoted to active by new evidence. */
+  memoriesPromoted: number;
+  /** Earlier pending writes retired by a fresh judge-reject verdict. */
+  memoriesDemoted: number;
   memoriesSkipped: number;
   nativeMemoriesImported: number;
   /** Non-fatal warnings surfaced to the operator. */