@remnic/core 9.45.5 → 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/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 };

package/dist/chunk-2X2T2UVE.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/source-agent-qualifier.ts"],"sourcesContent":["/**\n * Source-agent qualifier helpers for extraction (#2183).\n *\n * Pure leaf module: imports only types and sibling leaf/orchestration helpers,\n * never `extraction.ts`, so it introduces no cycle (extraction-run.ts only\n * type-imports extraction.ts).\n */\nimport { resolvePipelineProcessingCapabilities } from \"./capabilities.js\";\nimport { applyExtractionSourceGrounding } from \"./extraction-source-grounding.js\";\nimport type { ExtractionGroundingRoleSources } from \"./extraction-source-grounding.js\";\nimport { isValidConnectorId } from \"./connectors/index.js\";\nimport { CONNECTOR_LABEL_MAX_LENGTH, knownConnectorIds } from \"./connectors/label.js\";\nimport { deriveSourceConnector } from \"./orchestration/extraction-run.js\";\nimport type { BufferTurn, ExtractionResult, PluginConfig } from \"./types.js\";\n\n\nexport function resolveSourceConnector(turns: readonly BufferTurn[]): string | undefined {\n  const contributing = turns.filter((turn) => turn.extractionContextOnly !== true);\n  const derived = deriveSourceConnector(contributing);\n  if (derived === undefined || !isValidConnectorId(derived)) return undefined;\n  return /[\\u0000-\\u001F\\u007F]/.test(derived) ? undefined : derived;\n}\n\n// Same bound as the recall renderer (CONNECTOR_LABEL_MAX_LENGTH) but a DIFFERENT\n// policy: recall TRUNCATES past the bound (a truncated display label cannot\n// mislead), while the prompt SUPPRESSES (a truncated id could collide with a\n// different connector). Do not \"fix\" this inconsistency — it is deliberate.\nexport function headerConnector(connector: string | undefined): string | undefined {\n  return connector !== undefined && connector.length <= CONNECTOR_LABEL_MAX_LENGTH ? connector : undefined;\n}\n\nexport function renderExtractionConversation(\n  boundedTurns: readonly BufferTurn[],\n  sourceConnector: string | undefined,\n): { conversation: string; renderedConversation: string } {\n  const renderedConversation = boundedTurns\n    .map((t) => `[${t.extractionContextOnly === true ? `context ${t.role}` : t.role}] ${t.content}`)\n    .join(\"\\n\\n\");\n  const conversation = sourceConnector === undefined\n    ? renderedConversation\n    : `Source agent: ${sourceConnector}\\n\\nTool and command instructions in this conversation apply to the ${sourceConnector} agent unless they are clearly universal.\\n\\n${renderedConversation}`;\n  return { conversation, renderedConversation };\n}\n\nexport interface ExtractionGroundingContext {\n  groundingSource: string;\n  assertionSource: string;\n  roleAssertionSources?: ExtractionGroundingRoleSources;\n  messageTimestamp: Date | undefined;\n  sourceConnector?: string;\n  scopeClassificationEnabled?: boolean;\n}\n\nexport function applyGroundingWithConnector(\n  config: PluginConfig,\n  result: ExtractionResult,\n  ctx: ExtractionGroundingContext,\n): ExtractionResult {\n  const caps = resolvePipelineProcessingCapabilities(config);\n  const options = { sourceGrounding: caps.sourceGrounding, anchorTemporalExpressions: caps.delinearize };\n  const known = buildKnownConnectors(ctx.sourceConnector);\n  // Scope-forcing is decoupled from strip/restore (runs without a trusted\n  // connector) but gated on the capability: flag off = byte-identical pre-#2183.\n  const scoped = ctx.scopeClassificationEnabled === false\n    ? result\n    : forceProjectScopeOnAnyQualifier(result, known);\n  if (ctx.sourceConnector === undefined) {\n    return applyExtractionSourceGrounding(scoped, ctx.groundingSource, ctx.assertionSource, ctx.roleAssertionSources, ctx.messageTimestamp, options);\n  }\n  const prepared = prepareTrustedConnectorQualifier(scoped, ctx.sourceConnector, known);\n  const grounded = applyExtractionSourceGrounding(prepared.result, ctx.groundingSource, ctx.assertionSource, ctx.roleAssertionSources, ctx.messageTimestamp, options);\n  return restoreTrustedConnectorQualifier(grounded);\n}\n\nfunction buildKnownConnectors(trusted: string | undefined): Set<string> {\n  const known = new Set<string>();\n  for (const id of knownConnectorIds()) known.add(id.toLowerCase());\n  if (trusted !== undefined) known.add(trusted.toLowerCase());\n  return known;\n}\n\n/**\n * Parse a leading agent qualifier from fact text. ONE parser, ONE boundary\n * rule, ONE case policy (case-insensitive), ONE definition of \"agent\" (the name\n * must be a known connector ID). Returns the matched agent and the remaining\n * text, or undefined. Both scope-forcing and strip/restore consume this single\n * result so they can never disagree (#2183 round-11).\n */\nfunction parseLeadingQualifier(content: string, known: ReadonlySet<string>): { agent: string; rest: string } | undefined {\n  const lower = content.toLowerCase();\n  for (const lead of [\"in \", \"for \"]) {\n    if (!lower.startsWith(lead)) continue;\n    const m = lower.slice(lead.length).match(/^([a-z0-9][a-z0-9._-]*)\\s*,/u);\n    if (m && known.has(m[1])) {\n      const consumed = lead.length + m[0].length;\n      return { agent: m[1], rest: content.slice(consumed).replace(/^[\\s,.;:]+/u, \"\") };\n    }\n  }\n  const pm = lower.match(/^([a-z0-9][a-z0-9._-]*)'s(?![\\p{L}\\p{N}])/u);\n  if (pm && known.has(pm[1])) {\n    return { agent: pm[1], rest: content.slice(pm[0].length).replace(/^[\\s,.;:]+/u, \"\") };\n  }\n  return undefined;\n}\n\n/**\n * Force \"project\" scope on any fact whose content starts with a recognised\n * agent qualifier (a known connector name). A qualifier is evidence the fact is\n * agent-tied; which connector it names does not matter.\n */\nfunction forceProjectScopeOnAnyQualifier(result: ExtractionResult, known: ReadonlySet<string>): ExtractionResult {\n  let any = false;\n  const facts = result.facts.map((fact) => {\n    if (fact.scope === \"project\") return fact;\n    if (parseLeadingQualifier(fact.content, known) === undefined) return fact;\n    any = true;\n    return { ...fact, scope: \"project\" as const };\n  });\n  return any ? { ...result, facts } : result;\n}\n\nconst RESTORE_KEY = \"_qo\";\n\n/**\n * Strip the TRUSTED connector's qualifier for the grounding pass. Uses the same\n * parseLeadingQualifier as scope-forcing, but only strips when the matched agent\n * IS the trusted connector. Each stripped fact carries its original content\n * positionally for collision-free restore.\n */\nfunction prepareTrustedConnectorQualifier(\n  result: ExtractionResult,\n  trustedConnector: string,\n  known: ReadonlySet<string>,\n): { result: ExtractionResult } {\n  const trusted = trustedConnector.toLowerCase();\n  const facts = result.facts.map((fact) => {\n    const parsed = parseLeadingQualifier(fact.content, known);\n    if (parsed === undefined || parsed.agent !== trusted) return fact;\n    return { ...fact, content: parsed.rest, [RESTORE_KEY]: fact.content };\n  }) as ExtractionResult[\"facts\"];\n  return { result: { ...result, facts } };\n}\n\nfunction restoreTrustedConnectorQualifier(grounded: ExtractionResult): ExtractionResult {\n  let touched = false;\n  const facts = grounded.facts.map((fact) => {\n    const record = fact as unknown as Record<string, unknown>;\n    const original = record[RESTORE_KEY];\n    if (typeof original !== \"string\") return fact;\n    touched = true;\n    const rest = { ...record };\n    delete rest[RESTORE_KEY];\n    return { ...rest, content: original } as ExtractionResult[\"facts\"][number];\n  });\n  return touched ? { ...grounded, facts } : grounded;\n}\n"],"mappings":"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","names":[]}