@remnic/core 9.3.628 → 9.3.630

package/src/wearables/pipeline.test.ts

@@ -34,6 +34,10 @@ function config(overrides: Partial<WearablesConfig> = {}): WearablesConfig {
     ...defaultWearablesConfig(),
     enabled: true,
     timezone: "UTC",
+    // Pinned off so per-stage tests stay focused; defaults are covered
+    // in config.test.ts and the dedicated digest test below.
+    digestEnabled: false,
+    offTheRecordEnabled: false,
     ...overrides,
   };
 }
@@ -119,7 +123,7 @@ function makeDeps(memoryDir: string): {
       files.set(`${sourceId}/${date}`, serialized);
       written.push({ source: sourceId, date, serialized });
     },
-    async afterTranscriptsWritten() {
+    async afterWrites() {
       reindexes.count += 1;
     },
     memoryGen: {
@@ -576,6 +580,310 @@ test("page-capped days carry a visible partial marker and keep warning", async (
   }
 });
 
+test("a judge outage does not re-run the memory pass forever", async () => {
+  const memoryDir = mkdtempSync(path.join(tmpdir(), "remnic-pipeline-"));
+  try {
+    const byDate = {
+      "2026-06-11": [
+        makeConversation("c1", "2026-06-11", [
+          { speaker: "user", isWearer: true, text: "The vendor contract was renewed for another year today." },
+          { speaker: "Speaker 2", text: "Renewal confirmed, the paperwork went through this afternoon." },
+        ]),
+      ],
+    };
+    const { deps, memoryWrites } = makeDeps(memoryDir);
+    assert.ok(deps.memoryGen);
+    let extractCalls = 0;
+    const baseExtract = deps.memoryGen.extract;
+    deps.memoryGen.extract = async (turns) => {
+      extractCalls += 1;
+      return baseExtract(turns);
+    };
+    deps.memoryGen.judgeFacts = async () => {
+      throw new Error("judge backend down");
+    };
+
+    const first = await syncWearableSource(
+      fakeConnector(byDate),
+      settings({ memoryMode: "smart" }),
+      config(),
+      { days: 1 },
+      deps,
+    );
+    assert.ok(first.warnings.some((warning) => warning.includes("judge unavailable")));
+    assert.equal(first.memoriesCreated, 1, "degraded pass still writes");
+    const callsAfterFirst = extractCalls;
+
+    // Unchanged day, judge still down: the degraded-but-complete pass
+    // must have recorded completion — no re-extraction.
+    const second = await syncWearableSource(
+      fakeConnector(byDate),
+      settings({ memoryMode: "smart" }),
+      config(),
+      { days: 1 },
+      deps,
+    );
+    assert.equal(extractCalls, callsAfterFirst, "no repeat extraction for an unchanged day");
+    assert.equal(second.memoriesCreated, 0);
+    assert.equal(memoryWrites.length, 1);
+  } finally {
+    rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("smart mode: another device's stored day transcript corroborates borderline facts", async () => {
+  const memoryDir = mkdtempSync(path.join(tmpdir(), "remnic-pipeline-"));
+  try {
+    const byDate = {
+      "2026-06-11": [
+        makeConversation("c1", "2026-06-11", [
+          { speaker: "user", isWearer: true, text: "We are moving the launch to September twelfth after the vendor call." },
+          { speaker: "Speaker 2", text: "September twelfth works for everyone on the vendor side too." },
+        ]),
+      ],
+    };
+    const { deps, memoryWrites } = makeDeps(memoryDir);
+    assert.ok(deps.memoryGen);
+    // Borderline extraction: 0.75 * 0.8 = 0.6 — review band unless corroborated.
+    deps.memoryGen.extract = async () => ({
+      facts: [
+        {
+          category: "fact",
+          content: "The launch moved to September twelfth after the vendor call.",
+          confidence: 0.75,
+          tags: [],
+        },
+      ],
+      profileUpdates: [],
+      entities: [],
+      questions: [],
+    });
+    // A second device already stored a transcript covering the same day.
+    deps.readOtherSourceDayBodies = async (date, excludeSource) => {
+      assert.equal(date, "2026-06-11");
+      assert.equal(excludeSource, "testsource");
+      return new Map([
+        ["bee", "They said the launch moves to September twelfth right after that vendor call wrapped."],
+      ]);
+    };
+    deps.listSupportMemories = async () => [];
+
+    const summary = await syncWearableSource(
+      fakeConnector(byDate),
+      settings({ memoryMode: "smart" }),
+      config(),
+      { days: 1 },
+      deps,
+    );
+    assert.equal(summary.memoriesCreated, 1);
+    assert.equal(memoryWrites[0].options.status, "active", "corroboration lifts review -> active");
+    const attrs = memoryWrites[0].options.structuredAttributes as Record<string, string>;
+    assert.equal(attrs.corroboratedBySources, "bee");
+    assert.equal(attrs.trustDecision, "auto-approved");
+  } finally {
+    rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("smart native import never uses day-scoped cross-source corroboration", async () => {
+  const memoryDir = mkdtempSync(path.join(tmpdir(), "remnic-pipeline-"));
+  try {
+    const { deps, memoryWrites } = makeDeps(memoryDir);
+    assert.ok(deps.memoryGen);
+    let dayBodiesRequested = 0;
+    deps.readOtherSourceDayBodies = async () => {
+      dayBodiesRequested += 1;
+      return new Map([["bee", "the launch moves to september twelfth after that vendor call"]]);
+    };
+    deps.listSupportMemories = async () => [
+      { id: "fact-9", content: "User volunteers at the food bank every month with the team." },
+    ];
+    const summary = await syncWearableSource(
+      fakeConnector({}, [
+        // No day attached — must not be scored against any day's tokens,
+        // but corpus support still applies: 0.7*(0.8*0.9)+0.10 = 0.604 -> review.
+        { id: "nat-1", content: "User volunteers at the food bank every month with the team." },
+      ]),
+      settings({ memoryMode: "smart", importNativeMemories: "smart" }),
+      config(),
+      { days: 1 },
+      deps,
+    );
+    assert.equal(dayBodiesRequested, 0, "native import must not read day bodies");
+    assert.equal(summary.nativeMemoriesImported, 1);
+    const attrs = memoryWrites[0].options.structuredAttributes as Record<string, string>;
+    assert.equal(attrs.corroboratedBySources, undefined, "no cross-source evidence without a day");
+    assert.equal(attrs.supportingMemoryId, "fact-9", "corpus support still applies");
+  } finally {
+    rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("facts written earlier in a multi-day backfill support later days in the same run", async () => {
+  const memoryDir = mkdtempSync(path.join(tmpdir(), "remnic-pipeline-"));
+  try {
+    const byDate = {
+      "2026-06-10": [
+        makeConversation("c1", "2026-06-10", [
+          { speaker: "user", isWearer: true, text: "The launch moved to September twelfth after the vendor call." },
+          { speaker: "Speaker 2", text: "September twelfth confirmed with the vendor on the call." },
+        ]),
+      ],
+      "2026-06-11": [
+        makeConversation("c2", "2026-06-11", [
+          { speaker: "user", isWearer: true, text: "Reminder that the launch moved to September twelfth after the vendor call." },
+          { speaker: "Speaker 2", text: "Yes, the September date is locked in now." },
+        ]),
+      ],
+    };
+    const { deps, memoryWrites } = makeDeps(memoryDir);
+    assert.ok(deps.memoryGen);
+    // Borderline confidence so day 2 only crosses the auto threshold
+    // with the +0.10 corpus-support boost from day 1's write.
+    let call = 0;
+    deps.memoryGen.extract = async () => {
+      call += 1;
+      return {
+        facts: [
+          {
+            category: "fact",
+            content:
+              call === 1
+                ? "The launch moved to September twelfth after the vendor call."
+                : "Launch moved to September twelfth after the vendor call.",
+            confidence: 0.75,
+            tags: [],
+          },
+        ],
+        profileUpdates: [],
+        entities: [],
+        questions: [],
+      };
+    };
+    // listSupportMemories reflects what this run has written so far —
+    // mirroring storage, whose readAllMemories cache invalidates on
+    // every write.
+    deps.listSupportMemories = async () =>
+      memoryWrites.map((write, index) => ({ id: `mem-${index + 1}`, content: write.content }));
+
+    const summary = await syncWearableSource(
+      fakeConnector(byDate),
+      settings({ memoryMode: "smart" }),
+      config(),
+      { days: 2 },
+      deps,
+    );
+    assert.equal(summary.memoriesCreated, 2);
+    assert.equal(memoryWrites[0].options.status, "pending_review", "day 1 borderline stays in review");
+    assert.equal(memoryWrites[1].options.status, "active", "day 2 lifted by day 1's write");
+    const attrs = memoryWrites[1].options.structuredAttributes as Record<string, string>;
+    assert.equal(attrs.supportingMemoryId, "mem-1");
+  } finally {
+    rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("a second device's day write invalidates the first device's memory-pass completion", async () => {
+  const memoryDir = mkdtempSync(path.join(tmpdir(), "remnic-pipeline-"));
+  try {
+    const day = "2026-06-11";
+    const conversationFor = (source: string) =>
+      makeConversation(`${source}-c1`, day, [
+        { speaker: "user", isWearer: true, text: "We are moving the launch to September twelfth after the vendor call today." },
+        { speaker: "Speaker 2", text: "The vendor confirmed the September launch date on the call." },
+      ]);
+    const { deps } = makeDeps(memoryDir);
+
+    // Device A syncs first and completes its memory pass for the day.
+    const connectorA = { ...fakeConnector({ [day]: [conversationFor("a")] }), id: "sourcea" };
+    await syncWearableSource(connectorA, settings({ memoryMode: "smart" }), config(), { days: 1 }, deps);
+    let state = await loadSyncState(memoryDir);
+    assert.ok(state.sources.sourcea.memoryDayHashes?.[day], "A's pass recorded");
+
+    // Device B then writes a transcript for the same day: A's
+    // completion record for that day must be invalidated so A's next
+    // sync re-scores with B's evidence available.
+    const connectorB = { ...fakeConnector({ [day]: [conversationFor("b")] }), id: "sourceb" };
+    await syncWearableSource(connectorB, settings({ memoryMode: "smart" }), config(), { days: 1 }, deps);
+    state = await loadSyncState(memoryDir);
+    assert.equal(
+      state.sources.sourcea.memoryDayHashes?.[day],
+      undefined,
+      "A's completion cleared by B's new same-day evidence",
+    );
+    assert.ok(state.sources.sourceb.memoryDayHashes?.[day], "B's own pass recorded");
+  } finally {
+    rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("a promotion-only re-pass still fires the reindex hook", async () => {
+  const memoryDir = mkdtempSync(path.join(tmpdir(), "remnic-pipeline-"));
+  try {
+    const day = "2026-06-11";
+    const byDate = {
+      [day]: [
+        makeConversation("c1", day, [
+          { speaker: "user", isWearer: true, text: "We are moving the launch to September twelfth after the vendor call today." },
+          { speaker: "Speaker 2", text: "The vendor confirmed the September launch date on the call." },
+        ]),
+      ],
+    };
+    const { deps, reindexes, memoryWrites } = makeDeps(memoryDir);
+    assert.ok(deps.memoryGen);
+    const borderline = "The launch moved to September twelfth after the vendor call.";
+    deps.memoryGen.extract = async () => ({
+      facts: [{ category: "fact", content: borderline, confidence: 0.75, tags: [] }],
+      profileUpdates: [],
+      entities: [],
+      questions: [],
+    });
+
+    // Sync 1: borderline fact lands in review. Reindex fires (a memory
+    // was created).
+    await syncWearableSource(fakeConnector(byDate), settings({ memoryMode: "smart" }), config(), { days: 1 }, deps);
+    assert.equal(memoryWrites[0].options.status, "pending_review");
+    const reindexesAfterFirst = reindexes.count;
+
+    // Another source's same-day transcript arrives, then sync 1's
+    // source re-passes: unchanged transcript, duplicate fact — but now
+    // corroborated, so it PROMOTES. The reindex hook must still fire.
+    const written: string[] = [];
+    deps.memoryGen.writer.findWearableMemoryByContent = async (content) =>
+      content.trim() === borderline ? { id: "mem-1", status: "pending_review" } : null;
+    deps.memoryGen.writer.promoteWearableMemory = async (id) => {
+      written.push(id);
+      return true;
+    };
+    deps.memoryGen.writer.hasFactContentHash = async (content) =>
+      content.trim() === borderline;
+    deps.readOtherSourceDayBodies = async () =>
+      new Map([["bee", "They said the launch moves to September twelfth right after that vendor call wrapped."]]);
+    // Clear the completion record the way a sibling-source write would.
+    const { loadSyncState: load, saveSyncState: save } = await import("./sync-state.js");
+    const state = await load(memoryDir);
+    delete state.sources.testsource.memoryDayHashes?.[day];
+    await save(memoryDir, state);
+
+    const second = await syncWearableSource(
+      fakeConnector(byDate),
+      settings({ memoryMode: "smart" }),
+      config(),
+      { days: 1 },
+      deps,
+    );
+    assert.equal(second.transcriptsWritten.length, 0, "no transcript write");
+    assert.equal(second.memoriesPromoted, 1, "promotion happened");
+    assert.deepEqual(written, ["mem-1"]);
+    assert.ok(
+      reindexes.count > reindexesAfterFirst,
+      "reindex fired for the promotion-only run",
+    );
+  } finally {
+    rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
 test("a transcript write failure prevents the sync watermark from advancing", async () => {
   const memoryDir = mkdtempSync(path.join(tmpdir(), "remnic-pipeline-"));
   try {

package/src/wearables/pipeline.ts

@@ -36,6 +36,7 @@ import {
   writeDailyDigestMemory,
   type WearableMemoryGenDeps,
 } from "./memory-gen.js";
+import { tokenizeDayBody, type CorroborationContext } from "./trust.js";
 import { applyOffTheRecord, compileRedactionPatterns, redactText } from "./redaction.js";
 import { loadSpeakerRegistry } from "./speakers.js";
 import {
@@ -80,14 +81,36 @@ export interface WearableSyncDeps {
     date: string,
     serialized: string,
   ): Promise<void>;
-  /** Optional hook fired once after any day files changed (reindex). */
-  afterTranscriptsWritten?(): Promise<void>;
+  /**
+   * Optional hook fired once after the sync wrote ANYTHING the search
+   * index should see: day transcripts, created memories, in-place
+   * promotions, or native imports. (A cross-source invalidation can
+   * promote memories on a run with zero transcript writes — the index
+   * must still refresh.)
+   */
+  afterWrites?(): Promise<void>;
   /**
    * Memory-generation dependencies, or null when no extraction engine
    * is available in this context (transcripts still sync; memory
    * creation is skipped with a warning when the mode wanted it).
    */
   memoryGen: WearableMemoryGenDeps | null;
+  /**
+   * Same-day transcript bodies from OTHER sources, for cross-device
+   * corroboration in smart mode. Absent disables the boost.
+   */
+  readOtherSourceDayBodies?(
+    date: string,
+    excludeSource: string,
+  ): Promise<Map<string, string>>;
+  /**
+   * Existing memories usable as support evidence: status "active" or
+   * "pending_review" (explicit allow-list — a borderline fact observed
+   * again on a later day is repetition signal, and the +0.10 boost is
+   * how it earns promotion). Rejected/quarantined/superseded/archived/
+   * forgotten rows are never support evidence.
+   */
+  listSupportMemories?(): Promise<Array<{ id: string; content: string }>>;
   /** Clock injection for tests. */
   now?: () => Date;
 }
@@ -276,6 +299,8 @@ export async function syncWearableSource(
     correctionsApplied: 0,
     transcriptsWritten: [],
     memoriesCreated: 0,
+    memoriesPromoted: 0,
+    memoriesDemoted: 0,
     memoriesSkipped: 0,
     nativeMemoriesImported: 0,
     warnings: [],
@@ -380,6 +405,9 @@ export async function syncWearableSource(
 
     if (allElided) continue;
 
+    const needsSmartContext =
+      settings.memoryMode === "smart" || settings.importNativeMemories === "smart";
+
     // The memory pass runs when the day changed, when forced, or when
     // the last pass for this exact content didn't complete cleanly —
     // a sync that stored the transcript but failed mid-memory-write
@@ -406,18 +434,31 @@ export async function syncWearableSource(
         // re-runs the day.
         let passClean = false;
         try {
+          const corroboration = needsSmartContext
+            ? await buildCorroborationContext(connector.id, date, deps)
+            : undefined;
+          const dayMemoryGen: WearableMemoryGenDeps = {
+            ...deps.memoryGen,
+            ...(corroboration !== undefined ? { 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;
+          // Degraded-but-complete passes (e.g. judge unavailable) still
+          // record completion — only an aborted extraction should force
+          // the day to re-run on the next sync (Cursor review on PR
+          // #1462).
+          passClean = generated.completed;
           if (config.digestEnabled) {
             const wrote = await writeDailyDigestMemory(
               connector.id,
@@ -448,7 +489,7 @@ export async function syncWearableSource(
   }
 
   if (
-    settings.importNativeMemories === "review" &&
+    settings.importNativeMemories !== "off" &&
     typeof connector.fetchNativeMemories === "function"
   ) {
     if (!deps.memoryGen) {
@@ -459,6 +500,26 @@ export async function syncWearableSource(
       const alreadyImported = new Set(
         previousState?.importedNativeMemoryIds ?? [],
       );
+      // Native memories carry no day, so same-day cross-device
+      // corroboration does not apply to them — scoring a provider fact
+      // against an arbitrary day's tokens would be wrong-day evidence
+      // (Cursor review on PR #1462). They keep only the day-independent
+      // existing-memory support boost.
+      const nativeCorroboration =
+        settings.importNativeMemories === "smart"
+          ? {
+              otherSourceDayTokens: new Map<string, Set<string>>(),
+              existingMemories: deps.listSupportMemories
+                ? await deps.listSupportMemories()
+                : [],
+            }
+          : undefined;
+      const nativeMemoryGen: WearableMemoryGenDeps = {
+        ...deps.memoryGen,
+        ...(nativeCorroboration !== undefined
+          ? { corroboration: nativeCorroboration }
+          : {}),
+      };
       let cursor: string | null | undefined = undefined;
       for (let page = 0; page < MAX_NATIVE_PAGES; page++) {
         const result = await connector.fetchNativeMemories({
@@ -469,8 +530,10 @@ export async function syncWearableSource(
           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);
@@ -485,12 +548,18 @@ export async function syncWearableSource(
     }
   }
 
-  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)}`,
       );
     }
   }
@@ -505,11 +574,64 @@ export async function syncWearableSource(
     clearMemoryDays: failedMemoryDays,
     importedNativeMemoryIds: importedNativeIds,
   });
+  // New same-day evidence invalidates OTHER sources' memory-pass
+  // completion for the days this source just (re)wrote: their next
+  // sync re-scores with this transcript available, and the promotion
+  // path upgrades earlier borderline writes in place (Cursor review on
+  // PR #1462).
+  if (summary.transcriptsWritten.length > 0) {
+    const cleared: typeof syncState.sources = {};
+    for (const [otherId, otherState] of Object.entries(syncState.sources)) {
+      if (otherId === connector.id || otherState.memoryDayHashes === undefined) {
+        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;
 }
 
+/**
+ * Assemble smart-mode corroboration evidence: other sources' same-day
+ * transcript tokens + existing active memories. The memory list loads
+ * fresh per day (not per run) so facts written on earlier days of a
+ * multi-day backfill are visible as support evidence on later days —
+ * the underlying readAllMemories is cached in storage and invalidated
+ * by writes, so the per-day refresh is cheap (Cursor review on PR
+ * #1462).
+ */
+async function buildCorroborationContext(
+  sourceId: string,
+  date: string,
+  deps: WearableSyncDeps,
+): Promise<CorroborationContext> {
+  const otherSourceDayTokens = new Map<string, Set<string>>();
+  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 };
+}
+
 export function defaultTimezone(): string {
   try {
     return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";