@remnic/core 9.3.628 → 9.3.630

package/src/wearables/service.test.ts

@@ -74,6 +74,33 @@ function makeStorage(memoryDir: string): WearableStorageIo & {
     async hasFactContentHash() {
       return false;
     },
+    async findWearableMemoryByContent(content: string) {
+      const needle = content.trim();
+      const match = storage.memories.find(
+        (memory) =>
+          memory.frontmatter.source.startsWith("wearable:") &&
+          memory.content.trim() === needle,
+      );
+      return match
+        ? { id: match.frontmatter.id, status: match.frontmatter.status }
+        : null;
+    },
+    async promoteWearableMemory(id: string) {
+      const match = storage.memories.find((memory) => memory.frontmatter.id === id);
+      if (!match || match.frontmatter.status !== "pending_review") return false;
+      match.frontmatter.status = "active";
+      return true;
+    },
+    async demoteWearableMemory(id: string, attrs: Record<string, string>) {
+      const match = storage.memories.find((memory) => memory.frontmatter.id === id);
+      if (!match || match.frontmatter.status !== "pending_review") return false;
+      match.frontmatter.status = "rejected";
+      match.frontmatter.structuredAttributes = {
+        ...(match.frontmatter.structuredAttributes ?? {}),
+        ...attrs,
+      };
+      return true;
+    },
   };
   return storage;
 }
@@ -313,6 +340,151 @@ test("transcriptMemories filters by wearable source and day", async () => {
   }
 });
 
+test("support corpus includes pending_review rows and excludes terminal statuses", async () => {
+  const { registerWearableConnector, clearWearableConnectors } = await import("./registry.js");
+  const dir = mkdtempSync(path.join(tmpdir(), "remnic-service-"));
+  const borderlineFact =
+    "The launch moved to September twelfth after the vendor call.";
+  const makeRow = (
+    id: string,
+    status: string | undefined,
+    content: string,
+    archivedAt?: string,
+  ) => ({
+    path: `facts/${id}.md`,
+    frontmatter: {
+      id,
+      source: "wearable:limitless",
+      created: "2026-06-09T16:00:00.000Z",
+      tags: ["wearable"],
+      ...(status !== undefined ? { status } : {}),
+      ...(archivedAt !== undefined ? { archivedAt } : {}),
+      structuredAttributes: { wearableSource: "limitless" },
+    },
+    content,
+  });
+  const runSmartSync = async (
+    rows: ReturnType<typeof makeRow>[],
+  ): Promise<Record<string, unknown>> => {
+    const storage = makeStorage(mkdtempSync(path.join(tmpdir(), "remnic-service-mem-")));
+    storage.memories.push(...rows);
+    const writes: Array<{ options: Record<string, unknown> }> = [];
+    storage.writeMemory = (async (
+      _category: string,
+      _content: string,
+      options: Record<string, unknown>,
+    ) => {
+      writes.push({ options });
+      return `mem-${writes.length}`;
+    }) as WearableStorageIo["writeMemory"];
+    try {
+      registerWearableConnector({
+        id: "testsource",
+        displayName: "Test Source",
+        factory: () => ({
+          id: "testsource",
+          displayName: "Test Source",
+          verifyAuth: async () => ({ ok: true }),
+          fetchConversations: async () => ({
+            conversations: [
+              {
+                id: "c1",
+                source: "testsource",
+                startIso: "2026-06-10T15:00:00.000Z",
+                endIso: "2026-06-10T15:30:00.000Z",
+                segments: [
+                  { speakerKey: "user", isWearer: true, text: "We are moving the launch to September twelfth after that vendor call wrapped up." },
+                  { speakerKey: "guest", speakerName: "guest", text: "Confirmed, the vendor is aligned on the September date for the launch." },
+                ],
+              },
+            ],
+            nextCursor: null,
+          }),
+        }),
+      });
+      const service = new WearablesService({
+        config: {
+          ...defaultWearablesConfig(),
+          enabled: true,
+          digestEnabled: false,
+          sources: {
+            testsource: { ...defaultWearableSourceSettings(), enabled: true, memoryMode: "smart" },
+          },
+        },
+        getStorage: async () => storage,
+        // Borderline: 0.75 * 0.8 = 0.6 — active only with +0.10 support.
+        extract: async () => ({
+          facts: [{ category: "fact", content: borderlineFact, confidence: 0.75, tags: [] }],
+          profileUpdates: [],
+          entities: [],
+          questions: [],
+        }),
+        searchBackend: null,
+      });
+      await service.sync({ date: "2026-06-10" });
+      assert.equal(writes.length, 1);
+      return writes[0].options;
+    } finally {
+      clearWearableConnectors();
+    }
+  };
+
+  try {
+    // A pending_review row with matching content IS support evidence.
+    // (Similar wording, not identical — identical content would be
+    // consumed by the duplicate-existing dedup before scoring.)
+    const supported = await runSmartSync([
+      makeRow(
+        "pending-1",
+        "pending_review",
+        "The launch moved to September twelfth after the vendor call, noted earlier.",
+      ),
+    ]);
+    assert.equal(supported.status, "active");
+    assert.equal(
+      (supported.structuredAttributes as Record<string, string>).supportingMemoryId,
+      "pending-1",
+    );
+
+    // Terminal statuses with the same content are NOT support evidence.
+    const similar =
+      "The launch moved to September twelfth after the vendor call, noted earlier.";
+    const unsupported = await runSmartSync([
+      makeRow("rejected-1", "rejected", similar),
+      makeRow("quarantined-1", "quarantined", similar),
+      makeRow("superseded-1", "superseded", similar),
+      makeRow("archived-1", "archived", similar),
+      makeRow("forgotten-1", "forgotten", similar),
+      // Archived via archivedAt with NO explicit status — the
+      // canonical inferMemoryStatus must resolve this to archived.
+      makeRow("archived-implicit-1", undefined, similar, "2026-06-09T00:00:00.000Z"),
+    ]);
+    assert.equal(unsupported.status, "pending_review");
+    assert.equal(
+      (unsupported.structuredAttributes as Record<string, string>).supportingMemoryId,
+      undefined,
+    );
+
+    // Content matching ONLY through the "[Attributes: ...]" enrichment
+    // suffix is not corroboration — the suffix is stripped before
+    // token matching, so attribute metadata never grants the boost.
+    const suffixOnly = await runSmartSync([
+      makeRow(
+        "pending-2",
+        "pending_review",
+        "Unrelated note about quarterly budget planning.\n[Attributes: context: launch moved to September twelfth after the vendor call]",
+      ),
+    ]);
+    assert.equal(suffixOnly.status, "pending_review");
+    assert.equal(
+      (suffixOnly.structuredAttributes as Record<string, string>).supportingMemoryId,
+      undefined,
+    );
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test("the wearable memory writer dedups non-fact categories by content scan", async () => {
   const dir = mkdtempSync(path.join(tmpdir(), "remnic-service-"));
   try {

package/src/wearables/service.ts

@@ -12,7 +12,10 @@ import {
   compileCorrectionRule,
 } from "./corrections.js";
 import { describeErrorForOperator, WearablesInputError } from "./errors.js";
+import { inferMemoryStatus } from "../memory-lifecycle-ledger-utils.js";
 import { isValidTranscriptDate, parseDayTranscript } from "./day-store.js";
+import { stripAttributesSuffix } from "../storage.js";
+import type { MemoryFrontmatter } from "../types.js";
 import type { WearableMemoryGenDeps } from "./memory-gen.js";
 import { WEARABLE_SOURCE_PREFIX, wearableSourceLabel } from "./memory-gen.js";
 import {
@@ -65,6 +68,8 @@ export interface WearableStorageIo {
         created: string;
         tags: string[];
         status?: string;
+        /** Archival timestamp — rows with this set are not support. */
+        archivedAt?: string;
         structuredAttributes?: Record<string, string>;
       };
       content: string;
@@ -72,6 +77,18 @@ export interface WearableStorageIo {
   >;
   writeMemory: WearableMemoryGenDeps["writer"]["writeMemory"];
   hasFactContentHash(content: string): Promise<boolean>;
+  findWearableMemoryByContent(
+    content: string,
+  ): Promise<{ id: string; status: string | undefined } | null>;
+  promoteWearableMemory(
+    id: string,
+    attributeUpdates: Record<string, string>,
+    confidence?: number,
+  ): Promise<boolean>;
+  demoteWearableMemory(
+    id: string,
+    attributeUpdates: Record<string, string>,
+  ): Promise<boolean>;
 }
 
 export interface WearableSearchBackend {
@@ -87,6 +104,12 @@ export interface WearablesServiceDeps {
   getStorage(): Promise<WearableStorageIo>;
   /** Extraction hook; null when no engine is available. */
   extract: WearableMemoryGenDeps["extract"] | null;
+  /**
+   * LLM-as-judge hook for smart memoryMode (the orchestrator wires the
+   * existing extraction judge here). Absent degrades smart mode to
+   * confidence x sourceTrust + corroboration scoring.
+   */
+  judgeFacts?: WearableMemoryGenDeps["judgeFacts"];
   /** Search backend (QMD); null disables indexed search. */
   searchBackend: WearableSearchBackend | null;
   /** Fired after transcript writes so the search index refreshes. */
@@ -136,15 +159,25 @@ export function createWearableMemoryWriter(
 ): WearableMemoryGenDeps["writer"] {
   return {
     writeMemory: storage.writeMemory.bind(storage),
+    findWearableMemoryByContent: async (content: string) =>
+      (await storage.findWearableMemoryByContent(content)) as
+        | { id: string; status: import("../types.js").MemoryStatus | undefined }
+        | null,
+    promoteWearableMemory: storage.promoteWearableMemory.bind(storage),
+    demoteWearableMemory: storage.demoteWearableMemory.bind(storage),
     hasFactContentHash: async (content: string) => {
       if (await storage.hasFactContentHash(content)) return true;
-      const needle = content.trim();
+      // Compare with the "[Attributes: ...]" enrichment suffix removed
+      // on BOTH sides — stored wearable bodies carry it, callers pass
+      // raw fact text. Without the strip, digest/candidate dedup never
+      // matched attribute-bearing memories.
+      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,
+          stripAttributesSuffix(memory.content) === needle,
       );
     },
   };
@@ -263,6 +296,9 @@ export class WearablesService {
       ? {
           extract: this.deps.extract,
           writer: createWearableMemoryWriter(storage),
+          ...(this.deps.judgeFacts !== undefined
+            ? { judgeFacts: this.deps.judgeFacts }
+            : {}),
         }
       : null;
 
@@ -293,8 +329,53 @@ export class WearablesService {
           },
           writeDayTranscript: (source, date, serialized) =>
             storage.writeWearableDayTranscript(source, date, serialized),
-          afterTranscriptsWritten: this.deps.reindexSearch,
+          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 = new Map<string, string>();
+            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: Array<{ id: string; content: string }> = [];
+            for (const memory of memories) {
+              // WearableStorageIo narrows MemoryFrontmatter for
+              // testability; production hands us the real thing.
+              const status = inferMemoryStatus(
+                memory.frontmatter as MemoryFrontmatter,
+                memory.path,
+              );
+              if (status !== "active" && status !== "pending_review") {
+                continue;
+              }
+              support.push({
+                id: memory.frontmatter.id,
+                content: stripAttributesSuffix(memory.content),
+              });
+            }
+            return support;
+          },
         },
       );
       summaries.push(summary);

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);
+});