@remnic/core 9.6.0 → 9.6.2

package/src/orchestration/persistence-index.ts

@@ -133,6 +133,7 @@ export class PersistenceIndexCoordinator {
       eventTimeSource?: "extracted" | "assumed";
     },
     entityRef?: string,
+    sourceConnector?: string,
   ): Promise<void> {
     // I/O gate: scan when there is a recall-relevant bound to backfill —
     // either an end bound (invalidAt, which expires the fact) or a corrected
@@ -173,6 +174,19 @@ export class PersistenceIndexCoordinator {
         ) {
           return false;
         }
+        // Connector identity guard (review f1b89fe9, cursor #1852): exact
+        // match on connector identity, including undefined. In the shared
+        // namespace, multiple connectors can carry identical-content facts;
+        // without this filter .find() selects the first hash/entity match.
+        // Operator/no-connector backfill (sourceConnector undefined) may only
+        // select a connectorless candidate, never a connector-tagged one;
+        // connector-authenticated backfill only selects the same connector.
+        const incomingConnector = sourceConnector?.trim() || undefined;
+        const candidateConnector =
+          m.frontmatter.sourceConnector?.trim() || undefined;
+        if (incomingConnector !== candidateConnector) {
+          return false;
+        }
         // Prefer the stored contentHash (what the hash index actually keys
         // on) — it is computed from contentHashSource (the raw/enriched
         // body before citation), matching the dedupContent the caller passes.
@@ -488,10 +502,31 @@ export class PersistenceIndexCoordinator {
     const scope = this.deps.semanticDedupScopeFor(targetStorage);
     const hits = await this.deps.embeddingFallback.search(content, limit, { ...scope, throwOnTimeout: true });
     if (!Array.isArray(hits) || hits.length === 0) return [];
-    return hits.map((hit) => ({
-      id: hit.id,
-      score: hit.score,
-      path: hit.path,
-    }));
+    // PR #1852 review finding on 7e0eb1a0: attach each neighbor's
+    // sourceConnector so decideSemanticDedup can apply the connector-aware
+    // skip gate. Reads are bounded by `limit` (default 5) and best-effort:
+    // a read failure leaves the connector absent, which the decision
+    // function treats as "must not suppress a provenance-bearing write".
+    const enriched: SemanticDedupHit[] = await Promise.all(
+      hits.map(async (hit) => {
+        let sourceConnector: string | undefined;
+        try {
+          const memory = await targetStorage.getMemoryById(hit.id);
+          sourceConnector =
+            typeof memory?.frontmatter.sourceConnector === "string"
+              ? memory.frontmatter.sourceConnector.trim() || undefined
+              : undefined;
+        } catch {
+          sourceConnector = undefined;
+        }
+        return {
+          id: hit.id,
+          score: hit.score,
+          path: hit.path,
+          ...(sourceConnector !== undefined ? { sourceConnector } : {}),
+        };
+      }),
+    );
+    return enriched;
   }
 }

package/src/orchestration/turn-ingestion.ts

@@ -34,7 +34,7 @@ import { type ReplayTurn, normalizeReplaySessionKey } from "../replay/types.js";
 import { SessionObserverState } from "../session-observer-state.js";
 import { CODEX_THREAD_KEY_PREFIX } from "../thread-key.js";
 import { TranscriptManager } from "../transcript.js";
-import type { BufferTurn, PluginConfig } from "../types.js";
+import type { BufferTurn, PluginConfig, SourceConnectorProvenance } from "../types.js";
 import {
   BulkImportBatchPartialFailureError,
   splitTurnsBySourceValidAt,
@@ -102,6 +102,17 @@ export interface TurnIngestionDeps {
   readonly transcript: TranscriptManager;
 }
 
+/**
+ * Options for {@link TurnIngestionCoordinator.processTurn}.
+ * Extends {@link SourceConnectorProvenance} to thread trusted connector identity.
+ */
+export interface TurnIngestionOptions extends SourceConnectorProvenance {
+  bufferKey?: string;
+  logicalSessionKey?: string;
+  providerThreadId?: string | null;
+  turnFingerprint?: string;
+}
+
 export class TurnIngestionCoordinator {
   constructor(
     private readonly deps: TurnIngestionDeps,
@@ -111,13 +122,7 @@ export class TurnIngestionCoordinator {
     role: "user" | "assistant",
     content: string,
     sessionKey?: string,
-    options: {
-      bufferKey?: string;
-      logicalSessionKey?: string;
-      providerThreadId?: string | null;
-      turnFingerprint?: string;
-      persistProcessedFingerprint?: boolean;
-    } = {},
+    options: TurnIngestionOptions = {},
   ): Promise<void> {
     if (role !== "user" && role !== "assistant") {
       log.debug(`processTurn: ignoring unsupported role=${String(role)}`);
@@ -158,7 +163,7 @@ export class TurnIngestionCoordinator {
       logicalSessionKey: options.logicalSessionKey ?? bufferKey,
       providerThreadId: options.providerThreadId ?? null,
       turnFingerprint: options.turnFingerprint,
-      persistProcessedFingerprint: options.persistProcessedFingerprint === true,
+      ...(options.sourceConnector ? { sourceConnector: options.sourceConnector } : {}),
     };
 
     const outcome =
@@ -231,6 +236,7 @@ export class TurnIngestionCoordinator {
         parts: turn.parts,
         rawContent: turn.rawContent,
         sourceFormat: turn.sourceFormat,
+        sourceConnector: turn.sourceConnector,
       });
       bySession.set(key, list);
     }
@@ -416,6 +422,7 @@ export class TurnIngestionCoordinator {
         importProvenance: turn.importProvenance,
         turnFingerprint: turn.turnFingerprint,
         persistProcessedFingerprint: turn.persistProcessedFingerprint === true,
+        ...(turn.sourceConnector ? { sourceConnector: turn.sourceConnector } : {}),
       });
     }
     if (sessionTurns.length === 0) {