@remnic/core 9.3.629 → 9.3.631

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 {
@@ -51,10 +52,13 @@ import type {
   WearablesConfig,
 } from "./types.js";
 
-/** Safety cap on pages fetched per day window. */
-const MAX_PAGES_PER_DAY = 50;
-/** Safety cap on native-memory pages per sync. */
-const MAX_NATIVE_PAGES = 20;
+/**
+ * Pathological-provider backstop on pagination loops. Day fetches are
+ * intentionally UNLIMITED for real data — a full day must never be
+ * truncated — so runaway protection comes from cursor-cycle detection
+ * plus this far-out-of-band ceiling, not from a content-sized cap.
+ */
+const PAGE_SAFETY_CEILING = 10_000;
 /** Default lookback window (today + yesterday) for unscoped syncs. */
 const DEFAULT_SYNC_DAYS = 2;
 const MAX_SYNC_DAYS = 90;
@@ -80,14 +84,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;
 }
@@ -163,23 +189,42 @@ async function fetchAllConversationsForDate(
   signal: AbortSignal | undefined,
   warnings: string[],
 ): Promise<{ conversations: WearableConversation[]; partial: boolean }> {
-  const conversations: WearableConversation[] = [];
+  // Keyed by conversation id: a looping or overlapping provider can
+  // re-serve rows it already returned, and appending blindly would
+  // store the same conversation twice in the day file (Cursor review
+  // on PR #1464). Map keeps first-seen order; a re-served id replaces
+  // its entry in place, so the provider's LATEST version of a
+  // conversation wins — exactly what the current-day refresh wants.
+  const byId = new Map<string, WearableConversation>();
   let cursor: string | null | undefined = undefined;
-  for (let page = 0; page < MAX_PAGES_PER_DAY; page++) {
+  const seenCursors = new Set<string>();
+  const collect = () => [...byId.values()];
+  for (let page = 0; page < PAGE_SAFETY_CEILING; page++) {
     const result = await connector.fetchConversations({
       date,
       timezone,
       cursor,
       signal,
     });
-    conversations.push(...result.conversations);
-    if (!result.nextCursor) return { conversations, partial: false };
+    for (const conversation of result.conversations) {
+      byId.set(conversation.id, conversation);
+    }
+    if (!result.nextCursor) return { conversations: collect(), partial: false };
+    // A repeated cursor means the provider's pagination is looping —
+    // following it again would refetch the same page forever.
+    if (seenCursors.has(result.nextCursor)) {
+      warnings.push(
+        `${connector.id}: provider pagination repeated cursor on ${date} — stopped to avoid an infinite loop; day may be partially synced (every sync refetches and re-warns while the provider misbehaves)`,
+      );
+      return { conversations: collect(), partial: true };
+    }
+    seenCursors.add(result.nextCursor);
     cursor = result.nextCursor;
   }
   warnings.push(
-    `${connector.id}: stopped paginating ${date} after ${MAX_PAGES_PER_DAY} pages — day may be partially synced (every sync refetches and re-warns until the provider day fits the cap)`,
+    `${connector.id}: stopped paginating ${date} after the ${PAGE_SAFETY_CEILING}-page safety ceiling — day may be partially synced (every sync refetches and re-warns while this persists)`,
   );
-  return { conversations, partial: true };
+  return { conversations: collect(), partial: true };
 }
 
 /** Visible marker appended to day files whose fetch hit the page cap. */
@@ -276,6 +321,8 @@ export async function syncWearableSource(
     correctionsApplied: 0,
     transcriptsWritten: [],
     memoriesCreated: 0,
+    memoriesPromoted: 0,
+    memoriesDemoted: 0,
     memoriesSkipped: 0,
     nativeMemoriesImported: 0,
     warnings: [],
@@ -380,6 +427,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 +456,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 +511,7 @@ export async function syncWearableSource(
   }
 
   if (
-    settings.importNativeMemories === "review" &&
+    settings.importNativeMemories !== "off" &&
     typeof connector.fetchNativeMemories === "function"
   ) {
     if (!deps.memoryGen) {
@@ -459,8 +522,29 @@ 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 seenNativeCursors = new Set<string>();
+      for (let page = 0; page < PAGE_SAFETY_CEILING; page++) {
         const result = await connector.fetchNativeMemories({
           cursor,
           signal: options.signal,
@@ -469,28 +553,43 @@ 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);
         if (!result.nextCursor) break;
+        if (seenNativeCursors.has(result.nextCursor)) {
+          summary.warnings.push(
+            `${connector.id}: provider pagination repeated cursor during native-memory import — stopped to avoid an infinite loop; remaining items import on the next sync`,
+          );
+          break;
+        }
+        seenNativeCursors.add(result.nextCursor);
         cursor = result.nextCursor;
-        if (page === MAX_NATIVE_PAGES - 1) {
+        if (page === PAGE_SAFETY_CEILING - 1) {
           summary.warnings.push(
-            `${connector.id}: stopped native-memory import after ${MAX_NATIVE_PAGES} pages — remaining items import on the next sync`,
+            `${connector.id}: stopped native-memory import at the ${PAGE_SAFETY_CEILING}-page safety ceiling — remaining items import on the next sync`,
           );
         }
       }
     }
   }
 
-  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 +604,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";

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