@remnic/core 9.69.45 → 9.69.47

package/src/orchestration/semantic-merge-persist.ts

@@ -1144,15 +1144,26 @@ export async function runMergedTargetPostEffects(
     if (input.graphCaps.entityGraph) rewriteTypes.push("entity");
     if (input.graphCaps.timeGraph) rewriteTypes.push("time");
     if (input.graphCaps.causalGraph) rewriteTypes.push("causal");
-    // Round N+12 (C): the remove-and-rebuild is revision-guarded end to end
-    // (see rewriteMergedTargetGraphEdges) — a writer committing a newer body
-    // mid-rebuild aborts this install instead of clobbering its edges.
+    // Round N+12 (C) + #2837: the remove-and-rebuild is revision-guarded
+    // end to end (see rewriteMergedTargetGraphEdges) — a writer committing
+    // a newer body mid-rebuild aborts this install instead of clobbering
+    // its edges. The guard compares the truthful receipt STATUS (#2807:
+    // the dedicated CAS revision token, never public `updated`), and an
+    // UNAVAILABLE sidecar SKIPS the effect entirely: passing a fail-open
+    // undefined into the install is what let an unchecked replacement
+    // install when both sidecar reads failed.
+    const receiptStatus = await storage.readCasRevisionStatus(committed.path);
+    if (receiptStatus.status === "unavailable") {
+      log.warn(
+        `runMergedTargetPostEffects: CAS revision status for ${committed.path} is unavailable (${receiptStatus.reason}); skipping the graph rewrite — the next merge retries it (#2837)`,
+      );
+      return signals;
+    }
     rewriteInstalled = await rewriteMergedTargetGraphEdges(storage, {
       targetId: merge.targetId,
       memoryRelPath,
       mergedContent: merge.mergedContent,
-      // #2807: the dedicated CAS revision token, not public `updated`.
-      revisionChecked: await storage.readCasRevision(committed.path),
+      revisionChecked: receiptStatus.status === "present" ? receiptStatus.revision : undefined,
       rewriteTypes,
       build: () =>
         deps.buildGraphEdge(

package/src/provenance.ts

@@ -652,11 +652,11 @@ function casefold(s: string): string {
  * this as a verified match and record a source without offsets (cursor
  * thread Ocver — "Normalized match drops verified provenance").
  */
-type LocateQuoteResult =
+export type LocateQuoteResult =
   | { matched: false }
   | { matched: true; offsets?: { charStart: number; charEnd: number } };
 
-function locateQuoteOffsets(quote: string, text: string): LocateQuoteResult {
+export function locateQuoteOffsets(quote: string, text: string): LocateQuoteResult {
   // 1. Exact substring match (handles unicode, curly quotes, emoji verbatim).
   const exactIdx = text.indexOf(quote);
   if (exactIdx >= 0) {
@@ -769,7 +769,7 @@ function locateQuoteOffsets(quote: string, text: string): LocateQuoteResult {
  * original meaning (chatgpt-codex-connector thread 4xA — limiting role-prefix
  * stripping to actual prompt labels).
  */
-function stripLeadingRolePrefix(quote: string): string {
+export function stripLeadingRolePrefix(quote: string): string {
   return quote.replace(/^\s*\[(?:context\s+)?(?:user|assistant)\]\s+/i, "");
 }
 

package/src/reconcile/manifest.test.ts

@@ -39,6 +39,33 @@ test("peer manifest revision includes the citation-template fingerprint", () =>
   assert.equal(peerManifestRevision("{{source}}"), custom);
 });
 
+test("buildReconcileManifest stops scheduling read batches once the signal aborts (#2954)", async () => {
+  const controller = new AbortController();
+  let reads = 0;
+  const stub = Buffer.from("stub");
+  // 120 files = three 50-file read batches; the abort lands inside batch 1.
+  const files = Array.from({ length: 120 }, (_, i) => ({
+    path: `facts/batch-abort-${i}.md`,
+    sha256: createHash("sha256").update(String(i)).digest("hex"),
+  }));
+  await assert.rejects(
+    buildReconcileManifest({
+      files,
+      parseMemory: parseFrontmatter,
+      signal: controller.signal,
+      readFile: async () => {
+        reads += 1;
+        if (reads === 1) controller.abort();
+        return stub;
+      },
+    }),
+    (error: unknown) => (error as Error)?.name === "AbortError"
+  );
+  // Batch 1 was already in flight when the abort landed, so exactly its 50
+  // reads ran; batches 2 and 3 must never be scheduled.
+  assert.equal(reads, 50);
+});
+
 test("reconcile manifest keeps file identity separate from canonical semantic identity", async () => {
   const content = "The deployment uses a durable queue with an enrichment suffix.";
   const semanticHash = ContentHashIndex.computeHash("The deployment uses a durable queue.");

package/src/reconcile/manifest.ts

@@ -82,6 +82,9 @@ export interface BuildReconcileManifestOptions {
   parseMemory: ReconcileMemoryParser;
   cachedFiles?: Iterable<ReconcileManifestFile>;
   citationTemplate?: string;
+  /** Cancellation (#2954): checked between read batches so an aborted run
+   * stops scheduling new file reads instead of walking the whole corpus. */
+  signal?: AbortSignal;
 }
 
 const SHA256_PATTERN = /^[a-f0-9]{64}$/i;
@@ -287,6 +290,10 @@ export async function buildReconcileManifest(options: BuildReconcileManifestOpti
     }
   }
   for (let i = 0; i < uncached.length; i += MANIFEST_BUILD_BATCH_SIZE) {
+    // Between batches, not within one: an abort mid-batch lets the in-flight
+    // reads settle (their own fetch signal does the aborting) and stops the
+    // NEXT batch from ever being scheduled.
+    options.signal?.throwIfAborted();
     const batch = uncached.slice(i, i + MANIFEST_BUILD_BATCH_SIZE);
     const results = await Promise.all(
       batch.map(({ file }) =>

package/src/standing-memory-block.test.ts

@@ -0,0 +1,262 @@
+/**
+ * standing-memory-block.test.ts — issue #2971 foundation slice.
+ *
+ * Pins the prefix-cache contract:
+ *  - the block is byte-identical across consecutive builds with an unchanged
+ *    store (same entries), regardless of input order and of the evaluation
+ *    instant (the clock classifies bands but never renders);
+ *  - the volatility lint refuses clocks, dates, and counters at build time;
+ *  - three-band layering (pinned full, fresh full, older compressed to a
+ *    recognition hook) with a hook ledger that makes steady-state rebuilds
+ *    free and lets a later model slice pre-seed hooks;
+ *  - the mechanical trim fallback drops compressed lines from the tail and
+ *    never a pinned line;
+ *  - zero-diff: with the feature off (and even on, pre-wiring), the live
+ *    recall output is byte-identical and contains no standing block.
+ */
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import test from "node:test";
+
+import { parseConfig } from "./config.js";
+import { Orchestrator } from "./orchestrator.js";
+import type { PluginConfig } from "./types.js";
+import {
+  buildStandingMemoryBlock,
+  lintStandingBlockVolatility,
+  parseRecallStandingBlock,
+  parseStandingBlockFreshDays,
+  parseStandingBlockMaxChars,
+  standingHookLedgerKey,
+  StandingBlockBudgetError,
+  StandingBlockVolatilityError,
+  type StandingMemoryEntry,
+} from "./standing-memory-block.js";
+
+const NOW = Date.parse("2026-08-25T12:00:00.000Z");
+
+const PINNED: StandingMemoryEntry = {
+  id: "p-core",
+  description: "Deploys always go through the blue pipeline, never green.",
+  pinned: true,
+};
+const PINNED2: StandingMemoryEntry = {
+  id: "p-two",
+  description: "Every release tag is signed with the release key.",
+  pinned: true,
+};
+const FRESH: StandingMemoryEntry = {
+  id: "f-recent",
+  description: "The auth service owner is Priya.",
+  lastChangedAt: "2026-08-20T09:00:00.000Z",
+};
+const OLD_LONG: StandingMemoryEntry = {
+  id: "o-history",
+  description:
+    "The billing stack migrated off the legacy invoice service after the Q3 review " +
+    "because duplicate charges surfaced twice and the team rebuilt invoicing around " +
+    "the ledger event stream that the finance group already trusted.",
+  lastChangedAt: "2025-11-01T00:00:00.000Z",
+};
+
+test("parseConfig: standing block keys default off with byte-identical behavior", () => {
+  const base = { memoryDir: "/tmp/remnic-standing-config-test" };
+  const parsed = parseConfig(base);
+  assert.equal(parsed.recallStandingBlock, false, "absent → false");
+  assert.equal(parsed.standingBlockFreshDays, 14);
+  assert.equal(parsed.standingBlockMaxChars, 2048);
+  assert.equal(parseConfig({ ...base, recallStandingBlock: false }).recallStandingBlock, false);
+  assert.equal(parseConfig({ ...base, recallStandingBlock: 0 }).recallStandingBlock, false);
+  assert.equal(parseConfig({ ...base, recallStandingBlock: "false" }).recallStandingBlock, false);
+  assert.equal(parseConfig({ ...base, recallStandingBlock: true }).recallStandingBlock, true);
+  assert.equal(parseConfig({ ...base, recallStandingBlock: 1 }).recallStandingBlock, true);
+  assert.equal(parseConfig({ ...base, recallStandingBlock: "true" }).recallStandingBlock, true);
+  assert.equal(parseStandingBlockFreshDays("30"), 30);
+  assert.equal(parseStandingBlockMaxChars(1024), 1024);
+  assert.throws(() => parseStandingBlockFreshDays(-1), /Invalid standingBlockFreshDays/);
+  assert.throws(() => parseStandingBlockMaxChars(0), /Invalid standingBlockMaxChars/);
+});
+
+test("block is byte-identical across consecutive builds with an unchanged store", () => {
+  const entries = [PINNED, FRESH, OLD_LONG];
+  const first = buildStandingMemoryBlock({ entries, nowMs: NOW });
+  const second = buildStandingMemoryBlock({ entries, nowMs: NOW });
+  assert.equal(first.text, second.text);
+  assert.equal(first.text, buildStandingMemoryBlock({ entries: [...entries].reverse(), nowMs: NOW }).text);
+  assert.equal(
+    first.text,
+    buildStandingMemoryBlock({ entries, nowMs: NOW + 3_600_000, ledger: first.ledger }).text,
+    "the evaluation clock must never render into the block",
+  );
+  assert.ok(first.text.startsWith("## Standing Memory (Remnic)"));
+});
+
+test("volatility lint refuses dates, clocks, relative dates, and counters at build time", () => {
+  assert.deepEqual(lintStandingBlockVolatility("shipped 2026-08-01"), [
+    { kind: "iso-date", token: "2026-08-01" },
+  ]);
+  assert.deepEqual(lintStandingBlockVolatility("standup at 10:30 sharp"), [
+    { kind: "clock-time", token: "10:30" },
+  ]);
+  assert.deepEqual(lintStandingBlockVolatility("fixed yesterday"), [
+    { kind: "relative-date", token: "yesterday" },
+  ]);
+  assert.deepEqual(lintStandingBlockVolatility("index has memories: 42 rows"), [
+    { kind: "counter", token: "memories: 42" },
+  ]);
+  assert.deepEqual(lintStandingBlockVolatility("quiet, stable line"), []);
+
+  const refuses = (entry: StandingMemoryEntry, kind: string) => {
+    assert.throws(
+      () => buildStandingMemoryBlock({ entries: [entry], nowMs: NOW }),
+      (err: unknown) => {
+        assert.ok(err instanceof StandingBlockVolatilityError);
+        assert.equal(err.matches[0]?.kind, kind);
+        return true;
+      },
+      `expected refusal for ${kind}`,
+    );
+  };
+  refuses({ id: "d1", description: "Deployed on 2026-08-01 to prod." }, "iso-date");
+  refuses({ id: "d2", description: "The standup moved to 09:15." }, "clock-time");
+  refuses({ id: "d3", description: "The on-call rota changed yesterday." }, "relative-date");
+});
+
+test("three-band layering: pinned full first, fresh full, older compressed to a hook", () => {
+  const built = buildStandingMemoryBlock({ entries: [OLD_LONG, FRESH, PINNED], nowMs: NOW });
+  const body = built.lines.filter((line) => line.startsWith("- "));
+  assert.deepEqual(built.bandCounts, { pinned: 1, fresh: 1, compressed: 1, dropped: 0 });
+  // Band rank, then id order: pinned band has p-core alone.
+  assert.equal(body[0], `- ${PINNED.description}`);
+  assert.equal(body[1], `- ${FRESH.description}`);
+  const hookLine = body[2] ?? "";
+  assert.ok(hookLine.startsWith("- "), "compressed line must render");
+  assert.ok(hookLine.endsWith("..."), "mechanical hook marks truncation");
+  assert.ok(hookLine.length <= 2 + 96 + 3, "hook stays inside the char budget");
+  assert.ok(
+    built.ledger.get(standingHookLedgerKey(OLD_LONG.description, 96))?.endsWith("..."),
+    "generated hook lands in the ledger",
+  );
+});
+
+test("hook ledger: pre-seeded hooks are used verbatim; reuse keeps bytes identical", () => {
+  const seeded = new Map([[standingHookLedgerKey(OLD_LONG.description, 96), "Billing moved to the ledger stream."]]);
+  const built = buildStandingMemoryBlock({ entries: [OLD_LONG], nowMs: NOW, ledger: seeded });
+  assert.ok(built.text.includes("- Billing moved to the ledger stream."));
+  const rebuilt = buildStandingMemoryBlock({ entries: [OLD_LONG], nowMs: NOW, ledger: built.ledger });
+  assert.equal(built.text, rebuilt.text);
+  assert.equal(seeded.size, 1, "input ledger is never mutated");
+});
+
+test("mechanical trim: drops compressed lines from the tail, never pinned lines", () => {
+  const built = buildStandingMemoryBlock({ entries: [OLD_LONG, FRESH, PINNED], nowMs: NOW, maxChars: 220 });
+  assert.equal(built.bandCounts.pinned, 1, "pinned line survives");
+  assert.ok(built.bandCounts.dropped >= 1, "tail lines dropped");
+  assert.ok(built.text.includes("- ...(older lines trimmed)"));
+  assert.ok(!built.text.includes(OLD_LONG.description.slice(0, 40)), "the longest compressed line is gone");
+  assert.throws(
+    () => buildStandingMemoryBlock({ entries: [PINNED, PINNED2], nowMs: NOW, maxChars: 80 }),
+    StandingBlockBudgetError,
+  );
+});
+
+test("no entries render an empty block; bad input is refused loudly", () => {
+  assert.equal(buildStandingMemoryBlock({ entries: [], nowMs: NOW }).text, "");
+  assert.throws(
+    () => buildStandingMemoryBlock({ entries: [{ id: "x", description: "" }], nowMs: NOW }),
+    /requires a non-empty description/,
+  );
+  assert.throws(
+    () =>
+      buildStandingMemoryBlock({
+        entries: [
+          { id: "x", description: "One." },
+          { id: "x", description: "Two." },
+        ],
+        nowMs: NOW,
+      }),
+    /ids must be unique/,
+  );
+  assert.throws(
+    () => buildStandingMemoryBlock({ entries: [{ id: "x", description: "One.", lastChangedAt: "nope" }], nowMs: NOW }),
+    /unparseable lastChangedAt/,
+  );
+});
+
+/**
+ * Zero-diff proof for the foundation slice: nothing on the live recall path
+ * reads the new keys yet, so recall output must stay byte-identical whether
+ * the flag is absent or explicitly true, and must contain no standing block.
+ * When the server wiring slice lands, this test flips to assert the block IS
+ * prepended when on — that flip is the wiring PR's fail-before receipt.
+ */
+async function makeOrchestrator(
+  overrides: Partial<PluginConfig> = {},
+): Promise<{ orchestrator: Orchestrator; memoryDir: string }> {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-standing-zero-diff-"));
+  const config = parseConfig({
+    openaiApiKey: "sk-test",
+    memoryDir,
+    workspaceDir: path.join(memoryDir, "workspace"),
+    qmdEnabled: false,
+    embeddingFallbackEnabled: false,
+    multiGraphMemoryEnabled: false,
+    entityGraphEnabled: false,
+    timeGraphEnabled: false,
+    causalGraphEnabled: false,
+    extractionJudgeEnabled: false,
+    contradictionDetectionEnabled: false,
+    chunkingEnabled: false,
+    extractionMinChars: 0,
+    extractionMinImportanceLevel: "trivial",
+    inlineSourceAttributionEnabled: false,
+    initGateTimeoutMs: 200,
+    ...overrides,
+  });
+  return { orchestrator: new Orchestrator(config), memoryDir };
+}
+
+async function writeFact(memoryDir: string): Promise<void> {
+  const today = new Date().toISOString().slice(0, 10);
+  const factsDir = path.join(memoryDir, "facts", today);
+  await mkdir(factsDir, { recursive: true });
+  const now = new Date().toISOString();
+  const fact = [
+    "---",
+    "id: standing-fact",
+    "category: fact",
+    `created: ${now}`,
+    `updated: ${now}`,
+    "source: extraction",
+    "confidence: 0.8",
+    "confidenceTier: high",
+    "tags: []",
+    "status: active",
+    "---",
+    "",
+    "The blue pipeline is the only deploy path.",
+    "",
+  ];
+  await writeFile(path.join(factsDir, "standing-fact.md"), `${fact.join("\n")}\n`, "utf-8");
+}
+
+test("zero-diff: recall output is byte-identical with the flag off vs on (pre-wiring)", async () => {
+  const off = await makeOrchestrator();
+  const on = await makeOrchestrator({ recallStandingBlock: true });
+  try {
+    await writeFact(off.memoryDir);
+    await writeFact(on.memoryDir);
+    const outOff = await off.orchestrator.recall("how do deploys go out", "sess-standing-off");
+    const outOn = await on.orchestrator.recall("how do deploys go out", "sess-standing-on");
+    assert.equal(outOn, outOff, "recall must not change until the wiring slice lands");
+    assert.ok(!outOn.includes("## Standing Memory (Remnic)"), "no standing block in recall output");
+    assert.ok(outOn.includes("blue pipeline"), "sanity: the fact is recalled");
+  } finally {
+    await off.orchestrator.destroy();
+    await on.orchestrator.destroy();
+    await rm(off.memoryDir, { recursive: true, force: true });
+    await rm(on.memoryDir, { recursive: true, force: true });
+  }
+});