@remnic/core 9.69.46 → 9.69.47

package/src/memory-browse.ts

@@ -0,0 +1,316 @@
+/**
+ * Memory-store browse verbs (issue #2978) — deterministic `ls` / `tree` /
+ * `find` over ONE resolved namespace's memory store, so an agent can see
+ * what exists instead of guessing ids at an opaque search box.
+ *
+ * Scope rules (all existing contracts, no new ones):
+ *   - Every call resolves through the caller's `resolveReadableNamespace`
+ *     (read/write path symmetry) and ONE storage instance — browse never
+ *     enumerates across namespaces.
+ *   - Only the recall corpus is browsable: a path's top segment must be a
+ *     `RECALL_FALLBACK_DIRS` category AND survive
+ *     `isGenericRecallExcludedPath`. Derived stores (`artifacts/`,
+ *     `meetings/` records, wearables day stores, `state/`, ...) are
+ *     indistinguishable from missing paths — `not_found`, never listed.
+ *   - Support-passport private memories are filtered exactly like
+ *     `memoryBrowse` (the paginated list): their names never appear.
+ *   - Output is deterministically sorted (plain code-point order, no
+ *     locale) and entry-capped so a huge store cannot blow the response.
+ *
+ * `ponytail:` the index is rebuilt from `readAllMemories()` per call —
+ * O(corpus) per browse. Fine at agent cadence; swap for a cached directory
+ * index if browsing ever sits on a hot path.
+ */
+
+import { toMemoryPathRel } from "./memory-lifecycle-ledger-utils.js";
+import { normalizeProjectionPreview } from "./memory-projection-format.js";
+import { isGenericRecallExcludedPath } from "./orchestration/generic-recall-paths.js";
+import { isSupportPassportPrivateMemory } from "./support-passport/card-projection.js";
+import { RECALL_FALLBACK_DIRS } from "./utils/category-dir.js";
+import type { MemoryFile } from "./types.js";
+
+/** Browse reads touch only these storage members. */
+export interface MemoryBrowseStorage {
+  readonly dir: string;
+  readAllMemories(): Promise<MemoryFile[]>;
+}
+
+/** Injected seams; the service supplies live wiring, tests supply doubles. */
+export interface MemoryBrowseDeps {
+  readonly resolveReadableNamespace: (namespace: string | undefined, principal?: string) => string;
+  readonly getStorage: (namespace: string) => Promise<MemoryBrowseStorage>;
+}
+
+export type BrowseVerb = "ls" | "tree" | "find";
+
+export interface MemoryStoreBrowseRequest {
+  readonly verb: BrowseVerb;
+  /** ls/tree: directory relative to the store root ("" or "/" = root). */
+  readonly path?: string;
+  /** tree: expansion depth, 1..MAX_TREE_DEPTH (default 1). */
+  readonly depth?: number;
+  /** find: glob (`*` wildcard) or substring matched against path and name. */
+  readonly pattern?: string;
+  readonly namespace?: string;
+  readonly authenticatedPrincipal?: string;
+}
+
+export interface MemoryBrowseEntry {
+  /** Store-relative path with forward slashes; dirs carry no trailing slash. */
+  readonly path: string;
+  readonly kind: "dir" | "file";
+  readonly name: string;
+  /** Files: first content line (180-char preview). Dirs: empty. */
+  readonly description: string;
+  /** Dirs: recursive memory count beneath. Files: 1. */
+  readonly count: number;
+  /** 0-based depth relative to the browse root (tree nests; ls/find are 0). */
+  readonly depth: number;
+}
+
+export type MemoryBrowseError = "invalid_path" | "not_found" | "invalid_depth" | "invalid_pattern";
+
+export type MemoryStoreBrowseResult =
+  | {
+      ok: true;
+      verb: BrowseVerb;
+      namespace: string;
+      path: string;
+      total: number;
+      entries: MemoryBrowseEntry[];
+      truncated: boolean;
+      rendered: string;
+    }
+  | {
+      ok: false;
+      verb: BrowseVerb;
+      path: string;
+      error: MemoryBrowseError;
+      message: string;
+      rendered: string;
+    };
+
+export const MAX_LS_ENTRIES = 200;
+export const MAX_TREE_ENTRIES = 400;
+export const MAX_TREE_DEPTH = 4;
+export const MAX_FIND_ENTRIES = 200;
+const MAX_PATH_CHARS = 512;
+const MAX_PATTERN_CHARS = 256;
+
+const BROWSABLE_ROOTS: Record<string, true> = Object.fromEntries(RECALL_FALLBACK_DIRS.map((dir) => [dir, true]));
+
+/** The recall-corpus visibility rule shared by every browse code path. */
+function isBrowsableMemoryPath(relPath: string): boolean {
+  if (!relPath.endsWith(".md")) return false;
+  const top = relPath.split("/")[0] ?? "";
+  return BROWSABLE_ROOTS[top] === true && !isGenericRecallExcludedPath(relPath);
+}
+
+/**
+ * Normalize a caller-supplied store path. Returns "" for the root. Throws
+ * `Error` on absolute paths, `..`/`.` segments, backslashes, control
+ * characters, or oversize input — never reinterpreted (pattern 39).
+ */
+export function sanitizeBrowsePath(raw: string | undefined): string {
+  const trimmed = (raw ?? "").trim();
+  if (trimmed === "" || trimmed === "/") return "";
+  if (trimmed.length > MAX_PATH_CHARS) throw new Error("path is too long");
+  if (trimmed.includes("\\")) throw new Error("path must use '/' separators");
+  const segments = trimmed.split("/");
+  for (const segment of segments) {
+    if (segment === "") throw new Error("path has an empty segment");
+    if (segment === "." || segment === "..") throw new Error("path must not contain '.' or '..' segments");
+    for (const ch of segment) {
+      const code = ch.charCodeAt(0);
+      if (code < 0x20 || code === 0x7f) throw new Error("path has control characters");
+    }
+  }
+  return segments.join("/");
+}
+
+/** Escape every regex metacharacter in a glob segment. */
+function segmentRegex(segment: string): RegExp {
+  const source = `^${segment.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`;
+  return new RegExp(source, "i");
+}
+
+/**
+ * `*` glob (one segment per pattern segment, `find -name` semantics — `*`
+ * never crosses `/`) or case-insensitive substring over path and name.
+ */
+export function browsePatternMatches(pattern: string, relPath: string): boolean {
+  const segments = relPath.split("/");
+  const name = segments[segments.length - 1] ?? "";
+  const patternSegments = pattern.split("/");
+  if (patternSegments.length === 1) {
+    const single = patternSegments[0]!;
+    if (single.includes("*")) return segmentRegex(single).test(name);
+    const needle = single.toLowerCase();
+    return relPath.toLowerCase().includes(needle) || name.toLowerCase().includes(needle);
+  }
+  if (patternSegments.length !== segments.length) return false;
+  return patternSegments.every((segment, index) => segmentRegex(segment).test(segments[index]!));
+}
+
+interface DirNode {
+  readonly subdirs: Map<string, DirNode>;
+  readonly files: Map<string, MemoryFile>;
+  count: number;
+}
+
+function emptyNode(): DirNode {
+  return { subdirs: new Map(), files: new Map(), count: 0 };
+}
+
+/** Directory index over the browsable corpus: root "" holds category dirs. */
+function buildIndex(memories: readonly MemoryFile[], dir: string): DirNode {
+  const root = emptyNode();
+  for (const memory of memories) {
+    const rel = toMemoryPathRel(dir, memory.path);
+    if (!isBrowsableMemoryPath(rel)) continue;
+    const segments = rel.split("/");
+    let node = root;
+    node.count += 1;
+    for (let index = 0; index < segments.length - 1; index += 1) {
+      const name = segments[index]!;
+      let child = node.subdirs.get(name);
+      if (child === undefined) {
+        child = emptyNode();
+        node.subdirs.set(name, child);
+      }
+      node = child;
+      node.count += 1;
+    }
+    node.files.set(segments[segments.length - 1]!, memory);
+  }
+  return root;
+}
+
+function byPath(left: { path: string }, right: { path: string }): number {
+  return left.path < right.path ? -1 : left.path > right.path ? 1 : 0;
+}
+
+function dirEntries(node: DirNode, dirPath: string): MemoryBrowseEntry[] {
+  const prefix = dirPath === "" ? "" : `${dirPath}/`;
+  const entries: MemoryBrowseEntry[] = [];
+  for (const [name, child] of node.subdirs) {
+    entries.push({ path: `${prefix}${name}`, kind: "dir", name, description: "", count: child.count, depth: 0 });
+  }
+  for (const [name, memory] of node.files) {
+    entries.push({
+      path: `${prefix}${name}`,
+      kind: "file",
+      name,
+      description: normalizeProjectionPreview(memory.content),
+      count: 1,
+      depth: 0,
+    });
+  }
+  return entries.sort(byPath);
+}
+
+function renderEntries(verb: BrowseVerb, namespace: string, browsePath: string, entries: readonly MemoryBrowseEntry[]): string {
+  const lines = [`${verb} ${namespace}:${browsePath === "" ? "/" : browsePath}`];
+  for (const entry of entries) {
+    const indent = "  ".repeat(entry.depth);
+    if (entry.kind === "dir") {
+      lines.push(`${indent}${entry.path}/ (${entry.count} memories)`);
+    } else {
+      const description = entry.description.length > 0 ? ` — ${entry.description}` : "";
+      lines.push(`${indent}${entry.path}${description}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+function refusal(verb: BrowseVerb, browsePath: string, error: MemoryBrowseError, message: string): MemoryStoreBrowseResult {
+  return { ok: false, verb, path: browsePath, error, message, rendered: `browse ${verb} failed: ${error} — ${message}` };
+}
+
+/** Run one browse verb. Malformed input throws `Error`; typed refusals return in-band. */
+export async function runMemoryBrowse(
+  deps: MemoryBrowseDeps,
+  request: MemoryStoreBrowseRequest,
+): Promise<MemoryStoreBrowseResult> {
+  const namespace = deps.resolveReadableNamespace(request.namespace, request.authenticatedPrincipal);
+  const storage = await deps.getStorage(namespace);
+  const memories = (await storage.readAllMemories()).filter((memory) => !isSupportPassportPrivateMemory(memory));
+
+  if (request.verb === "find") {
+    const pattern = (request.pattern ?? "").trim();
+    if (pattern.length === 0) return refusal(request.verb, "", "invalid_pattern", "pattern is required");
+    if (pattern.length > MAX_PATTERN_CHARS) {
+      return refusal(request.verb, "", "invalid_pattern", "pattern is too long");
+    }
+    const hits: MemoryBrowseEntry[] = [];
+    let truncated = false;
+    let total = 0;
+    for (const memory of memories) {
+      const rel = toMemoryPathRel(storage.dir, memory.path);
+      if (!isBrowsableMemoryPath(rel)) continue;
+      if (!browsePatternMatches(pattern, rel)) continue;
+      total += 1;
+      if (hits.length >= MAX_FIND_ENTRIES) {
+        truncated = true;
+        break;
+      }
+      hits.push({
+        path: rel,
+        kind: "file",
+        name: rel.split("/").pop() ?? rel,
+        description: normalizeProjectionPreview(memory.content),
+        count: 1,
+        depth: 0,
+      });
+    }
+    hits.sort(byPath);
+    return { ok: true, verb: "find", namespace, path: "", total, entries: hits, truncated, rendered: renderEntries("find", namespace, "", hits) };
+  }
+
+  let browsePath: string;
+  try {
+    browsePath = sanitizeBrowsePath(request.path);
+  } catch (err) {
+    return refusal(request.verb, request.path ?? "", "invalid_path", err instanceof Error ? err.message : String(err));
+  }
+  const root = buildIndex(memories, storage.dir);
+  let node: DirNode | undefined = root;
+  for (const segment of browsePath === "" ? [] : browsePath.split("/")) {
+    node = node?.subdirs.get(segment);
+    if (node === undefined) break;
+  }
+  // Invisible-by-design stores resolve as not_found, indistinguishable from
+  // a missing path: the index only ever contains browsable corpus paths.
+  if (node === undefined) {
+    return refusal(request.verb, browsePath, "not_found", `no browsable store path: ${browsePath}`);
+  }
+
+  if (request.verb === "ls") {
+    const all = dirEntries(node, browsePath);
+    const truncated = all.length > MAX_LS_ENTRIES;
+    const entries = all.slice(0, MAX_LS_ENTRIES);
+    return { ok: true, verb: "ls", namespace, path: browsePath, total: all.length, entries, truncated, rendered: renderEntries("ls", namespace, browsePath, entries) };
+  }
+
+  if (request.depth !== undefined && (!Number.isInteger(request.depth) || request.depth < 1 || request.depth > MAX_TREE_DEPTH)) {
+    return refusal(request.verb, browsePath, "invalid_depth", `depth must be an integer between 1 and ${MAX_TREE_DEPTH}`);
+  }
+  const depth = request.depth ?? 1;
+  const entries: MemoryBrowseEntry[] = [];
+  let truncated = false;
+  const walk = (current: DirNode, currentPath: string, currentDepth: number): void => {
+    for (const entry of dirEntries(current, currentPath)) {
+      if (entries.length >= MAX_TREE_ENTRIES) {
+        truncated = true;
+        return;
+      }
+      entries.push({ ...entry, depth: currentDepth });
+      if (entry.kind === "dir" && currentDepth < depth - 1) {
+        walk(current.subdirs.get(entry.name)!, entry.path, currentDepth + 1);
+        if (truncated) return;
+      }
+    }
+  };
+  walk(node, browsePath, 0);
+  return { ok: true, verb: "tree", namespace, path: browsePath, total: entries.length, entries, truncated, rendered: renderEntries("tree", namespace, browsePath, entries) };
+}

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 });
+  }
+});