@remnic/core 10.0.67 → 10.0.68

package/dist/index.js

@@ -181,7 +181,7 @@ import {
   writeManifest,
   writeMeetingEpisodeMemory,
   writeTimelineState
-} from "./chunk-LFYEQK45.js";
+} from "./chunk-FAF4A76Q.js";
 import {
   WEARABLE_SOURCE_PREFIX,
   buildExtractionTurns,

package/dist/orchestration/buffer-drain-runner.js

@@ -1,6 +1,6 @@
 import {
   TurnIngestionCoordinator
-} from "../chunk-LFYEQK45.js";
+} from "../chunk-FAF4A76Q.js";
 import "../chunk-5QV6CE6K.js";
 import "../chunk-GGD2YDS6.js";
 import "../chunk-5PHOU5QI.js";

package/dist/orchestration/extraction-persist.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extraction-persist.d.ts","sourceRoot":"","sources":["../../src/orchestration/extraction-persist.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAgBxG,OAAO,EAA6C,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAM7F,OAAO,EAUgE,KAAK,8BAA8B,EACxG,KAAK,4BAA4B,EAClC,MAAM,oBAAoB,CAAC;AAqD5B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAGhF,OAAO,KAAK,EAEV,gBAAgB,EAQjB,MAAM,aAAa,CAAC;AAWrB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAmB1E,6FAA6F;AAC7F,MAAM,WAAW,uBAAuB;IACtC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,4EAA4E;IAC5E,aAAa,EAAE,MAAM,CAAC;IACtB,kFAAkF;IAClF,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,qBAAa,4BAA4B;IAErC,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,qBAAqB;IAE9C,OAAO,KAAK,MAAM,GAEjB;IACD,OAAO,KAAK,6BAA6B,GAGxC;IAEK,iBAAiB,CACrB,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,cAAc,EACvB,qBAAqB,CAAC,EAAE,MAAM,GAAG,IAAI,EACrC,aAAa,CAAC,EAAE,uBAAuB,EACvC,aAAa,CAAC,EAAE,MAAM,EACtB,qBAAqB,CAAC,EAAE,wBAAwB,GAAG,IAAI,EACvD,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,GAAE,8BAAuF,EAClG,aAAa,GAAE,4BAAmF,GACjG,OAAO,CAAC,uBAAuB,CAAC;CAkxFpC"}
+{"version":3,"file":"extraction-persist.d.ts","sourceRoot":"","sources":["../../src/orchestration/extraction-persist.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAgBxG,OAAO,EAA6C,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAM7F,OAAO,EAUgE,KAAK,8BAA8B,EACxG,KAAK,4BAA4B,EAClC,MAAM,oBAAoB,CAAC;AAqD5B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAGhF,OAAO,KAAK,EAEV,gBAAgB,EAQjB,MAAM,aAAa,CAAC;AAWrB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAmB1E,6FAA6F;AAC7F,MAAM,WAAW,uBAAuB;IACtC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,4EAA4E;IAC5E,aAAa,EAAE,MAAM,CAAC;IACtB,kFAAkF;IAClF,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,qBAAa,4BAA4B;IAErC,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,qBAAqB;IAE9C,OAAO,KAAK,MAAM,GAEjB;IACD,OAAO,KAAK,6BAA6B,GAGxC;IAEK,iBAAiB,CACrB,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,cAAc,EACvB,qBAAqB,CAAC,EAAE,MAAM,GAAG,IAAI,EACrC,aAAa,CAAC,EAAE,uBAAuB,EACvC,aAAa,CAAC,EAAE,MAAM,EACtB,qBAAqB,CAAC,EAAE,wBAAwB,GAAG,IAAI,EACvD,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,GAAE,8BAAuF,EAClG,aAAa,GAAE,4BAAmF,GACjG,OAAO,CAAC,uBAAuB,CAAC;CA0wFpC"}

package/dist/orchestrator.js

@@ -4,7 +4,7 @@ import {
   graphPathRelativeToStorage,
   mergeGraphExpandedResults,
   qmdStartupCollectionChecksWithTimeout
-} from "./chunk-LFYEQK45.js";
+} from "./chunk-FAF4A76Q.js";
 import "./chunk-5QV6CE6K.js";
 import "./chunk-GGD2YDS6.js";
 import {

package/package.json

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

package/src/extraction-parallel-dedup.test.ts

@@ -0,0 +1,185 @@
+/**
+ * Issue #3312 — non-fact dedup registration must share the fact-dedup commit
+ * window.
+ *
+ * writeMemory indexes content hashes for facts only (rule 44 #1579); every
+ * other category used to register its hash in a post-write block that ran
+ * after persistUnderFactDedupWindow had already released the per-dir commit
+ * window. With extractionQueueConcurrency > 1 a second session's in-window
+ * recheck could then miss and both sessions wrote the same preference —
+ * duplicate active copies. The fix registers the hash inside the window
+ * callback, so any later window holder observes the committed content.
+ *
+ * These tests drive the real persistExtraction path (no LLM network; every
+ * gate that would call one is off) and assert the durable outcome: exactly
+ * one active copy survives a concurrent same-content write pair.
+ */
+
+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 type { ExtractionResult, PluginConfig } from "./types.js";
+import type { LocalLlmClient } from "./local-llm.js";
+import type { PersistExtractionFn } from "./testing/orchestrator-lite.js";
+import type { StorageManager } from "./storage.js";
+
+// Fixture contract for the private Orchestrator surface this suite drives.
+interface OrchestratorFixture {
+  localLlm?: unknown;
+  chatCompletion?: unknown;
+  getStorage?: unknown;
+  persistExtraction?: unknown;
+}
+
+// Named owner contract for the private internals this suite drives.
+interface OrchestratorInternals {
+  localLlm: LocalLlmClient;
+  getStorage: (ns: string) => Promise<StorageManager>;
+  persistExtraction: PersistExtractionFn;
+}
+
+function asInternals<T extends object>(value: OrchestratorFixture): T {
+  // SAFETY: the fixture provides the members the persist path reads; the
+  // remaining contract members are unused by these tests.
+  return value as T;
+}
+
+async function makeHarness(): Promise<{
+  orchestrator: Orchestrator;
+  persist: OrchestratorInternals;
+  memoryDir: string;
+}> {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-parallel-dedup-"));
+  const config: PluginConfig = parseConfig({
+    openaiApiKey: "sk-test",
+    memoryDir,
+    workspaceDir: path.join(memoryDir, "workspace"),
+    // Minimize every gate that needs a model or corpus-scale machinery so the
+    // preference reaches the normal (non-chunked) write path.
+    extractionJudgeEnabled: false,
+    temporalSupersessionEnabled: false,
+    contradictionDetectionEnabled: false,
+    chunkingEnabled: false,
+    embeddingFallbackEnabled: false,
+    qmdEnabled: false,
+    extractionMinChars: 0,
+    extractionMinImportanceLevel: "trivial",
+    inlineSourceAttributionEnabled: false,
+    // Real deployment profile: the artifact write sits between the window
+    // release and hash registration, widening the exact gap under test.
+    verbatimArtifactsEnabled: true,
+    verbatimArtifactCategories: ["preference"],
+  });
+  const orchestrator = new Orchestrator(config);
+  const internals = asInternals<OrchestratorInternals>(orchestrator);
+  internals.localLlm = asInternals<LocalLlmClient>({ chatCompletion: async () => null });
+  return { orchestrator, persist: internals, memoryDir };
+}
+
+function preferenceResult(content: string): ExtractionResult {
+  const result = {
+    facts: [
+      {
+        content,
+        category: "preference",
+        tags: [],
+        confidence: 0.9,
+      },
+    ],
+    entities: [],
+    relationships: [],
+    questions: [],
+    profileUpdates: [],
+  };
+  // SAFETY: literal carries the full extraction-result shape persistExtraction
+  // consumes for a single preference candidate.
+  return result as ExtractionResult;
+}
+
+async function activePreferenceCopies(storage: StorageManager): Promise<number> {
+  const memories = await storage.readAllMemories();
+  return memories.filter(
+    (m) => m.frontmatter.category === "preference" && (m.frontmatter.status ?? "active") === "active",
+  ).length;
+}
+
+const PREFERENCE = "Always answer with bullet points.";
+
+test("a repeated identical preference persists once (serial baseline)", async () => {
+  const { persist, memoryDir } = await makeHarness();
+  try {
+    const storage = await persist.getStorage("default");
+    await storage.ensureDirectories();
+
+    const first = await persist.persistExtraction(
+      preferenceResult(PREFERENCE),
+      storage,
+      null,
+      { sessionKey: "agent:test:a", principal: "test" },
+      undefined,
+      null,
+      "User said they always want bullet points.",
+    );
+    const second = await persist.persistExtraction(
+      preferenceResult(PREFERENCE),
+      storage,
+      null,
+      { sessionKey: "agent:test:b", principal: "test" },
+      undefined,
+      null,
+      "User said they always want bullet points.",
+    );
+
+    assert.equal(first.persistedIds.length, 1, "first write persists");
+    assert.equal(second.persistedIds.length, 0, "second identical write is deduped");
+    assert.equal(await activePreferenceCopies(storage), 1);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("concurrent identical preferences leave exactly one active copy", async () => {
+  const { persist, memoryDir } = await makeHarness();
+  try {
+    const storage = await persist.getStorage("default");
+    await storage.ensureDirectories();
+
+    const sourceText = "User said they always want bullet points.";
+    // The race was probabilistic before the fix (the window released before
+    // registration); after it, this invariant holds for every interleaving.
+    const [a, b] = await Promise.all([
+      persist.persistExtraction(
+        preferenceResult(PREFERENCE),
+        storage,
+        null,
+        { sessionKey: "agent:test:a", principal: "test" },
+        undefined,
+        null,
+        sourceText,
+      ),
+      persist.persistExtraction(
+        preferenceResult(PREFERENCE),
+        storage,
+        null,
+        { sessionKey: "agent:test:b", principal: "test" },
+        undefined,
+        null,
+        sourceText,
+      ),
+    ]);
+
+    assert.equal(
+      a.persistedIds.length + b.persistedIds.length,
+      1,
+      "exactly one concurrent write may persist",
+    );
+    assert.equal(await activePreferenceCopies(storage), 1);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/orchestration/extraction-persist.ts

@@ -2581,8 +2581,8 @@ export class ExtractionPersistCoordinator {
       const factWriteOutcome = await persistUnderFactDedupWindow(
         targetStorage.dir,
         raceRecheck(targetStorage, contentHashDedupKey),
-        async () =>
-          targetStorage.writeSealedMemory(factWriteEnvelope, {
+        async () => {
+          const factWrite = await targetStorage.writeSealedMemory(factWriteEnvelope, {
         importance,
         supersedes,
         links: links.length > 0 ? links : undefined,
@@ -2605,7 +2605,22 @@ export class ExtractionPersistCoordinator {
         // must see this hash, or its recheck misses and duplicates it.
         deferHashIndexSave: false,
         ...(factToolScoped ? { toolScoped: true as const } : {}),
-          }),
+          });
+          // Register the dedup hash inside the same commit window: writeMemory
+          // indexes facts only (rule 44 #1579), so non-fact categories
+          // previously registered after the window released, letting a
+          // concurrent session's in-window recheck miss and both write the
+          // same content (issue #3312). Fail-open, like the post-write
+          // registration this replaces.
+          if (!factWrite.tombstoneBlocked) {
+            try {
+              await this.deps.addContentHashDedup(targetStorage, contentHashDedupKey);
+            } catch (err) {
+              log.warn(`content-hash dedup registration failed for memory ${factWrite.id}: ${err}`);
+            }
+          }
+          return factWrite;
+        },
       ).catch(finalizeOnWindowFailure);
       if (factWriteOutcome.suppressed) {
         // Codex P2: backfill bounds onto the window's winning copy first.
@@ -2800,29 +2815,6 @@ export class ExtractionPersistCoordinator {
             ...(factToolScoped ? { toolScoped: true as const } : {}),
           });
         }
-        // Register in the target storage content-hash index after successful
-        // write. Thread 3 fix: canonicalize by stripping any pre-existing
-        // citation so the stored hash matches what the dedup check computes.
-        try {
-          const canonicalFactContent =
-            citationEnabled &&
-            hasCitationForTemplate(fact.content, citationTemplate)
-              ? stripCitationForTemplate(fact.content, citationTemplate)
-              : fact.content;
-          const hashRegisterKey =
-            writeCategory === "procedure"
-              ? buildProcedurePersistBody(fact.content, fact.procedureSteps)
-              : canonicalFactContent;
-          // #1645: do NOT register a tombstone-blocked fact's content in the dedup
-          // index (rule 44 defeat) — see chunked path comment.
-          if (!tombstoneBlocked) {
-            await this.deps.addContentHashDedup(targetStorage, hashRegisterKey);
-          }
-        } catch (err) {
-          log.warn(
-            `content-hash dedup registration failed for memory ${memoryId}: ${err}`,
-          );
-        }
       } catch (err) {
         // PR #2016 / #3231: finalize deferred side effects for facts already
         // durable before propagating so hash/behavior/harmonic/temporal/QMD

package/src/orchestration/provider-breaker.test.ts

@@ -87,3 +87,25 @@ test("an unowned forced outcome neither trips the half-open threshold nor settle
   breaker.success(probe.token);
   assert.deepEqual(breaker.acquire(6_500).suppressed, false, "owner success closes the breaker");
 });
+
+test("an unowned auth_config failure does not reopen over a held probe", () => {
+  const breaker = new ProviderCircuitBreaker();
+  breaker.failure("provider_retryable", 1_000, CONFIG);
+  breaker.failure("provider_retryable", 1_050, CONFIG);
+  breaker.failure("provider_retryable", 1_100, CONFIG);
+  const probe = breaker.acquire(6_100);
+  assert.equal(probe.probe, true);
+
+  // A forced extraction reporting auth_config while the probe runs must not
+  // flip the breaker open over the still-held owner token (PRRT_kwDORJXyws6z07Mu).
+  breaker.failure("auth_config", 1_200, CONFIG);
+  assert.deepEqual(breaker.acquire(1_300), { suppressed: true, probe: false }, "probe stays held");
+
+  // The owner's own auth_config failure settles it with the auth cooldown.
+  breaker.failure("auth_config", 1_400, CONFIG, probe.token);
+  assert.deepEqual(breaker.acquire(1_500).suppressed, true, "owned auth_config failure reopens at once");
+  assert.deepEqual(breaker.acquire(60_000).suppressed, true, "auth cooldown still gates the next probe");
+  // The stranded-owner hazard: after the auth cooldown elapses, no SECOND
+  // probe may mint while the original owner is still held.
+  assert.deepEqual(breaker.acquire(60_001), { suppressed: true, probe: false }, "no second probe over a held one");
+});