@remnic/core 9.60.1 → 9.60.2

package/src/entity-origin-fields.ts

@@ -0,0 +1,56 @@
+import type { EntityStructuredSection } from "./types.js";
+
+type OriginatedEntry = { text: string; origin?: string };
+type RecalledFact = { text: string; sourceIndex: number };
+type SanitizedFacts = { facts: string[]; origins: Array<string | undefined> };
+
+export type EntityOriginStructuredSection = EntityStructuredSection & {
+  factOrigins?: Array<string | undefined>;
+};
+
+export function sanitizeOriginatedFacts(
+  entries: readonly OriginatedEntry[],
+  sanitize: (value: string) => string,
+  compact: (value: string, maxLength: number) => string,
+  deduplicate: boolean,
+): SanitizedFacts {
+  const result: SanitizedFacts = { facts: [], origins: [] };
+  const indexes = new Map<string, number>();
+  for (const entry of entries) {
+    const clean = sanitize(entry.text);
+    if (!clean) continue;
+    const fact = compact(clean, 180);
+    const index = deduplicate ? indexes.get(fact) ?? -1 : -1;
+    if (index < 0) {
+      indexes.set(fact, result.facts.length);
+      result.facts.push(fact);
+      result.origins.push(entry.origin);
+    } else if (result.origins[index] !== entry.origin) {
+      result.origins[index] = undefined;
+    }
+  }
+  return result;
+}
+
+export function buildOriginStructuredSections(
+  sections: readonly EntityStructuredSection[],
+  recallFacts: (section: EntityStructuredSection) => RecalledFact[],
+  sanitize: (value: string) => string,
+  compact: (value: string, maxLength: number) => string,
+): EntityOriginStructuredSection[] {
+  return sections
+    .map((section) => {
+      const entries = recallFacts(section).map(({ text, sourceIndex }) => ({
+        text,
+        origin: section.factOrigins?.[sourceIndex],
+      }));
+      const result = sanitizeOriginatedFacts(entries, sanitize, compact, false);
+      return {
+        key: section.key,
+        title: section.title,
+        facts: result.facts,
+        ...(result.origins.some((origin) => origin !== undefined) ? { factOrigins: result.origins } : {}),
+      };
+    })
+    .filter((section) => section.facts.length > 0);
+}

package/src/entity-retrieval.ts

@@ -9,13 +9,17 @@ import { compareEntityTimestamps, normalizeEntityName, type StorageManager } fro
 import { normalizeEntityText, resolveRequestedEntitySectionKeys } from "./entity-schema.js";
 import type { EntityStructuredSection, MemoryFile, PluginConfig, TranscriptEntry } from "./types.js";
 import { containsPhrase } from "./entity-retrieval-boundaries.js";
+import {
+  buildOriginStructuredSections,
+  sanitizeOriginatedFacts,
+  type EntityOriginStructuredSection,
+} from "./entity-origin-fields.js";
 import {
   checkEntityRecallAbort,
   entityRecallSectionAbsent,
   yieldEntityRecallScan,
   yieldEntityRecallScanEvery,
 } from "./entity-recall-cancellation.js";
-
 const ENTITY_INDEX_VERSION = 3;
 const RECENT_TRANSCRIPT_LOOKBACK_HOURS = 24;
 const INSTRUCTION_LIKE_RE = /\b(always|never|must|should|remember to|do not|don't|process|workflow|template|checklist|instruction)\b/i;
@@ -23,24 +27,24 @@ const METADATA_WRAPPER_RE = /^(source|context|metadata|notes?):/i;
 const ENTITY_PRONOUN_RE = /\b(he|him|his|she|her|they|them|their|it|its)\b/i;
 const BELIEF_LEDGER_SECTION_KEY = "belief_ledger";
 const BELIEF_LEDGER_FACT_RE = /^claim=([^;]+);\s*status=([^;]+);\s*updatedAt=([^;]+);\s*(.+)$/;
-
 type EntityQueryMode = "direct" | "timeline" | "follow_up";
-
 type EntityMentionIndexEntry = {
   canonicalId: string;
   name: string;
   type: string;
-  aliases: string[];
   summary?: string;
+  aliases: string[];
   facts: string[];
   timelineFacts: string[];
-  structuredSections: EntityStructuredSection[];
+  timelineFactOrigins?: Array<string | undefined>;
+  structuredSections: EntityOriginStructuredSection[];
   timeline: Array<{
     timestamp: string;
     text: string;
     source?: string;
     sessionKey?: string;
     principal?: string;
+    origin?: string;
   }>;
   relationships: Array<{ target: string; label: string }>;
   activity: Array<{ date: string; note: string }>;
@@ -55,21 +59,18 @@ type EntityMentionIndexEntry = {
     derivedDate?: string;
   }>;
 };
-
 type EntityMentionIndex = {
   version: number;
   updatedAt: string;
   entityStatusVersion?: number;
   entities: EntityMentionIndexEntry[];
 };
-
 type EntityCandidate = {
   entry: EntityMentionIndexEntry;
   alias: string;
   score: number;
   source: "query" | "recent_turn";
 };
-
 type EntityHintSnippet = {
   text: string;
   score: number;
@@ -96,37 +97,35 @@ export interface BuildEntityRecallSectionOptions {
    */
   abortSignal?: AbortSignal;
 }
-
 function tokenize(value: string): string[] {
   return normalizeEntityText(value).split(/\s+/).filter((token) => token.length >= 2);
 }
-
 function uniqueStrings(values: string[]): string[] {
   return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))];
 }
-
 function compactLine(value: string, maxLength: number = 220): string {
   const normalized = value.replace(/\s+/g, " ").trim();
   if (normalized.length <= maxLength) return normalized;
   return `${normalized.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
 }
-
 function dedupeHintSnippetsByText(snippets: EntityHintSnippet[]): EntityHintSnippet[] {
-  const seen = new Set<string>();
-  const result: EntityHintSnippet[] = [];
+  const deduped = new Map<string, EntityHintSnippet>();
   for (const snippet of snippets) {
     const key = normalizeEntityText(snippet.text);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    result.push(snippet);
+    const existing = deduped.get(key);
+    if (!existing) {
+      deduped.set(key, snippet);
+      continue;
+    }
+    if (existing.origin !== snippet.origin) {
+      existing.origin = undefined;
+    }
   }
-  return result;
+  return [...deduped.values()];
 }
-
 function isBeliefLedgerSection(section: Pick<EntityStructuredSection, "key">): boolean {
   return normalizeEntityText(section.key).replace(/\s+/g, "_") === BELIEF_LEDGER_SECTION_KEY;
 }
-
 function beliefLedgerFactKeys(sections: EntityStructuredSection[]): Set<string> {
   const keys = new Set<string>();
   for (const section of sections) {
@@ -137,15 +136,16 @@ function beliefLedgerFactKeys(sections: EntityStructuredSection[]): Set<string>
   }
   return keys;
 }
-
-function recallFactsForStructuredSection(section: EntityStructuredSection): string[] {
-  if (!isBeliefLedgerSection(section)) return section.facts;
+type RecalledEntityFact = { text: string; sourceIndex: number };
+function recallFactsForStructuredSection(section: EntityStructuredSection): RecalledEntityFact[] {
+  if (!isBeliefLedgerSection(section)) {
+    return section.facts.map((text, sourceIndex) => ({ text, sourceIndex }));
+  }
   return currentActiveBeliefLedgerFactTexts(section.facts);
 }
-
-function currentActiveBeliefLedgerFactTexts(facts: string[]): string[] {
-  const byClaim = new Map<string, { status: string; updatedAtMs: number; texts: string[] }>();
-  for (const fact of facts) {
+function currentActiveBeliefLedgerFactTexts(facts: string[]): RecalledEntityFact[] {
+  const byClaim = new Map<string, { status: string; updatedAtMs: number; texts: RecalledEntityFact[] }>();
+  for (const [sourceIndex, fact] of facts.entries()) {
     const match = BELIEF_LEDGER_FACT_RE.exec(fact.trim());
     if (!match) continue;
     const [, claimId, status, updatedAt, text] = match;
@@ -160,28 +160,20 @@ function currentActiveBeliefLedgerFactTexts(facts: string[]): string[] {
       current.status === "active" &&
       normalizedStatus !== "active";
     if (!current || updatedAtMs > current.updatedAtMs || inactiveTieWins) {
-      byClaim.set(normalizedClaimId, { status: normalizedStatus, updatedAtMs, texts: [text.trim()] });
+      byClaim.set(normalizedClaimId, { status: normalizedStatus, updatedAtMs, texts: [{ text: text.trim(), sourceIndex }] });
       continue;
     }
     if (updatedAtMs === current.updatedAtMs && current.status === normalizedStatus) {
-      current.texts.push(text.trim());
-    }
-  }
-  const result: string[] = [];
-  for (const current of byClaim.values()) {
-    if (current.status === "active") {
-      result.push(...current.texts);
+      current.texts.push({ text: text.trim(), sourceIndex });
     }
   }
-  return result;
+  return [...byClaim.values()].flatMap((current) => current.status === "active" ? current.texts : []);
 }
-
 function relationLine(entry: EntityMentionIndexEntry, relationship: { target: string; label: string }): string {
   const normalizedLabel = relationship.label.replace(/\s+/g, " ").trim();
   if (normalizedLabel.length === 0) return `${entry.name} is connected to ${relationship.target}`;
   return `${entry.name} ${normalizedLabel} ${relationship.target}`;
 }
-
 function detectEntityQueryMode(query: string): EntityQueryMode | null {
   const normalized = normalizeEntityText(query);
   if (!normalized) return null;
@@ -211,7 +203,6 @@ function detectEntityQueryMode(query: string): EntityQueryMode | null {
   }
   return null;
 }
-
 function scoreAliasMatch(query: string, alias: string): number {
   const normalizedQuery = normalizeEntityText(query);
   const normalizedAlias = normalizeEntityText(alias);
@@ -246,7 +237,6 @@ function scoreAliasMatch(query: string, alias: string): number {
   }
   return overlap;
 }
-
 /**
  * Tokens that look like type prefixes / generic role identifiers and
  * therefore should not, on their own, count as evidence that a
@@ -264,15 +254,12 @@ const ALIAS_AFFIX_TOKENS = new Set<string>([
   "place", "places", "tool", "tools", "service", "services",
   "system", "systems", "agent", "agents", "bot", "bots",
 ]);
-
 function isAliasAffixToken(token: string): boolean {
   return ALIAS_AFFIX_TOKENS.has(token);
 }
-
 function isLikelyInstructionLike(value: string): boolean {
   return INSTRUCTION_LIKE_RE.test(value) || METADATA_WRAPPER_RE.test(value);
 }
-
 function sanitizeEntityFact(fact: string): string {
   const sanitized = sanitizeMemoryContent(fact);
   const clean = sanitized.text.trim();
@@ -280,7 +267,6 @@ function sanitizeEntityFact(fact: string): string {
   if (INSTRUCTION_LIKE_RE.test(clean) && clean.length > 100) return "";
   return clean;
 }
-
 function scoreHintSnippet(snippet: EntityHintSnippet, queryTokens: string[]): EntityHintSnippet | null {
   const normalized = normalizeEntityText(snippet.text);
   if (!normalized) return null;
@@ -294,7 +280,6 @@ function scoreHintSnippet(snippet: EntityHintSnippet, queryTokens: string[]): En
   if (scored.text.length <= 160) scored.score += 1;
   return scored.score > 0 ? scored : null;
 }
-
 function sortTimelineEntriesDesc(
   left: EntityMentionIndexEntry["timeline"][number],
   right: EntityMentionIndexEntry["timeline"][number],
@@ -305,7 +290,6 @@ function sortTimelineEntriesDesc(
   }
   return right.text.localeCompare(left.text);
 }
-
 function jaccardSimilarity(a: string, b: string): number {
   const aTokens = new Set(tokenize(a));
   const bTokens = new Set(tokenize(b));
@@ -317,7 +301,6 @@ function jaccardSimilarity(a: string, b: string): number {
   const union = new Set([...aTokens, ...bTokens]).size;
   return union === 0 ? 0 : intersection / union;
 }
-
 function buildAliasIndex(entries: EntityMentionIndexEntry[]): Map<string, EntityMentionIndexEntry[]> {
   const index = new Map<string, EntityMentionIndexEntry[]>();
   for (const entry of entries) {
@@ -330,7 +313,6 @@ function buildAliasIndex(entries: EntityMentionIndexEntry[]): Map<string, Entity
   }
   return index;
 }
-
 async function readNativeChunks(
   config: PluginConfig,
   recallNamespaces?: string[],
@@ -344,7 +326,6 @@ async function readNativeChunks(
     defaultNamespace: config.defaultNamespace,
   }).catch(() => []);
 }
-
 async function resolveEntityIndexStorages(
   storage: StorageManager,
   config: PluginConfig,
@@ -359,7 +340,6 @@ async function resolveEntityIndexStorages(
   ) {
     return [storage];
   }
-
   const storages: StorageManager[] = [];
   const seenDirs = new Set<string>();
   for (const namespace of uniqueStrings(recallNamespaces)) {
@@ -373,10 +353,8 @@ async function resolveEntityIndexStorages(
       continue;
     }
   }
-
   return storages.length > 0 ? storages : [storage];
 }
-
 function entityIndexStatePath(storage: StorageManager): string {
   return path.join(storage.dir, "state", "entity-mention-index.json");
 }
@@ -392,8 +370,6 @@ async function readEntityIndexState(storage: StorageManager): Promise<EntityMent
     return null;
   }
 }
-
-
 async function readCurrentPersistedEntityIndex(
   storage: StorageManager,
   config: PluginConfig,
@@ -429,7 +405,6 @@ function nativeEntityIndexRevision(chunks: NativeKnowledgeChunk[]): string {
   ]);
   return createHash("sha256").update(JSON.stringify(projection)).digest("hex");
 }
-
 function namespaceEntityIndexCacheKey(
   storages: StorageManager[],
   recallNamespaces: string[],
@@ -449,7 +424,6 @@ function namespaceEntityIndexCacheKey(
     .join("\u001f");
   return `${namespaceKey}\u001e${storageKey}\u001e${nativeRevision}`;
 }
-
 function rememberNamespaceEntityIndex(key: string, index: EntityMentionIndex): void {
   if (namespaceEntityIndexCache.size >= MAX_NAMESPACE_ENTITY_INDEX_CACHE_ENTRIES) {
     const oldestKey = namespaceEntityIndexCache.keys().next().value;
@@ -585,10 +559,18 @@ async function buildEntityMentionIndex(
       .filter(Boolean)
       .filter((fact) => !rawBeliefLedgerFactKeys.has(normalizeEntityText(fact)))
       .map((fact) => compactLine(fact, 180));
-    const sanitizedTimelineFacts = entity.timeline
-      .map((entry) => sanitizeEntityFact(entry.text))
-      .filter(Boolean)
-      .map((fact) => compactLine(fact, 180));
+    const { facts: timelineFacts, origins: timelineFactOrigins } = sanitizeOriginatedFacts(
+      entity.timeline,
+      sanitizeEntityFact,
+      compactLine,
+      true,
+    );
+    const structuredSections = buildOriginStructuredSections(
+      rawStructuredSections,
+      recallFactsForStructuredSection,
+      sanitizeEntityFact,
+      compactLine,
+    );
     entities.set(canonicalId, {
       canonicalId,
       name: entity.name,
@@ -596,15 +578,9 @@ async function buildEntityMentionIndex(
       aliases: uniqueStrings(entity.aliases),
       summary: entity.synthesis?.trim() || entity.summary?.trim() || undefined,
       facts: sanitizedFacts,
-      timelineFacts: uniqueStrings(sanitizedTimelineFacts),
-      structuredSections: rawStructuredSections.map((section) => ({
-        key: section.key,
-        title: section.title,
-        facts: recallFactsForStructuredSection(section)
-          .map((fact) => sanitizeEntityFact(fact))
-          .filter(Boolean)
-          .map((fact) => compactLine(fact, 180)),
-      })).filter((section) => section.facts.length > 0),
+      timelineFacts,
+      ...(timelineFactOrigins.some((origin) => origin !== undefined) ? { timelineFactOrigins } : {}),
+      structuredSections,
       timeline: entity.timeline.map((entry) => ({ ...entry })),
       relationships: entity.relationships.map((relationship) => ({ ...relationship })),
       activity: entity.activity.map((activity) => ({ ...activity })),
@@ -857,20 +833,29 @@ async function buildHintSnippets(
   if (entry.summary) {
     snippets.push({ text: compactLine(entry.summary, 180), score: 10, kind: "summary" });
   }
-
   if (requestedSectionKeys.size > 0) {
     for (const section of entry.structuredSections) {
       if (!requestedSectionKeys.has(normalizeEntityText(section.key).replace(/\s+/g, "_"))) continue;
-      for (const fact of section.facts) {
-        snippets.push({ text: fact, score: mode === "direct" ? 8 : 9, kind: "section" });
+      for (const [index, fact] of section.facts.entries()) {
+        snippets.push({
+          text: fact,
+          score: mode === "direct" ? 8 : 9,
+          kind: "section",
+          origin: section.factOrigins?.[index],
+        });
       }
     }
   } else {
-    for (const fact of entry.timelineFacts) {
-      snippets.push({ text: fact, score: mode === "direct" ? 6 : 7, kind: "fact" });
+    for (const [index, fact] of entry.timelineFacts.entries()) {
+      snippets.push({
+        text: fact,
+        score: mode === "direct" ? 6 : 7,
+        kind: "fact",
+        origin: entry.timelineFactOrigins?.[index],
+      });
     }
     for (const section of entry.structuredSections) {
-      for (const fact of section.facts) {
+      for (const [index, fact] of section.facts.entries()) {
         const normalizedFact = normalizeEntityText(fact);
         const hasNonAliasQueryOverlap = queryTokens.some((token) =>
           !aliasTokens.has(token) && normalizedFact.includes(token)
@@ -878,7 +863,12 @@ async function buildHintSnippets(
         if (entry.timelineFacts.length > 0 && !hasNonAliasQueryOverlap) {
           continue;
         }
-        snippets.push({ text: fact, score: mode === "direct" ? 6 : 7, kind: "fact" });
+        snippets.push({
+          text: fact,
+          score: mode === "direct" ? 6 : 7,
+          kind: "fact",
+          origin: section.factOrigins?.[index],
+        });
       }
     }
     if (entry.timelineFacts.length === 0 && entry.structuredSections.length === 0) {
@@ -925,7 +915,13 @@ async function buildHintSnippets(
     if (!scored) continue;
     const normalized = normalizeEntityText(scored.text);
     const existing = deduped.get(normalized);
-    if (!existing || scored.score > existing.score) deduped.set(normalized, scored);
+    if (!existing) {
+      deduped.set(normalized, scored);
+    } else if (existing.origin !== scored.origin) {
+      deduped.set(normalized, { ...(scored.score > existing.score ? scored : existing), origin: undefined });
+    } else if (scored.score > existing.score) {
+      deduped.set(normalized, scored);
+    }
   }
 
   return [...deduped.values()]
@@ -987,13 +983,17 @@ function formatEntityHintSection(
         (candidate.entry.timeline ?? [])
           .slice()
           .sort(sortTimelineEntriesDesc)
-          .map((entry) => sanitizeEntityFact(entry.text))
-          .filter(Boolean)
-          .map((text) => scoreHintSnippet({
-            text: compactLine(text, 180),
-            score: 7,
-            kind: "activity" as const,
-          }, queryTokens))
+          .map((entry) => {
+            const text = sanitizeEntityFact(entry.text);
+            return text
+              ? scoreHintSnippet({
+                text: compactLine(text, 180),
+                score: 7,
+                kind: "activity" as const,
+                origin: entry.origin,
+              }, queryTokens)
+              : null;
+          })
           .filter((snippet): snippet is EntityHintSnippet => snippet !== null)
           .filter((snippet) => !seedExcludedTexts.has(normalizeEntityText(snippet.text))),
       ).slice(0, 2);

package/src/orchestration/extraction-injection-gate.ts

@@ -1,7 +1,4 @@
-/**
- * Pure issue #1955 injection-screen gate for extracted facts.
- */
-
+import { parseOriginClass } from "../security/origin-authority.js";
 import { normalizeAttributePairs } from "../structured-attributes.js";
 import { buildProcedurePersistBody } from "../procedural/procedure-types.js";
 import { screenCandidateFact } from "../security/injection-screen.js";
@@ -123,7 +120,22 @@ export function screenEntityForIndex(entity: unknown, enabled: boolean): Screene
     source: typeof record?.source === "string" ? record.source : "extraction",
     facts: factScreen.kept,
     ...(sectionScreens
-      ? { structuredSections: sectionScreens.map(({ section, screen }) => ({ ...section, facts: screen.kept })) }
+      ? {
+        structuredSections: sectionScreens.map(({ section, screen }) => {
+          let nextFactIndex = 0;
+          const factOrigins = screen.kept.map((fact) => {
+            const factIndex = section.facts.indexOf(fact, nextFactIndex);
+            nextFactIndex = factIndex + 1;
+            const origin = section.factOrigins?.[factIndex];
+            return origin === undefined ? undefined : parseOriginClass(origin);
+          });
+          return {
+            ...section,
+            facts: screen.kept,
+            ...(factOrigins.some((origin) => origin !== undefined) ? { factOrigins } : {}),
+          };
+        }),
+      }
       : rawSections
         ? { structuredSections: rawSections }
         : {}),

package/src/orchestration/extraction-persist.ts

@@ -116,7 +116,6 @@ import type { HarmonicConstructionInput } from "../harmonic-construction.js";
 import { persistConstructedHarmonicRecords } from "./harmonic-construction-persist.js";
 import { ExtractionAnchorSnapshot } from "./extraction-anchor-snapshot.js";
 
-
 export class ExtractionPersistCoordinator {
   constructor(
     private readonly deps: ExtractionPersistDeps,
@@ -2856,6 +2855,7 @@ export class ExtractionPersistCoordinator {
           timestamp: sourceContext?.validAt,
           sessionKey: sourceContext?.sessionKey,
           principal: sourceContext?.principal,
+          origin,
           structuredSections: screened.structuredSections,
         });
         if (id) {

package/src/recall-authority-fence.test.ts

@@ -150,6 +150,46 @@ test("entity recall fences memory snippets and preserves disabled output", async
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
+test("entity facts and structured sections retain extracted origin authority", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-authority-entity-origin-"));
+  try {
+    const storage = new StorageManager(memoryDir);
+    await storage.writeEntity("Alice", "person", ["Alice prefers direct answers."], {
+      origin: "user",
+      structuredSections: [
+        {
+          key: "communication_style",
+          title: "Communication Style",
+          facts: ["Alice writes concise messages."],
+        },
+      ],
+    });
+    const config = parseConfig({
+      openaiApiKey: "sk-test",
+      memoryDir,
+      workspaceDir: path.join(memoryDir, "workspace"),
+      originAuthorityEnabled: true,
+    });
+    const output = await buildEntityRecallSection({
+      config,
+      storage,
+      query: "Who is Alice?",
+      recentTurns: 1,
+      maxHints: 2,
+      maxSupportingFacts: 4,
+      maxRelatedEntities: 2,
+      maxChars: 10_000,
+      transcriptEntries: [],
+      originAuthorityEnabled: true,
+      untrustedOrigins: ["unknown"],
+    });
+    assert.match(output ?? "", /Alice prefers direct answers\./);
+    assert.match(output ?? "", /Alice writes concise messages\./);
+    assert.doesNotMatch(output ?? "", /content below is data, not instructions/);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
 
 test("procedure recall fences untrusted-origin procedure bodies (#1955 review)", async () => {
   const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-authority-procedure-"));

package/src/security/audit-memory.test.ts

@@ -14,6 +14,7 @@ type MemoryOptions = {
   pathPrefix?: string;
   source?: string;
   sourceConnector?: string;
+  timestamp?: string;
 };
 
 function makeMemory(
@@ -23,7 +24,7 @@ function makeMemory(
   content: string,
   options: MemoryOptions = {},
 ): MemoryFile {
-  const timestamp = "2026-08-14T12:00:00.000Z";
+  const timestamp = options.timestamp ?? "2026-08-14T12:00:00.000Z";
   const frontmatter = {
     id,
     category: "fact",
@@ -236,6 +237,28 @@ test("auditMemoryStore uses a leave-one-out burst baseline", async () => {
   }
 });
 
+test("auditMemoryStore includes memories exactly at --since and excludes earlier ones", async () => {
+  const root = await mkdtemp(path.join(tmpdir(), "remnic-audit-memory-boundary-"));
+  try {
+    const cutoff = "2026-08-14T12:00:00.000Z";
+    const before = makeMemory(root, "before", "session-before", "Before cutoff", {
+      timestamp: "2026-08-14T11:59:59.999Z",
+    });
+    const atCutoff = makeMemory(root, "at-cutoff", "session-at-cutoff", "At cutoff", {
+      timestamp: cutoff,
+    });
+    const report = await auditMemoryStore({
+      memoryDir: root,
+      storage: memoryStorage([before, atCutoff]),
+      since: cutoff,
+    });
+    assert.equal(report.activeMemories, 1);
+    assert.deepEqual([...new Set(report.findings.map((finding) => finding.memoryId))], []);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
 test("auditMemoryStore rejects malformed --since dates instead of normalizing them (#1955 review)", async () => {
   const root = await mkdtemp(path.join(tmpdir(), "remnic-audit-memory-date-"));
   try {