@remnic/core 9.3.714 → 9.3.716

package/dist/transfer/types.d.ts

@@ -313,13 +313,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         peerProfiles: boolean;
     }>;
 }, "strip", z.ZodTypeAny, {
-    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
+    schemaVersion: string;
     id: string;
     version: string;
     description: string;
@@ -334,13 +334,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         directAnswerEnabled: boolean;
     };
 }, {
-    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
+    schemaVersion: string;
     id: string;
     version: string;
     description: string;
@@ -464,13 +464,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             peerProfiles: boolean;
         }>;
     }, "strip", z.ZodTypeAny, {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         version: string;
         description: string;
@@ -485,13 +485,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             directAnswerEnabled: boolean;
         };
     }, {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         version: string;
         description: string;
@@ -518,13 +518,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         version: string;
         description: string;
@@ -551,13 +551,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         version: string;
         description: string;
@@ -683,13 +683,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             }>;
         }, "strip", z.ZodTypeAny, {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;
@@ -704,13 +704,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 directAnswerEnabled: boolean;
             };
         }, {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;
@@ -737,13 +737,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;
@@ -770,13 +770,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;
@@ -819,13 +819,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;
@@ -858,13 +858,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             version: string;
             description: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.714",
+  "version": "9.3.716",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -2966,7 +2966,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.3.714"
+    "@remnic/coding-graph": "^9.3.716"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/capabilities.test.ts

@@ -96,6 +96,34 @@ test("resolveCapabilities returns a frozen object", () => {
   assert.equal(Object.isFrozen(caps), true, "CapabilitySet must be frozen");
 });
 
+test("resolveCapabilities is deterministic — same config always yields identical gate values (one-resolution-per-op #1523)", () => {
+  // The one-resolution-per-op contract (issue #1523): resolve ONCE at the
+  // operation entry, thread the frozen result down. This test proves the
+  // resolution is deterministic — calling it twice with the same config
+  // produces identical values for every gate, so there is never a reason to
+  // re-resolve mid-operation.
+  const config = parseConfig({
+    rerankCacheEnabled: true,
+    recallDirectAnswerEnabled: false,
+    recallMmrEnabled: true,
+    recallPlannerLlmEnabled: true,
+    graphRecallEnabled: true,
+  });
+  const first = resolveCapabilities(config);
+  const second = resolveCapabilities(config);
+  for (const field of FIELDS) {
+    assert.equal(
+      first[field],
+      second[field],
+      `field ${field} must be deterministic across resolutions`,
+    );
+  }
+  // Both must be frozen — a mid-operation mutation would break the contract.
+  assert.equal(Object.isFrozen(first), true);
+  assert.equal(Object.isFrozen(second), true);
+});
+
+
 // ---------------------------------------------------------------------------
 // GraphConstructionCapabilitySet — gate-parity tests (issue #1566 Cluster A).
 //

package/src/direct-answer-wiring.test.ts

@@ -13,7 +13,6 @@ import type { TrustZoneName } from "./trust-zones.js";
 type WiringConfig = DirectAnswerWiringInput["config"];
 
 const BASE_CONFIG: WiringConfig = {
-  recallDirectAnswerEnabled: true,
   recallDirectAnswerTokenOverlapFloor: 0.5,
   recallDirectAnswerImportanceFloor: 0.7,
   recallDirectAnswerAmbiguityMargin: 0.15,
@@ -105,17 +104,24 @@ test("tryDirectAnswer disabled-path does not call any source accessor", async ()
   assert.deepEqual(sources.calls.importance, []);
 });
 
-// ── Backward-compat (#1523): omit top-level `enabled`, fall back to config ──
+// ── One-resolution-per-op (#1523): `enabled` is the sole gate ──────────────
 
-test("tryDirectAnswer falls back to config.recallDirectAnswerEnabled when `enabled` is omitted (disabled)", async () => {
-  // Old input shape: config carries recallDirectAnswerEnabled: false and no
-  // top-level `enabled`. Must short-circuit as "disabled" (identical to the
-  // pre-#1523 behavior) rather than treating undefined as enabled.
-  const sources = makeMockSources({ memories: [makeMemory()] });
+test("tryDirectAnswer disabled when `enabled: false` even with matching candidates (caps wins over any config-derived value)", async () => {
+  // Issue #1523 contract: the resolved capability is the sole gate.
+  // `enabled` comes from `resolveCapabilities(config).recallDirectAnswer`,
+  // resolved ONCE at the recall entry. This test proves the gate value is
+  // authoritative — when it says disabled, the function short-circuits
+  // regardless of candidate quality.
+  const sources = makeMockSources({
+    memories: [makeMemory({ tags: ["pnpm"], content: "remnic uses pnpm" })],
+    trustZones: { m1: "trusted" },
+    importance: { m1: 0.9 },
+  });
   const result = await tryDirectAnswer({
-    query: "does not matter",
+    query: "package manager remnic",
     namespace: "default",
-    config: { ...BASE_CONFIG, recallDirectAnswerEnabled: false },
+    config: BASE_CONFIG,
+    enabled: false,
     sources,
   });
   assert.equal(result.eligible, false);
@@ -123,9 +129,9 @@ test("tryDirectAnswer falls back to config.recallDirectAnswerEnabled when `enabl
   assert.equal(sources.calls.listCandidates, 0);
 });
 
-test("tryDirectAnswer falls back to config.recallDirectAnswerEnabled when `enabled` is omitted (enabled)", async () => {
-  // Old input shape with recallDirectAnswerEnabled: true and no `enabled` must
-  // NOT short-circuit — it proceeds to materialize candidates.
+test("tryDirectAnswer proceeds when `enabled: true` and candidates match", async () => {
+  // Same contract, positive case: when the resolved capability says enabled,
+  // the function proceeds to materialize candidates.
   const sources = makeMockSources({
     memories: [makeMemory({ tags: ["pnpm"], content: "remnic uses pnpm" })],
     trustZones: { m1: "trusted" },
@@ -134,7 +140,8 @@ test("tryDirectAnswer falls back to config.recallDirectAnswerEnabled when `enabl
   const result = await tryDirectAnswer({
     query: "package manager remnic",
     namespace: "default",
-    config: BASE_CONFIG, // recallDirectAnswerEnabled: true
+    config: BASE_CONFIG,
+    enabled: true,
     sources,
   });
   assert.notEqual(result.reason, "disabled");

package/src/direct-answer-wiring.ts

@@ -14,8 +14,9 @@
  *
  * Short-circuit contract:
  *
- * - When the resolved gate (`input.enabled` if supplied, else
- *   `config.recallDirectAnswerEnabled`) is `false`, the function returns the
+ * - When the resolved gate (`input.enabled`, projected from
+ *   `caps.recallDirectAnswer` at the recall-operation entry) is `false`, the
+ *   function returns the
  *   eligibility verdict with reason `"disabled"` without touching any source
  *   accessor.  This is the documented default.
  * - When enabled, the wiring cheaply drops non-trusted-zone memories
@@ -74,7 +75,6 @@ export interface DirectAnswerWiringInput {
   namespace: string;
   config: Pick<
     PluginConfig,
-    | "recallDirectAnswerEnabled"
     | "recallDirectAnswerTokenOverlapFloor"
     | "recallDirectAnswerImportanceFloor"
     | "recallDirectAnswerAmbiguityMargin"
@@ -82,13 +82,12 @@ export interface DirectAnswerWiringInput {
   >;
   /**
    * Direct-answer capability gate, resolved once at the recall-operation entry
-   * (issue #1523: `caps.recallDirectAnswer`). OPTIONAL and additive: when the
-   * caller supplies it, this module and the orchestrator agree on a single
-   * resolved gate value for the whole operation. When omitted, we fall back to
-   * `config.recallDirectAnswerEnabled` so existing callers on the old input
-   * shape keep identical behavior.
+   * via `resolveCapabilities(config).recallDirectAnswer` (issue #1523). This
+   * is the sole gate — the function no longer reads the config flag directly.
+   * Callers MUST pass the resolved capability so the whole operation agrees on
+   * a single gate value.
    */
-  enabled?: boolean;
+  enabled: boolean;
   sources: DirectAnswerSources;
   queryEntityRefs?: string[];
   abortSignal?: AbortSignal;
@@ -105,10 +104,7 @@ export async function tryDirectAnswer(
   const { query, namespace, config, enabled, sources, queryEntityRefs, abortSignal } = input;
 
   const eligibilityConfig: DirectAnswerConfig = {
-    // Prefer the resolved capability when supplied; fall back to the config
-    // flag so callers on the old input shape (config-only, no `enabled`) get
-    // identical gating (issue #1523 backward-compat).
-    enabled: enabled ?? config.recallDirectAnswerEnabled,
+    enabled,
     tokenOverlapFloor: config.recallDirectAnswerTokenOverlapFloor,
     importanceFloor: config.recallDirectAnswerImportanceFloor,
     ambiguityMargin: config.recallDirectAnswerAmbiguityMargin,

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

@@ -25,6 +25,7 @@ import { Orchestrator } from "./orchestrator.js";
 import { readEdges } from "./graph.js";
 import type { ExtractionResult, PluginConfig } from "./types.js";
 import type { LocalLlmClient } from "./local-llm.js";
+import type { BufferTurn, ConversationThread } from "./types.js";
 
 /**
  * Stub local LLM whose `chatCompletion` only answers faithfulness-gate calls
@@ -42,15 +43,20 @@ function faithfulnessStubLocalLlm(
     ) => {
       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);
+      // The batch prompt emits one `FACT: "<text>"` line per fact, each
+      // followed by `Respond with the JSON array entry for index <i>`. The
+      // gate maps verdicts back to facts by that index, so return one entry
+      // per fact in prompt order. (Single-fact callers still get one entry.)
+      const factMatches = [...(userMsg?.content ?? "").matchAll(/FACT: "([^"]*)"/g)];
+      const entries = factMatches.map((m, i) => ({
+        index: i,
+        verdict: verdictForFactContent(m[1] ?? ""),
+        rationale: "stub verdict",
+      }));
       return {
-        content: JSON.stringify([
-          { index: 0, verdict, rationale: "stub verdict" },
-        ]),
+        content: JSON.stringify(
+          entries.length > 0 ? entries : [{ index: 0, verdict: "entailed" as const, rationale: "stub" }],
+        ),
       };
     },
   } as unknown as LocalLlmClient;
@@ -250,3 +256,203 @@ test("pending_review fact gets no graph edge; an active fact with the same entit
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
+
+
+/**
+ * Thread-enabled harness for issue #1635: time + causal graph ON (so
+ * thread-predecessor edges are built), faithfulness gate in enforce mode.
+ * Entity graph is left OFF to isolate the thread-episode predecessor
+ * mechanism (entity-sibling edges are a separate, out-of-scope path).
+ */
+async function makeThreadHarness(): Promise<OrchHarness> {
+  const memoryDir = await mkdtemp(
+    path.join(os.tmpdir(), "remnic-faithfulness-thread-"),
+  );
+  const config: PluginConfig = parseConfig({
+    openaiApiKey: "sk-test",
+    memoryDir,
+    workspaceDir: path.join(memoryDir, "workspace"),
+    multiGraphMemoryEnabled: true,
+    entityGraphEnabled: false,
+    timeGraphEnabled: true,
+    causalGraphEnabled: true,
+    extractionFaithfulnessGate: "enforce",
+    extractionFaithfulnessContextChars: 400,
+    extractionFaithfulnessTimeoutMs: 2000,
+    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 };
+}
+
+/** ExtractionResult with two facts (order preserved by the persist loop). */
+function twoFactResult(
+  contentA: string,
+  entityRefA: string,
+  contentB: string,
+  entityRefB: string,
+): ExtractionResult {
+  return {
+    facts: [
+      { content: contentA, category: "fact", tags: [], confidence: 0.9, entityRef: entityRefA },
+      { content: contentB, category: "fact", tags: [], confidence: 0.9, entityRef: entityRefB },
+    ],
+    entities: [],
+    relationships: [],
+    questions: [],
+    profileUpdates: [],
+  } as unknown as ExtractionResult;
+}
+
+interface StorageLike {
+  ensureDirectories: () => Promise<void>;
+  dir: string;
+  readAllMemories: () => Promise<
+    Array<{ path: string; frontmatter: { id: string; status?: string } }>
+  >;
+}
+
+interface PersistExtractionSig {
+  (
+    r: ExtractionResult,
+    s: unknown,
+    t: string | null,
+    ctx: unknown,
+    bn: unknown,
+    plan: unknown,
+    src: string,
+  ): Promise<string[]>;
+}
+
+test("pending_review id must NOT enter persisted thread episodes across a cross-flush (#1635)", async () => {
+  const { orchestrator, memoryDir } = await makeThreadHarness();
+  try {
+    // fact content containing "closed permanently" → unsupported → pending_review.
+    (orchestrator as unknown as { localLlm: LocalLlmClient }).localLlm =
+      faithfulnessStubLocalLlm((c) =>
+        c.includes("closed permanently") ? "unsupported" : "entailed",
+      );
+
+    const getStorage = orchestrator as unknown as {
+      getStorage: (ns: string) => Promise<StorageLike>;
+    };
+    const storage = await getStorage.getStorage("default");
+    await storage.ensureDirectories();
+
+    // Establish a real thread (mirrors runExtraction's processTurn step) so
+    // appendEpisodeIds has a thread file to write episode ids into.
+    const threading = orchestrator as unknown as {
+      threading: {
+        processTurn: (turn: BufferTurn, ids: string[]) => Promise<string>;
+        loadThread: (id: string) => Promise<ConversationThread | null>;
+      };
+    };
+    const seedTurn: BufferTurn = {
+      role: "user",
+      content: "Tell me about the widget factory.",
+      timestamp: "2026-07-06T10:00:00.000Z",
+      sessionKey: "agent:test:main",
+    };
+    const threadId = await threading.threading.processTurn(seedTurn, []);
+    assert.ok(threadId, "thread established via processTurn");
+
+    const persist = orchestrator as unknown as {
+      persistExtraction: PersistExtractionSig;
+      appendPersistedThreadEpisodes: (
+        threadId: string,
+        persistedIds: string[],
+      ) => Promise<void>;
+    };
+
+    const sourceText =
+      "The widget factory reopened this quarter after being closed permanently last year.";
+
+    // --- Flush 1: an active fact + a pending_review fact, same thread ---
+    const flush1 = await persist.persistExtraction(
+      twoFactResult(
+        "The widget factory reopened this quarter.", "wf-active",
+        "The widget factory closed permanently last year.", "wf-pending",
+      ),
+      storage,
+      threadId,
+      { sessionKey: "agent:test:main", principal: "test" },
+      undefined,
+      null,
+      sourceText,
+    );
+    const [activeId1, pendingId] = flush1;
+    assert.ok(activeId1, "flush1 active fact persisted");
+    assert.ok(pendingId, "flush1 pending_review fact persisted");
+
+    // runExtraction's append step (the real helper; filters pending_review).
+    await persist.appendPersistedThreadEpisodes(threadId, flush1);
+
+    // PART (a): the thread FILE must hold the active id but NOT the pending id.
+    const threadAfter1 = await threading.threading.loadThread(threadId);
+    assert.ok(threadAfter1, "thread file readable after flush 1");
+    assert.ok(
+      threadAfter1!.episodeIds.includes(activeId1),
+      "active fact id is in persisted thread episodes",
+    );
+    assert.ok(
+      !threadAfter1!.episodeIds.includes(pendingId),
+      "pending_review id must NOT enter persisted thread episodes (#1635)",
+    );
+
+    // The pending fact IS durable (with status pending_review) — proves the
+    // gate routed it correctly; the guard is about its absence from the thread.
+    const memsAfter1 = await storage.readAllMemories();
+    const pendingMem = memsAfter1.find((m) => m.frontmatter.id === pendingId);
+    assert.ok(pendingMem, "pending_review fact is durable");
+    assert.equal(
+      pendingMem!.frontmatter.status,
+      "pending_review",
+      "unsupported fact is pending_review under enforce",
+    );
+
+    // --- Flush 2: an active fact in the SAME thread ---
+    const flush2 = await persist.persistExtraction(
+      factResult("The widget factory hired ten new engineers.", "wf-active"),
+      storage,
+      threadId,
+      { sessionKey: "agent:test:main", principal: "test" },
+      undefined,
+      null,
+      sourceText,
+    );
+    const activeId2 = flush2[0];
+    assert.ok(activeId2, "flush2 active fact persisted");
+    await persist.appendPersistedThreadEpisodes(threadId, flush2);
+
+    // PART (a)+(b): no predecessor edge may reference the pending fact. Under
+    // the bug, flush 1 would have appended pendingId to the thread file, flush
+    // 2's loadThread would re-seed it into threadEpisodeIdsForGraph, and the
+    // active fact2 would build a time/causal predecessor edge to it.
+    const pendingPath = path.relative(memoryDir, pendingMem!.path);
+    for (const gtype of ["time", "causal"] as const) {
+      const edges = await readEdges(memoryDir, gtype);
+      assert.ok(
+        !edges.some((e) => e.from === pendingPath || e.to === pendingPath),
+        `no ${gtype} edge references the pending_review fact path (${pendingPath}); got ${edges.length} edges`,
+      );
+    }
+
+    // Control: the graph + threading are wired — the active fact2 builds a
+    // time predecessor edge to the active fact1 (which IS in the thread file).
+    const timeEdges = await readEdges(memoryDir, "time");
+    assert.ok(
+      timeEdges.length > 0,
+      "active fact2 builds a time predecessor edge (control: graph+threading wired)",
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});