@remnic/core 9.45.4 → 9.46.0

package/src/testing/subjects/recall-search-prefilter.test.ts

@@ -0,0 +1,365 @@
+import assert from "node:assert/strict";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import { parseConfig } from "../../config.js";
+import type { EmbeddingFallback } from "../../embedding-fallback.js";
+import {
+  type PrefilterAndArtifactDeps,
+  buildQueryAwarePrefilter,
+  fetchActiveArtifactsForNamespace,
+  searchEmbeddingFallback,
+  searchQueryAwareFallback,
+} from "../../orchestration/recall-search-prefilter.js";
+import type { QueryAwarePrefilter } from "../../orchestrator.js";
+import { StorageManager } from "../../storage.js";
+import type { MemoryFile, PluginConfig, QmdSearchResult } from "../../types.js";
+import { type LifecycleSubject, type MatrixRow, runLifecycleMatrix } from "../lifecycle-matrix.js";
+import { cleanupDir, mkTempMemoryDir } from "../orchestrator-lite.js";
+
+interface RecallSearchPrefilterState {
+  memoryDir: string;
+  config: PluginConfig;
+  storage: StorageManager;
+  fetchLimitsSeen: number[];
+  activeArtifactsResult?: MemoryFile[];
+  prefilterResult?: QueryAwarePrefilter;
+  prefilterOverflowResult?: QueryAwarePrefilter;
+  embeddingResult?: QmdSearchResult[];
+  embeddingDisabledResult?: QmdSearchResult[];
+  queryAwareFallbackResult?: QmdSearchResult[];
+  queryAwareFallbackEmptyResult?: QmdSearchResult[];
+  scopedOptionsSeen?: { allowArchived?: boolean };
+  scopedNamespacesSeen?: string[];
+}
+
+const subject: LifecycleSubject<RecallSearchPrefilterState> = {
+  appliesTo(row: MatrixRow): boolean | string {
+    if (row.id === "explicit-provider-identity" || row.id === "restart-reload-recovery") {
+      return true;
+    }
+    return `recall search prefilter helper pipeline has no ${row.id} session/flush/dedupe semantics to realize`;
+  },
+
+  async setup(row: MatrixRow): Promise<RecallSearchPrefilterState> {
+    const memoryDir = await mkTempMemoryDir(`recall-search-prefilter-${row.id}`);
+    try {
+      const config = parseConfig({
+        memoryDir,
+        queryAwareIndexingEnabled: true,
+        queryAwareIndexingMaxCandidates: 100,
+        embeddingFallbackEnabled: true,
+      });
+      const storage = new StorageManager(memoryDir);
+      return {
+        memoryDir,
+        config,
+        storage,
+        fetchLimitsSeen: [],
+      };
+    } catch (error) {
+      await cleanupDir(memoryDir);
+      throw error;
+    }
+  },
+
+  async exercise(state: RecallSearchPrefilterState, row: MatrixRow): Promise<void> {
+    await state.storage.ensureDirectories();
+    const stateDir = path.join(state.memoryDir, "state");
+    await mkdir(stateDir, { recursive: true });
+
+    await writeFile(
+      path.join(stateDir, "index_tags.json"),
+      JSON.stringify({
+        version: 2,
+        tags: {
+          review: { paths: ["facts/a.md", "facts/b.md"] },
+          report: { paths: ["facts/b.md", "facts/c.md"] },
+        },
+        aliases: {},
+      }),
+      "utf8"
+    );
+    await writeFile(
+      path.join(stateDir, "index_time.json"),
+      JSON.stringify({
+        version: 2,
+        dates: {
+          "2026-07-31": ["facts/a.md"],
+        },
+        events: {},
+      }),
+      "utf8"
+    );
+
+    const writtenMem = await state.storage.writeMemory(
+      "fact",
+      "Embedding fallback test memory content for hydration verification.",
+      { source: "test-source" }
+    );
+    const memFile = await state.storage.getMemoryById(writtenMem.id);
+    assert.ok(memFile, "stored memory file must exist for embedding test");
+    const memPath = memFile.path;
+
+    if (row.dimensions.restart) {
+      state.storage = new StorageManager(state.memoryDir);
+    }
+
+    const mockArtifacts: MemoryFile[] = [
+      {
+        path: "artifacts/stale.md",
+        content: "stale artifact",
+        frontmatter: { sourceMemoryId: "src-stale" },
+      } as unknown as MemoryFile,
+      {
+        path: "artifacts/active1.md",
+        content: "active artifact 1",
+        frontmatter: { sourceMemoryId: "src-active1" },
+      } as unknown as MemoryFile,
+      {
+        path: "artifacts/active2.md",
+        content: "active artifact 2",
+        frontmatter: { sourceMemoryId: "src-active2" },
+      } as unknown as MemoryFile,
+      {
+        path: "artifacts/missing.md",
+        content: "missing artifact",
+        frontmatter: { sourceMemoryId: "src-missing" },
+      } as unknown as MemoryFile,
+    ];
+
+    const storageRouter = {
+      storageFor: async () =>
+        ({
+          searchArtifacts: async (_prompt: string, limit: number) => {
+            state.fetchLimitsSeen.push(limit);
+            if (state.fetchLimitsSeen.length === 1) {
+              return [mockArtifacts[1], ...Array.from({ length: limit - 1 }, () => mockArtifacts[0])];
+            }
+            return mockArtifacts;
+          },
+        }) as unknown as StorageManager,
+    } as unknown as PrefilterAndArtifactDeps["storageRouter"];
+
+    const resolveArtifactSourceStatuses = async (
+      _stg: unknown,
+      sourceIds: string[]
+    ): Promise<Map<string, "active" | "superseded" | "archived" | "missing">> => {
+      const map = new Map<string, "active" | "superseded" | "archived" | "missing">();
+      for (const id of sourceIds) {
+        if (id === "src-stale") map.set(id, "superseded");
+        else if (id === "src-active1" || id === "src-active2") map.set(id, "active");
+        else if (id === "src-missing") map.set(id, "missing");
+      }
+      return map;
+    };
+
+    state.activeArtifactsResult = await fetchActiveArtifactsForNamespace(
+      {
+        storageRouter,
+        resolveArtifactSourceStatuses,
+      },
+      "default",
+      "artifact prompt",
+      2
+    );
+
+    const scopeQueryAwarePaths = (paths: Set<string> | null, namespaces: string[]): Set<string> | null => {
+      state.scopedNamespacesSeen = namespaces;
+      return paths;
+    };
+
+    state.prefilterResult = await buildQueryAwarePrefilter(
+      {
+        config: state.config,
+        scopeQueryAwarePaths,
+      },
+      "2026-07-31 #review quarterly report",
+      ["default"]
+    );
+
+    const overflowConfig = parseConfig({
+      memoryDir: state.memoryDir,
+      queryAwareIndexingEnabled: true,
+      queryAwareIndexingMaxCandidates: 1,
+    });
+
+    state.prefilterOverflowResult = await buildQueryAwarePrefilter(
+      {
+        config: overflowConfig,
+        scopeQueryAwarePaths,
+      },
+      "#review quarterly report",
+      ["default"]
+    );
+
+    const embeddingFallback: EmbeddingFallback = {
+      isAvailable: async () => true,
+      search: async (_query: string, _limit: number) => [
+        {
+          id: "emb-hit-1",
+          path: memPath,
+          score: 0.95,
+        },
+      ],
+    } as unknown as EmbeddingFallback;
+
+    state.embeddingResult = await searchEmbeddingFallback(
+      {
+        config: state.config,
+        embeddingFallback,
+        storage: state.storage,
+      },
+      "hydration query",
+      5
+    );
+
+    const disabledConfig = parseConfig({
+      memoryDir: state.memoryDir,
+      embeddingFallbackEnabled: false,
+    });
+
+    state.embeddingDisabledResult = await searchEmbeddingFallback(
+      {
+        config: disabledConfig,
+        embeddingFallback,
+        storage: state.storage,
+      },
+      "hydration query",
+      5
+    );
+
+    const meetingRecordPath = "meetings/2026-03-10/mtg-2026-03-10-abcdef01.md";
+    const recallablePath = "facts/quarterly-report.md";
+
+    const searchScopedMemoryCandidates = async (
+      candidatePaths: Set<string>,
+      _query: string,
+      limit: number,
+      options?: { allowArchived?: boolean }
+    ): Promise<QmdSearchResult[]> => {
+      state.scopedOptionsSeen = options;
+      const all: QmdSearchResult[] = [
+        { docid: "doc-mtg", path: meetingRecordPath, score: 0.99, snippet: "meeting" },
+        { docid: "doc-fact", path: recallablePath, score: 0.88, snippet: "fact" },
+      ];
+      return all.filter((item) => candidatePaths.has(item.path)).slice(0, limit);
+    };
+
+    const prefilterForFallback: QueryAwarePrefilter = {
+      candidatePaths: new Set([meetingRecordPath, recallablePath]),
+      temporalFromDate: null,
+      matchedTags: ["review"],
+      expandedTags: ["review"],
+      combination: "tag",
+      filteredToFullSearch: false,
+    };
+
+    state.queryAwareFallbackResult = await searchQueryAwareFallback(
+      {
+        config: state.config,
+        searchScopedMemoryCandidates,
+      },
+      "quarterly",
+      1,
+      prefilterForFallback
+    );
+
+    state.queryAwareFallbackEmptyResult = await searchQueryAwareFallback(
+      {
+        config: state.config,
+        searchScopedMemoryCandidates,
+      },
+      "quarterly",
+      0,
+      prefilterForFallback
+    );
+  },
+
+  async invariants(state: RecallSearchPrefilterState, _row: MatrixRow): Promise<void> {
+    assert.ok(state.activeArtifactsResult, "activeArtifactsResult must be populated");
+    assert.equal(state.activeArtifactsResult.length, 2, "must adaptively retrieve targetCount active artifacts");
+    assert.deepEqual(
+      state.activeArtifactsResult.map((a) => a.path),
+      ["artifacts/active1.md", "artifacts/active2.md"],
+      "must filter out stale and missing source artifacts"
+    );
+    assert.ok(
+      state.fetchLimitsSeen.length > 1,
+      "must attempt top-up with grown fetch limit when initial results yield fewer active artifacts than targetCount"
+    );
+    assert.ok(
+      state.fetchLimitsSeen[1] > state.fetchLimitsSeen[0],
+      "fetchLimit must adaptively increase across top-up attempts"
+    );
+
+    assert.ok(state.prefilterResult, "prefilterResult must be populated");
+    assert.ok(state.prefilterResult.matchedTags.includes("review"), "must extract matched tags from prompt");
+    assert.ok(
+      state.prefilterResult.candidatePaths instanceof Set,
+      "candidatePaths must be a Set when candidate count <= maxCandidates"
+    );
+    assert.equal(state.prefilterResult.filteredToFullSearch, false, "must not set filteredToFullSearch when under cap");
+    assert.equal(
+      state.prefilterResult.temporalFromDate,
+      "2026-07-31",
+      "must combine temporal and tag prefilter inputs"
+    );
+    assert.deepEqual(
+      state.prefilterResult.candidatePaths,
+      new Set(["facts/a.md"]),
+      "must intersect temporal and tag candidates"
+    );
+    assert.deepEqual(state.scopedNamespacesSeen, ["default"], "must scope query-aware paths to the recall namespaces");
+
+    assert.ok(state.prefilterOverflowResult, "prefilterOverflowResult must be populated");
+    assert.equal(
+      state.prefilterOverflowResult.candidatePaths,
+      null,
+      "candidatePaths must be reset to null when exceeding maxCandidates"
+    );
+    assert.equal(
+      state.prefilterOverflowResult.filteredToFullSearch,
+      true,
+      "filteredToFullSearch must be true when candidates exceed maxCandidates"
+    );
+
+    assert.ok(state.embeddingResult, "embeddingResult must be populated");
+    assert.equal(state.embeddingResult.length, 1, "must return hydrated search hit");
+    assert.equal(state.embeddingResult[0].docid, "emb-hit-1");
+    assert.equal(state.embeddingResult[0].score, 0.95);
+    assert.match(
+      state.embeddingResult[0].snippet,
+      /Embedding fallback test memory content for hydration verification/,
+      "must hydrate memory content into search snippet"
+    );
+
+    assert.ok(state.embeddingDisabledResult, "embeddingDisabledResult must be populated");
+    assert.deepEqual(
+      state.embeddingDisabledResult,
+      [],
+      "must return empty array when embeddingFallback capability is disabled"
+    );
+
+    assert.ok(state.queryAwareFallbackResult, "queryAwareFallbackResult must be populated");
+    assert.equal(state.queryAwareFallbackResult.length, 1, "must respect result limit cap");
+    assert.equal(
+      state.queryAwareFallbackResult[0].path,
+      "facts/quarterly-report.md",
+      "must exclude meeting record before applying result cap so valid candidate is returned at the cap"
+    );
+    assert.deepEqual(
+      state.scopedOptionsSeen,
+      { allowArchived: true },
+      "must request allowArchived when searching candidate paths for historical filtering"
+    );
+
+    assert.deepEqual(state.queryAwareFallbackEmptyResult, [], "must return empty array when limit is zero");
+  },
+
+  async teardown(state: RecallSearchPrefilterState): Promise<void> {
+    await cleanupDir(state.memoryDir);
+  },
+};
+
+runLifecycleMatrix("recall-search-prefilter", subject);

package/src/tier-migration.ts

@@ -88,18 +88,16 @@ export class TierMigrationExecutor {
 
     await this.appendJournal(result);
 
-    if (result.changed) {
-      const destinationCollection = this.collectionForTier(toTier);
-      const sourceCollection = this.collectionForTier(fromTier);
-      await this.updateCollectionFromTierRoot(destinationCollection, toTier);
-      if (sourceCollection !== destinationCollection && this.qmd.updatesAllCollections?.() !== true) {
-        await this.updateCollectionFromTierRoot(sourceCollection, fromTier);
-      }
-      if (this.autoEmbed) {
-        await this.qmd.embedCollection(destinationCollection);
-        if (sourceCollection !== destinationCollection) {
-          await this.qmd.embedCollection(sourceCollection);
-        }
+    const destinationCollection = this.collectionForTier(toTier);
+    const sourceCollection = this.collectionForTier(fromTier);
+    await this.updateCollectionFromTierRoot(destinationCollection, toTier);
+    if (sourceCollection !== destinationCollection && this.qmd.updatesAllCollections?.() !== true) {
+      await this.updateCollectionFromTierRoot(sourceCollection, fromTier);
+    }
+    if (this.autoEmbed) {
+      await this.qmd.embedCollection(destinationCollection);
+      if (sourceCollection !== destinationCollection) {
+        await this.qmd.embedCollection(sourceCollection);
       }
     }
 

package/src/types.ts

@@ -6,7 +6,7 @@ import type { ExtractionLivenessConfig } from "./extraction-liveness.js";
 import type { ReplicaPeersConfig } from "./replica-peers-config.js";
 import type { ExternalWikiRoot } from "./external-wiki-config.js";
 
-import type { BufferTurnOwner } from "./buffer-turn-helpers.js";
+import type { AmbientCaptureProvenance, BufferTurnOwner } from "./buffer-turn-helpers.js";
 export type ReasoningEffort = "none" | "low" | "medium" | "high";
 export type TriggerMode = "smart" | "every_n" | "time_based";
 export type ConvergeConflictPolicy = "newest-wins" | "manual";
@@ -2643,7 +2643,7 @@ export interface RelevanceFeedback {
 export interface SourceConnectorProvenance {
   sourceConnector?: string;
 }
-export interface BufferTurn extends SourceConnectorProvenance, BufferTurnOwner {
+export interface BufferTurn extends SourceConnectorProvenance, BufferTurnOwner, AmbientCaptureProvenance {
   role: "user" | "assistant";
   content: string;
   timestamp: string;

package/src/wearables/memory-gen.test.ts

@@ -224,6 +224,33 @@ test("auto mode writes active status", async () => {
   assert.equal(writes[0].options.status, "active");
 });
 
+test("auto mode still refuses to write a high-impact personal claim active (#2294)", async () => {
+  // `auto` has no trust scoring, and an operator may lower minConfidence to or
+  // below the speculative ceiling the ambient clamp writes — which would let a
+  // clamped TV line straight into recall without this guard.
+  const { writer, writes } = makeWriter();
+  await generateWearableMemories(
+    "limitless",
+    "2026-06-10",
+    [LONG_CONVERSATION],
+    settings({ memoryMode: "auto", minConfidence: 0.3 }),
+    REGISTRY,
+    {
+      extract: extractionReturning([
+        { category: "fact", content: "Dana's mother has a birthday on June 3rd.", confidence: 0.39, tags: [] },
+        { category: "fact", content: "Vendor call happens tomorrow morning.", confidence: 0.8, tags: [] },
+      ]),
+      writer,
+    },
+  );
+  const personal = writes.find((w) => w.content.includes("birthday"));
+  assert.ok(personal, "the personal claim was written");
+  assert.equal(personal!.options.status, "pending_review");
+  const ordinary = writes.find((w) => w.content.includes("Vendor call"));
+  assert.ok(ordinary, "the ordinary fact was written");
+  assert.equal(ordinary!.options.status, "active");
+});
+
 test("gates: confidence floor, importance floor, dedup, and unsupported categories", async () => {
   const { writer, writes } = makeWriter(["Already stored fact about the vendor."]);
   const result = await generateWearableMemories(
@@ -343,6 +370,61 @@ test("daily digest writes one deterministic episode memory and dedups", async ()
   assert.equal(writes2.length, 0);
 });
 
+test("review mode queues a clamped personal claim instead of dropping it below the floor (#2294)", async () => {
+  // The extraction clamp pins high-impact ambient facts to 0.39, under the 0.6
+  // default minConfidence — so without an exemption the pre-filter would drop
+  // exactly the candidates review mode promises to queue.
+  const { writer, writes } = makeWriter();
+  const result = await generateWearableMemories(
+    "limitless",
+    "2026-06-10",
+    [LONG_CONVERSATION],
+    settings({ memoryMode: "review" }),
+    REGISTRY,
+    {
+      extract: extractionReturning([
+        { category: "fact", content: "Dana's mother has a birthday on June 3rd.", confidence: 0.39, tags: [] },
+        { category: "fact", content: "A low-signal rumor about the vendor.", confidence: 0.39, tags: [] },
+      ]),
+      writer,
+    },
+  );
+
+  assert.equal(writes.length, 1, "only the high-impact claim is exempt from the floor");
+  assert.match(writes[0].content, /birthday/);
+  assert.equal(writes[0].options.status, "pending_review");
+  assert.equal(result.skippedByReason["below-confidence"], 1, "ordinary low-confidence facts still drop");
+});
+
+test("a digest whose provider title is a personal claim is held for review (#2294)", async () => {
+  // Providers derive conversation.title from the same captured audio, so a
+  // title lifted from a television scene must not ride into recall on the
+  // digest, which bypasses extraction and its clamp entirely.
+  const { writer, writes } = makeWriter();
+  const wrote = await writeDailyDigestMemory(
+    "limitless",
+    "2026-06-10",
+    [{ ...LONG_CONVERSATION, title: "Dana's cancer diagnosis" }],
+    settings({ memoryMode: "smart" }),
+    REGISTRY,
+    writer,
+  );
+
+  assert.equal(wrote, true, "the digest is still written, just not active");
+  assert.equal(writes[0].options.status, "pending_review");
+
+  const { writer: clean, writes: cleanWrites } = makeWriter();
+  await writeDailyDigestMemory(
+    "limitless",
+    "2026-06-10",
+    [LONG_CONVERSATION],
+    settings({ memoryMode: "smart" }),
+    REGISTRY,
+    clean,
+  );
+  assert.equal(cleanWrites[0].options.status, "active", "an ordinary digest is unaffected");
+});
+
 function judgeReturning(
   kinds: Array<"accept" | "reject" | "defer">,
 ): NonNullable<Parameters<typeof generateWearableMemories>[5]["judgeFacts"]> {

package/src/wearables/memory-gen.ts

@@ -28,6 +28,7 @@
  */
 
 import { scoreImportance } from "../importance.js";
+import { collectPersonEntityRefs, isHighImpactPersonalFact } from "../ambient-provenance.js";
 import type { MemoryWriteResult } from "../storage.js";
 import {
   composeMemoryEnvelope,
@@ -241,6 +242,9 @@ export function buildExtractionTurns(
       timestamp,
       sourceValidAt: timestamp,
       sessionKey,
+      // Always-on capture: this transcript may carry TV, podcast, or
+      // overheard speech the wearer never authored (issue #2294).
+      ambientCapture: true,
     });
     chunkLines = [];
     chunkChars = 0;
@@ -258,6 +262,12 @@ interface GatedCandidate {
   fact: ExtractedFact;
   importance: ImportanceScore;
   conversation: WearableConversation;
+  /**
+   * Ambient high-impact verdict, decided where the extraction's entity list is
+   * still in scope so personhood comes from the extractor's own `type:
+   * "person"` metadata rather than the spelling of `entityRef` (#2294).
+   */
+  highImpact: boolean;
 }
 
 interface ScoredCandidate {
@@ -375,6 +385,7 @@ export async function generateWearableMemories(
       result.completed = false;
       break;
     }
+    const personRefs = collectPersonEntityRefs(extraction);
     for (const fact of extraction.facts) {
       const content = fact.content?.trim();
       if (!content) {
@@ -385,10 +396,18 @@ export async function generateWearableMemories(
         skip("unsupported-category");
         continue;
       }
+      const highImpact = isHighImpactPersonalFact({ ...fact, content }, personRefs);
       // In smart mode the trust bands subsume the hard confidence
       // floor — a borderline fact belongs in the review band, not on
       // the floor. The pre-filter applies to review/auto modes only.
+      //
+      // High-impact ambient claims are exempt: the extraction clamp just
+      // pinned them to 0.39, which is below the 0.6 default floor, so the
+      // pre-filter would silently drop the very candidates `review` mode
+      // promises to queue and would make the auto-mode cap unreachable
+      // (#2294). They skip the floor and land pending_review via the cap.
       if (
+        highImpact === false &&
         settings.memoryMode !== "smart" &&
         typeof fact.confidence === "number" &&
         fact.confidence < settings.minConfidence
@@ -410,7 +429,12 @@ export async function generateWearableMemories(
         continue;
       }
       seenContent.add(dedupKey);
-      candidates.push({ fact: { ...fact, content }, importance, conversation });
+      candidates.push({
+        fact: { ...fact, content },
+        importance,
+        conversation,
+        highImpact,
+      });
     }
   }
 
@@ -446,8 +470,13 @@ export async function generateWearableMemories(
     const promoteScores = await scoreCandidates(promotable, settings, deps, result);
     for (const [index, candidate] of promotable.entries()) {
       const scored = promoteScores.get(index);
+      // Every wearable candidate is ambient by construction, so a high-impact
+      // personal claim can only ever reach the review queue — late-arriving
+      // corroboration must not promote a clamped TV line to active (#2294).
       const decision = scored
-        ? decideSmart(scored.trust, scored.verdict, settings)
+        ? decideSmart(scored.trust, scored.verdict, settings, {
+            capAtReview: candidate.highImpact,
+          })
         : undefined;
       if (!scored || !decision) {
         skip("duplicate-existing");
@@ -536,13 +565,24 @@ export async function generateWearableMemories(
   const modeStatus = memoryStatusForMode(settings.memoryMode);
   const writable: Writable[] = [];
   novel.forEach((candidate, index) => {
+    // Every wearable candidate is ambient, so a high-impact personal claim can
+    // never be written active — on ANY mode. `auto` has no trust scoring and an
+    // operator may set minConfidence at or below the speculative ceiling, which
+    // would otherwise let a clamped TV line straight into recall (#2294).
+    const capAtReview = candidate.highImpact;
     if (settings.memoryMode !== "smart") {
-      writable.push({ candidate, index, status: modeStatus, trustAttributes: {} });
+      const status = capAtReview ? "pending_review" : modeStatus;
+      writable.push({
+        candidate,
+        index,
+        status,
+        trustAttributes: capAtReview ? { trustDecision: "ambient-high-impact" } : {},
+      });
       return;
     }
     const scored = trustById.get(index);
     if (!scored) return;
-    const decision = decideSmart(scored.trust, scored.verdict, settings);
+    const decision = decideSmart(scored.trust, scored.verdict, settings, { capAtReview });
     if (decision.outcome === "drop") {
       skip(decision.reason);
       return;
@@ -680,10 +720,19 @@ export async function writeDailyDigestMemory(
     },
     { source: wearableSourceLabel(sourceId) },
   );
+  // A provider derives conversation.title from the same captured audio, so a
+  // title lifted from a television scene ("Dana's cancer diagnosis") would
+  // otherwise ride into recall on the digest, bypassing the extraction prompt
+  // and its clamp entirely. Digest content is `moment`, which the classifier
+  // already treats as personal-claim-shaped, so this reads the titles alone
+  // and holds only a contaminated digest for review (#2294).
+  const titleIsHighImpact = lines.some((line) =>
+    isHighImpactPersonalFact({ category: "fact", content: line }),
+  );
   await writer.writeSealedMemory(digestEnvelope, {
     importance: scoreImportance(content, "moment", ["daily-digest"]),
     contentHashSource: content,
-    status: memoryStatusForMode(settings.memoryMode),
+    status: titleIsHighImpact ? "pending_review" : memoryStatusForMode(settings.memoryMode),
     memoryKind: "episode",
   });
   return true;

package/src/wearables/trust.ts

@@ -142,15 +142,30 @@ export interface SmartDecision {
     | "judge-deferred"
     | "auto-approved"
     | "queued-for-review"
-    | "below-trust";
+    | "below-trust"
+    | "ambient-high-impact";
   trust: number;
 }
 
+export interface SmartDecisionOptions {
+  /**
+   * Deny auto-approval regardless of score (issue #2294). Set for high-impact
+   * personal facts derived from ambient capture: clamping extraction
+   * confidence to the speculative ceiling is not enough on its own, because
+   * judge-accept plus cross-source and existing-memory boosts sum past
+   * `autoApproveTrust` — and two devices in one room recording the same
+   * television program corroborate each other perfectly. Such a candidate
+   * tops out in the review queue.
+   */
+  capAtReview?: boolean;
+}
+
 /** 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 },
+  options?: SmartDecisionOptions,
 ): SmartDecision {
   if (judgeVerdict === "reject") {
     return { outcome: "drop", reason: "judge-rejected", trust };
@@ -159,7 +174,9 @@ export function decideSmart(
     return { outcome: "review", reason: "judge-deferred", trust };
   }
   if (trust >= thresholds.autoApproveTrust) {
-    return { outcome: "active", reason: "auto-approved", trust };
+    return options?.capAtReview === true
+      ? { outcome: "review", reason: "ambient-high-impact", trust }
+      : { outcome: "active", reason: "auto-approved", trust };
   }
   if (trust >= thresholds.reviewTrust) {
     return { outcome: "review", reason: "queued-for-review", trust };