@remnic/core 9.3.694 → 9.3.695

package/src/faithfulness-graph-guard.test.ts

@@ -0,0 +1,252 @@
+/**
+ * Issue #1576 — pending-review facts must NOT originate graph edges.
+ *
+ * When `extractionFaithfulnessGate="enforce"` routes an unsupported or
+ * contradicted fact to `pending_review`, the persist path still builds entity
+ * edges via `GraphIndex.onMemoryWritten`, so an unfaithful extraction in the
+ * review queue could change graph traversal/ranking for active memories even
+ * though direct recall filters later drop the pending file. The guard mirrors
+ * the existing supersession/promotion/artifact guards (codex P2
+ * PRRT_kwDORJXyws6OblI1's sibling thread PRRT_kwDORJXyws6OblI0).
+ *
+ * These tests exercise the real `persistExtraction` path end-to-end (no LLM
+ * network — the local LLM is stubbed to return controlled verdicts) and read
+ * the entity graph JSONL directly to prove the guard.
+ */
+
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, rm } from "node:fs/promises";
+import test from "node:test";
+
+import { parseConfig } from "./config.js";
+import { Orchestrator } from "./orchestrator.js";
+import { readEdges } from "./graph.js";
+import type { ExtractionResult, PluginConfig } from "./types.js";
+import type { LocalLlmClient } from "./local-llm.js";
+
+/**
+ * Stub local LLM whose `chatCompletion` only answers faithfulness-gate calls
+ * (operation === "extraction-faithfulness"). The verdict is chosen by a marker
+ * in the fact text so each persisted fact gets a deterministic, controllable
+ * verdict with no network. Non-faithfulness calls return null (fail-open skip).
+ */
+function faithfulnessStubLocalLlm(
+  verdictForFactContent: (factContent: string) => "entailed" | "unsupported",
+): LocalLlmClient {
+  return {
+    chatCompletion: async (
+      messages: Array<{ role: string; content: string }>,
+      options: { operation?: string } = {},
+    ) => {
+      if (options.operation !== "extraction-faithfulness") return null;
+      const userMsg = messages.find((m) => m.role === "user");
+      // The prompt emits `FACT: "<text>"` — fact text never contains a raw
+      // double-quote, so capture up to the closing quote.
+      const match = userMsg?.content.match(/FACT: "([^"]*)"/);
+      const factContent = match ? (match[1] ?? "") : "";
+      const verdict = verdictForFactContent(factContent);
+      return {
+        content: JSON.stringify([
+          { index: 0, verdict, rationale: "stub verdict" },
+        ]),
+      };
+    },
+  } as unknown as LocalLlmClient;
+}
+
+interface OrchHarness {
+  orchestrator: Orchestrator;
+  memoryDir: string;
+}
+
+async function makeHarness(): Promise<OrchHarness> {
+  const memoryDir = await mkdtemp(
+    path.join(os.tmpdir(), "remnic-faithfulness-graph-"),
+  );
+  const config: PluginConfig = parseConfig({
+    openaiApiKey: "sk-test",
+    memoryDir,
+    workspaceDir: path.join(memoryDir, "workspace"),
+    // Graph: entity only (isolate the assertion; time/causal off).
+    multiGraphMemoryEnabled: true,
+    entityGraphEnabled: true,
+    timeGraphEnabled: false,
+    causalGraphEnabled: false,
+    // Faithfulness gate in enforce mode.
+    extractionFaithfulnessGate: "enforce",
+    extractionFaithfulnessContextChars: 400,
+    extractionFaithfulnessTimeoutMs: 2000,
+    // Minimize competing gates so the fact reaches the write + graph stage.
+    extractionJudgeEnabled: false,
+    temporalSupersessionEnabled: false,
+    contradictionDetectionEnabled: false,
+    chunkingEnabled: false,
+    embeddingFallbackEnabled: false,
+    qmdEnabled: false,
+    extractionMinChars: 0,
+    extractionMinImportanceLevel: "trivial",
+    inlineSourceAttributionEnabled: false,
+  });
+  const orchestrator = new Orchestrator(config);
+  return { orchestrator, memoryDir };
+}
+
+function factResult(content: string, entityRef: string): ExtractionResult {
+  return {
+    facts: [
+      {
+        content,
+        category: "fact",
+        tags: [],
+        confidence: 0.9,
+        entityRef,
+      },
+    ],
+    entities: [],
+    relationships: [],
+    questions: [],
+    profileUpdates: [],
+  } as unknown as ExtractionResult;
+}
+
+test("pending_review fact gets no graph edge; an active fact with the same entityRef does (faithfulness #1576 guard)", async () => {
+  const { orchestrator, memoryDir } = await makeHarness();
+  try {
+    // fact0 → entailed (active). Establishes entityRef "widget-factory" so the
+    // next E1 fact has a sibling to edge to. Alone, fact0 has no sibling yet.
+    (orchestrator as unknown as { localLlm: LocalLlmClient }).localLlm =
+      faithfulnessStubLocalLlm((c) =>
+        c.includes("closed permanently") ? "unsupported" : "entailed",
+      );
+    const storage = await (orchestrator as unknown as {
+      getStorage: (ns: string) => Promise<{
+        ensureDirectories: () => Promise<void>;
+        readAllMemories: () => Promise<
+          Array<{
+            path: string;
+            frontmatter: { id: string; status?: string };
+          }>
+        >;
+      }>;
+    }).getStorage("default");
+    await storage.ensureDirectories();
+
+    const sourceText =
+      "The widget factory produces widgets. It launched last year. The team is small.";
+
+    const ids0 = await (orchestrator as unknown as {
+      persistExtraction: (
+        r: ExtractionResult,
+        s: unknown,
+        t: unknown,
+        ctx: unknown,
+        bn: unknown,
+        plan: unknown,
+        src: string,
+      ) => Promise<string[]>;
+    }).persistExtraction(
+      factResult("The widget factory produces widgets daily.", "widget-factory"),
+      storage,
+      null,
+      { sessionKey: "agent:test:main", principal: "test" },
+      undefined,
+      null,
+      sourceText,
+    );
+    const id0 = ids0[0];
+    assert.ok(id0, "fact0 persisted");
+
+    // fact1 → unsupported (pending_review). Under the bug it would originate an
+    // entity edge to fact0; under the guard it must NOT.
+    const ids1 = await (orchestrator as unknown as {
+      persistExtraction: (
+        r: ExtractionResult,
+        s: unknown,
+        t: unknown,
+        ctx: unknown,
+        bn: unknown,
+        plan: unknown,
+        src: string,
+      ) => Promise<string[]>;
+    }).persistExtraction(
+      factResult(
+        "The widget factory closed permanently.",
+        "widget-factory",
+      ),
+      storage,
+      null,
+      { sessionKey: "agent:test:main", principal: "test" },
+      undefined,
+      null,
+      sourceText,
+    );
+    const id1 = ids1[0];
+    assert.ok(id1, "fact1 persisted");
+
+    // fact1 must be written with status pending_review (the gate ran).
+    const memsAfter1 = await storage.readAllMemories();
+    const mem1 = memsAfter1.find((m) => m.frontmatter.id === id1);
+    assert.ok(mem1, "fact1 memory readable");
+    assert.equal(
+      mem1!.frontmatter.status,
+      "pending_review",
+      "unsupported fact must be pending_review under enforce",
+    );
+
+    // After fact0 + fact1: NO entity edges at all. fact0 had no E1 sibling when
+    // written; fact1 is pending_review and must be guarded out of the graph.
+    const edgesAfter1 = await readEdges(memoryDir, "entity");
+    assert.equal(
+      edgesAfter1.length,
+      0,
+      `pending_review fact must originate no graph edge (got ${edgesAfter1.length} entity edges)`,
+    );
+    assert.ok(
+      !edgesAfter1.some((e) => e.from.includes(id1!) || e.from.includes(id0!)),
+      "neither fact0 nor fact1 originates an entity edge",
+    );
+
+    // Control: an ACTIVE fact with the same entityRef DOES create entity edges
+    // (proving the graph is wired and only pending_review is excluded).
+    const ids2 = await (orchestrator as unknown as {
+      persistExtraction: (
+        r: ExtractionResult,
+        s: unknown,
+        t: unknown,
+        ctx: unknown,
+        bn: unknown,
+        plan: unknown,
+        src: string,
+      ) => Promise<string[]>;
+    }).persistExtraction(
+      factResult("The widget factory reopened this quarter.", "widget-factory"),
+      storage,
+      null,
+      { sessionKey: "agent:test:main", principal: "test" },
+      undefined,
+      null,
+      sourceText,
+    );
+    const id2 = ids2[0];
+    assert.ok(id2, "fact2 persisted");
+
+    const edgesAfter2 = await readEdges(memoryDir, "entity");
+    assert.ok(
+      edgesAfter2.length > 0,
+      "active fact with a shared entityRef must create entity edges (control)",
+    );
+    // fact2 (active) originates edges; fact1 (pending_review) never does.
+    assert.ok(
+      edgesAfter2.some((e) => e.from.includes(id2!)),
+      "active fact2 must be the source of an entity edge",
+    );
+    assert.ok(
+      !edgesAfter2.some((e) => e.from.includes(id1!)),
+      "pending_review fact1 must never originate an entity edge even after a later active fact",
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/local-llm.ts

@@ -131,6 +131,7 @@ const THINKING_COMPATIBLE_BACKENDS: ReadonlySet<LocalLlmType> = new Set([
 const THINKING_SUPPRESSED_OPERATIONS: ReadonlySet<string> = new Set([
   "extraction",
   "extraction-judge",
+  "extraction-faithfulness",
   "contradiction-judge",
   "contradiction_verification",
   "link_suggestion",

package/src/orchestrator.ts

@@ -35,6 +35,12 @@ import {
   type JudgeCandidate,
   type JudgeVerdict,
 } from "./extraction-judge.js";
+import {
+  applyFaithfulnessVerdict,
+  createFaithfulnessCounters,
+  runFaithfulnessGateBatch,
+} from "./extraction-faithfulness.js";
+import type { FaithfulnessGateCounters } from "./extraction-faithfulness.js";
 import {
   EXTRACTION_JUDGE_VERDICT_CATEGORY,
   recordJudgeVerdict,
@@ -1828,6 +1834,12 @@ export class Orchestrator {
    * hash so the defer cap can be enforced.
    */
   private readonly judgeDeferCounts: Map<string, number>;
+  /**
+   * Faithfulness gate distribution counters (issue #1576). Per-orchestrator
+   * running tally surfaced via console_state telemetry. No module-level state
+   * (rule 11) — these hang off the orchestrator instance.
+   */
+  private faithfulnessCounters: FaithfulnessGateCounters = createFaithfulnessCounters();
   /**
    * Side-channel: number of facts deferred in the most recent
    * `persistExtraction` call (issue #562, PR 2). The caller reads this after
@@ -1841,6 +1853,20 @@ export class Orchestrator {
   get fastGatewayLlm(): FallbackLlmClient | null {
     return this._fastGatewayLlm;
   }
+
+  /**
+   * Faithfulness gate verdict distribution (issue #1576). Consumed by the
+   * console-state aggregator so `remnic doctor` can render how the gate is
+   * performing. Returns a fresh object so callers cannot mutate the
+   * internal counters. Returns `undefined` when the gate is off so the
+   * console-state snapshot omits the faithfulness block entirely (cursor
+   * review: an all-zero block would otherwise always be truthy and leak
+   * into snapshots that document it as absent-when-off).
+   */
+  getConsoleFaithfulnessDistribution(): FaithfulnessGateCounters | undefined {
+    if (this.config.extractionFaithfulnessGate === "off") return undefined;
+    return { ...this.faithfulnessCounters };
+  }
   readonly modelRegistry: ModelRegistry;
   readonly relevance: RelevanceStore;
   readonly negatives: NegativeExampleStore;
@@ -13247,6 +13273,9 @@ export class Orchestrator {
       // real namespace rather than a guess decoded from the storage dir.
       selfNamespace,
       scopeProfileGatePlan,
+      // Verbatim source turns for the faithfulness gate (#1576) so it can
+      // locate a quote per fact when #1575 spans are absent.
+      normalizedTurns.map((t) => t.content).join("\n\n"),
     );
     let postPersistMetadataFailed = false;
     meta ??= await storage.loadMeta();
@@ -13693,6 +13722,8 @@ export class Orchestrator {
     sourceContext?: { sessionKey?: string; principal?: string; validAt?: string },
     baseNamespace?: string,
     scopeProfileWritePlan?: ResolvedScopeProfilePlan | null,
+    /** Verbatim source turn text the facts were extracted from (faithfulness gate #1576). */
+    sourceText?: string,
     graphCaps: GraphConstructionCapabilitySet = resolveGraphConstructionCapabilities(this.config),
   ): Promise<string[]> {
     // Inline source attribution (issue #369). When enabled, every extracted
@@ -14577,6 +14608,29 @@ export class Orchestrator {
       }
     }
 
+    // Faithfulness gate (issue #1576). Entailment-verification of extracted
+    // facts against their verified source spans from #1575. Placement: after
+    // parse + provenance validation, BEFORE persist/index (rule 44). The
+    // substantive batch logic lives in the pure module; this is thin
+    // delegation (ground rule 4). off → null map (byte-identical pre-feature
+    // pipeline, rule 39); shadow → record only; enforce → pending_review.
+    const faithfulnessMode = this.config.extractionFaithfulnessGate;
+    const faithfulnessResultsByFactIndex =
+      faithfulnessMode === "shadow" || faithfulnessMode === "enforce"
+        ? await runFaithfulnessGateBatch(
+            facts,
+            faithfulnessMode,
+            this.config,
+            this.localLlm,
+            new FallbackLlmClient(
+              this.config.gatewayConfig,
+              fallbackLlmRuntimeContextFromConfig(this.config),
+            ),
+            this.faithfulnessCounters,
+            sourceText,
+          )
+        : null;
+
     let factLoopIndex = -1;
     for (const fact of facts) {
       factLoopIndex++;
@@ -14813,6 +14867,19 @@ export class Orchestrator {
         }
       }
 
+      // Faithfulness gate verdict application (issue #1576). Look up the
+      // pre-computed verdict for this fact and translate it to frontmatter +
+      // an optional enforce-mode pending_review status. Logic lives in the
+      // pure module; this is thin read-through (ground rule 4).
+      const { faithfulness: faithfulnessFm, enforceStatus: faithfulnessEnforceStatus } =
+        applyFaithfulnessVerdict(
+          faithfulnessResultsByFactIndex,
+          factLoopIndex,
+          faithfulnessMode,
+          fact.content,
+          this.faithfulnessCounters,
+        );
+
       // Issue #373 — write-time semantic similarity guard. Hook runs after
       // the exact content-hash miss and the importance gate so that:
       //   (a) paraphrased near-duplicates never reach writeMemory(), and
@@ -14903,7 +14970,14 @@ export class Orchestrator {
       // memory without user confirmation).
       let contradictionDetected = false;
 
-      if (this.config.contradictionDetectionEnabled && this.qmd.isAvailable()) {
+      // Faithfulness gate (#1576, chatgpt P2): skip contradiction detection
+      // for a pending_review fact — an unfaithful extraction in the review queue
+      // must not trigger auto-resolve and retire an existing active memory.
+      if (
+        this.config.contradictionDetectionEnabled &&
+        this.qmd.isAvailable() &&
+        faithfulnessEnforceStatus !== "pending_review"
+      ) {
         const targetNamespace = this.namespaceFromStorageDir(targetStorage.dir);
         const contradiction = await this.checkForContradiction(
           fact.content,
@@ -14968,7 +15042,16 @@ export class Orchestrator {
       // dropped, leaving a stale fact active. writeCategory (not fact.category)
       // is used because routing rules may have overridden the raw category.
       const isCorrection = writeCategory === "correction";
-      if (pendingSemanticSkip && !contradictionDetected && !isCorrection) {
+      // Faithfulness gate (#1576, cursor High): a pending_review fact must
+      // bypass the semantic-dedup skip so it reaches the review queue — the
+      // gate's contract is "persists with status: pending_review, never
+      // silently dropped" (issue #1576).
+      if (
+        pendingSemanticSkip &&
+        !contradictionDetected &&
+        !isCorrection &&
+        faithfulnessEnforceStatus !== "pending_review"
+      ) {
         log.debug(
           `dedup: skipping semantic near-duplicate fact "${fact.content
             .slice(0, 60)
@@ -15067,6 +15150,9 @@ export class Orchestrator {
               structuredAttributes: fact.structuredAttributes,
               validAt: sourceContext?.validAt,
               contentHashSource: rawChunkedContent,
+              // Faithfulness gate (issue #1576).
+              ...(faithfulnessFm ? { faithfulness: faithfulnessFm } : {}),
+              ...(faithfulnessEnforceStatus ? { status: faithfulnessEnforceStatus } : {}),
             },
           );
           try {
@@ -15102,6 +15188,11 @@ export class Orchestrator {
                   intentEntityTypes: inferredIntent?.entityTypes,
                   memoryKind,
                   validAt: sourceContext?.validAt,
+                  // Faithfulness gate (issue #1576): propagate the parent
+                  // fact's verdict + enforce status so a pending_review fact
+                  // is not indexed as active through its chunks (chatgpt P2).
+                  ...(faithfulnessFm ? { faithfulness: faithfulnessFm } : {}),
+                  ...(faithfulnessEnforceStatus ? { status: faithfulnessEnforceStatus } : {}),
                 },
               );
             }
@@ -15122,7 +15213,9 @@ export class Orchestrator {
             `chunked memory ${parentId} into ${chunkResult.chunks.length} chunks`,
           );
           trackPersistedId(targetStorage, parentId);
+          // #1576 (cursor Medium): keep pending_review ids out of threadEpisodeIdsForGraph — else later active facts build thread-predecessor edges to an unfaithful memory.
           if (
+            faithfulnessEnforceStatus !== "pending_review" &&
             threadEpisodeIdsForGraph &&
             !threadEpisodeIdsForGraph.includes(parentId)
           ) {
@@ -15132,23 +15225,31 @@ export class Orchestrator {
           // PR #402 Thread 1 fix: run source-namespace temporal supersession for
           // chunked writes, matching the non-chunked path.  Without this the
           // source namespace retains stale facts that should have been superseded.
-          try {
-            const supersessionEntityRef =
-              typeof (fact as any).entityRef === "string"
-                ? ((fact as any).entityRef as string)
-                : undefined;
-            await applyTemporalSupersession({
-              storage: targetStorage,
-              newMemoryId: parentId,
-              entityRef: supersessionEntityRef,
-              structuredAttributes: fact.structuredAttributes,
-              createdAt: supersessionOrderingAt(sourceContext?.validAt),
-              enabled: this.config.temporalSupersessionEnabled,
-            });
-          } catch (err) {
-            log.warn(`temporal-supersession (chunked): unexpected error: ${err}`);
+          // Faithfulness gate (#1576, cursor High): skip supersession for a
+          // pending_review fact — an unfaithful extraction in the review queue
+          // must NOT retire older active memories.
+          if (faithfulnessEnforceStatus !== "pending_review") {
+            try {
+              const supersessionEntityRef =
+                typeof (fact as any).entityRef === "string"
+                  ? ((fact as any).entityRef as string)
+                  : undefined;
+              await applyTemporalSupersession({
+                storage: targetStorage,
+                newMemoryId: parentId,
+                entityRef: supersessionEntityRef,
+                structuredAttributes: fact.structuredAttributes,
+                createdAt: supersessionOrderingAt(sourceContext?.validAt),
+                enabled: this.config.temporalSupersessionEnabled,
+              });
+            } catch (err) {
+              log.warn(`temporal-supersession (chunked): unexpected error: ${err}`);
+            }
           }
-          await promoteMemoryToShared({
+          // Faithfulness gate (#1576, chatgpt P2): do not promote a
+          // pending_review fact to shared/profile — it must enter the review
+          // queue without active copies that bypass the gate.
+          if (faithfulnessEnforceStatus !== "pending_review") await promoteMemoryToShared({
             sourceStorage: targetStorage,
             category: writeCategory,
             content: fact.content,
@@ -15193,7 +15294,8 @@ export class Orchestrator {
             if (
               this.config.verbatimArtifactsEnabled &&
               this.config.verbatimArtifactCategories.includes(writeCategory) &&
-              fact.confidence >= this.config.verbatimArtifactsMinConfidence
+              fact.confidence >= this.config.verbatimArtifactsMinConfidence &&
+              faithfulnessEnforceStatus !== "pending_review"
             ) {
               // Reuse citedChunkedContent so the artifact carries the same citation
               // timestamp as the parent memory write above (Fix #3 — duplicate-citation).
@@ -15207,8 +15309,8 @@ export class Orchestrator {
                 intentEntityTypes: inferredIntent?.entityTypes,
               });
             }
-            // v8.2: graph edge building for chunked memories
-            if (graphCaps.multiGraphMemory) {
+            // v8.2: graph edge building for chunked memories. #1576: skip pending_review.
+            if (graphCaps.multiGraphMemory && faithfulnessEnforceStatus !== "pending_review") {
               try {
                 const graphContext = await ensureGraphContext(targetStorage);
                 const entityRef =
@@ -15333,6 +15435,9 @@ export class Orchestrator {
           structuredAttributes: fact.structuredAttributes,
           validAt: sourceContext?.validAt,
           contentHashSource: writeCategory === "fact" ? fact.content : undefined,
+          // Faithfulness gate (issue #1576).
+          ...(faithfulnessFm ? { faithfulness: faithfulnessFm } : {}),
+          ...(faithfulnessEnforceStatus ? { status: faithfulnessEnforceStatus } : {}),
         },
       );
       if (routedRuleId) {
@@ -15342,22 +15447,26 @@ export class Orchestrator {
       }
       // Temporal supersession (issue #375): when the new fact has structured
       // attributes, retire any older fact with the same entity + attribute
-      // key that has a conflicting value.
-      try {
-        const supersessionEntityRef =
-          typeof (fact as any).entityRef === "string"
-            ? ((fact as any).entityRef as string)
-            : undefined;
-        await applyTemporalSupersession({
-          storage: targetStorage,
-          newMemoryId: memoryId,
-          entityRef: supersessionEntityRef,
-          structuredAttributes: fact.structuredAttributes,
-          createdAt: supersessionOrderingAt(sourceContext?.validAt),
-          enabled: this.config.temporalSupersessionEnabled,
-        });
-      } catch (err) {
-        log.warn(`temporal-supersession: unexpected error: ${err}`);
+      // key that has a conflicting value. Faithfulness gate (#1576, cursor
+      // High): skip for a pending_review fact — an unfaithful extraction in
+      // the review queue must NOT retire older active memories.
+      if (faithfulnessEnforceStatus !== "pending_review") {
+        try {
+          const supersessionEntityRef =
+            typeof (fact as any).entityRef === "string"
+              ? ((fact as any).entityRef as string)
+              : undefined;
+          await applyTemporalSupersession({
+            storage: targetStorage,
+            newMemoryId: memoryId,
+            entityRef: supersessionEntityRef,
+            structuredAttributes: fact.structuredAttributes,
+            createdAt: supersessionOrderingAt(sourceContext?.validAt),
+            enabled: this.config.temporalSupersessionEnabled,
+          });
+        } catch (err) {
+          log.warn(`temporal-supersession: unexpected error: ${err}`);
+        }
       }
       try {
         trackBehaviorSignals(
@@ -15372,14 +15481,18 @@ export class Orchestrator {
           }),
         );
         trackPersistedId(targetStorage, memoryId);
+        // #1576 (cursor Medium): same thread-episode guard on the non-chunked path.
         if (
+          faithfulnessEnforceStatus !== "pending_review" &&
           threadEpisodeIdsForGraph &&
           !threadEpisodeIdsForGraph.includes(memoryId)
         ) {
           threadEpisodeIdsForGraph.push(memoryId);
         }
         await this.indexPersistedMemory(targetStorage, memoryId);
-        await promoteMemoryToShared({
+        // Faithfulness gate (#1576, chatgpt P2): skip promotion for a
+        // pending_review fact so no active shared/profile copy bypasses the gate.
+        if (faithfulnessEnforceStatus !== "pending_review") await promoteMemoryToShared({
           sourceStorage: targetStorage,
           category: writeCategory,
           content: fact.content,
@@ -15399,8 +15512,8 @@ export class Orchestrator {
           validAt: sourceContext?.validAt,
           source: extractionWriteSource,
         });
-        // v8.2: graph edge building (fail-open — errors caught inside GraphIndex)
-        if (graphCaps.multiGraphMemory) {
+        // v8.2: graph edge building (fail-open). #1576: skip pending_review facts.
+        if (graphCaps.multiGraphMemory && faithfulnessEnforceStatus !== "pending_review") {
           try {
             const graphContext = await ensureGraphContext(targetStorage);
             const entityRef =
@@ -15443,7 +15556,8 @@ export class Orchestrator {
         if (
           this.config.verbatimArtifactsEnabled &&
           this.config.verbatimArtifactCategories.includes(writeCategory) &&
-          fact.confidence >= this.config.verbatimArtifactsMinConfidence
+          fact.confidence >= this.config.verbatimArtifactsMinConfidence &&
+          faithfulnessEnforceStatus !== "pending_review"
         ) {
           // Reuse citedFactContent so the artifact carries the same citation
           // timestamp as the memory write above (Fix #3 — duplicate-citation).
@@ -16296,9 +16410,8 @@ export class Orchestrator {
         const tmtEntries = allMemories
           .filter(
             (m) =>
-              m.frontmatter.status !== "superseded" &&
-              m.frontmatter.status !== "archived" &&
-              m.frontmatter.status !== "forgotten",
+              m.frontmatter.status !== "superseded" && m.frontmatter.status !== "archived" &&
+              m.frontmatter.status !== "forgotten" && m.frontmatter.status !== "pending_review", // #1576: unfaithful queue items must not feed TMT clusters
           )
           .map((m) => ({
             path: m.path,
@@ -18965,7 +19078,18 @@ export class Orchestrator {
       }
       const memory = memoryByPath.get(r.path);
       if (memory) {
-        if (memory.frontmatter.status === "forgotten") {
+        // Review-lifecycle statuses never enter active recall injection
+        // (forgotten, pending_review, rejected, quarantined). Superseded and
+        // archived have dedicated filters below. #1576: the faithfulness gate
+        // routes unsupported/contradicted facts to pending_review — they must
+        // not leak back via the QMD/embedding path. chatgpt P2.
+        const recallStatus = memory.frontmatter.status;
+        if (
+          recallStatus === "forgotten" ||
+          recallStatus === "pending_review" ||
+          recallStatus === "rejected" ||
+          recallStatus === "quarantined"
+        ) {
           forgottenFilteredCount += 1;
           continue;
         }