@remnic/core 9.69.52 → 9.69.53

package/src/orchestration/recall-recognition-index.test.ts

@@ -0,0 +1,249 @@
+/**
+ * recall-recognition-index.test.ts — issue #2975 write-path maintenance slice.
+ *
+ * Pins: when recallRecognitionTier is on, a namespace write upserts the
+ * memory id into state/index_recognition.json so loadRecognitionIndex
+ * sees a fresh entry. Gate-off is zero index I/O. Descriptions are the
+ * first non-empty body line (no recognition-trigger generation here).
+ */
+import assert from "node:assert/strict";
+import { mock } from "node:test";
+import os from "node:os";
+import path from "node:path";
+import { promises as fsp } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import test from "node:test";
+
+import { parseConfig } from "../config.js";
+import { loadRecognitionIndex, recognitionIndexPath } from "../recall-recognition-tier.js";
+import { PersistenceIndexCoordinator } from "./persistence-index.js";
+import { maintainRecognitionIndexAfterWrite } from "./recall-recognition-index.js";
+import type { MemoryFile, PluginConfig } from "../types.js";
+
+async function tmpNamespace(): Promise<string> {
+  return mkdtemp(path.join(os.tmpdir(), "remnic-recognition-index-"));
+}
+
+async function exists(filePath: string): Promise<boolean> {
+  try {
+    await fsp.stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+test("acceptance: gate-off write is zero index I/O", async () => {
+  const dir = await tmpNamespace();
+  const spies = [
+    mock.method(fsp, "readFile"),
+    mock.method(fsp, "writeFile"),
+    mock.method(fsp, "mkdir"),
+    mock.method(fsp, "open"),
+    mock.method(fsp, "rename"),
+    mock.method(fsp, "rm"),
+    mock.method(fsp, "unlink"),
+    mock.method(fsp, "stat"),
+    mock.method(fsp, "access"),
+    mock.method(fsp, "readdir"),
+  ];
+  try {
+    await maintainRecognitionIndexAfterWrite({
+      memoryDir: dir,
+      enabled: false,
+      changes: [{ action: "upsert", id: "fact-001", content: "SSD inference chips in the lab rack.\nMore body." }],
+    });
+    for (const spy of spies) {
+      assert.equal(spy.mock.calls.length, 0, `${String(spy.mock.calls.length)} unexpected fs calls on the off path`);
+    }
+    assert.equal(await exists(recognitionIndexPath(dir)), false);
+    assert.equal(await loadRecognitionIndex(dir), null);
+  } finally {
+    for (const spy of spies) spy.mock.restore();
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("acceptance: gate-on write upserts id so loadRecognitionIndex sees a fresh entry", async () => {
+  const dir = await tmpNamespace();
+  try {
+    await maintainRecognitionIndexAfterWrite({
+      memoryDir: dir,
+      enabled: true,
+      changes: [
+        {
+          action: "upsert",
+          id: "fact-001",
+          content: "SSD inference chips in the lab rack.\nRunning the model off a local tier.",
+        },
+      ],
+    });
+    const index = await loadRecognitionIndex(dir);
+    assert.ok(index, "index must exist after an enabled write");
+    assert.deepEqual(index.entries, [
+      { id: "fact-001", description: "SSD inference chips in the lab rack." },
+    ]);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("incremental write updates an existing id in place and appends a new id", async () => {
+  const dir = await tmpNamespace();
+  try {
+    await maintainRecognitionIndexAfterWrite({
+      memoryDir: dir,
+      enabled: true,
+      changes: [{ action: "upsert", id: "m-001", content: "first line original" }],
+    });
+    await maintainRecognitionIndexAfterWrite({
+      memoryDir: dir,
+      enabled: true,
+      changes: [
+        { action: "upsert", id: "m-001", content: "first line rewritten\nbody" },
+        { action: "upsert", id: "m-002", content: "second memory trigger" },
+      ],
+    });
+    const index = await loadRecognitionIndex(dir);
+    assert.deepEqual(index?.entries, [
+      { id: "m-001", description: "first line rewritten" },
+      { id: "m-002", description: "second memory trigger" },
+    ]);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("remove drops the id; blank ids are ignored without writing", async () => {
+  const dir = await tmpNamespace();
+  try {
+    await maintainRecognitionIndexAfterWrite({
+      memoryDir: dir,
+      enabled: true,
+      changes: [
+        { action: "upsert", id: "keep", content: "kept" },
+        { action: "upsert", id: "drop", content: "gone" },
+      ],
+    });
+    await maintainRecognitionIndexAfterWrite({
+      memoryDir: dir,
+      enabled: true,
+      changes: [{ action: "remove", id: "drop" }],
+    });
+    assert.deepEqual((await loadRecognitionIndex(dir))?.entries, [
+      { id: "keep", description: "kept" },
+    ]);
+
+    const before = await fsp.readFile(recognitionIndexPath(dir), "utf8");
+    await maintainRecognitionIndexAfterWrite({
+      memoryDir: dir,
+      enabled: true,
+      changes: [{ action: "upsert", id: "   ", content: "blank id is dropped" }],
+    });
+    assert.equal(await fsp.readFile(recognitionIndexPath(dir), "utf8"), before);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+function memory(id: string, content: string): MemoryFile {
+  return {
+    path: `/tmp/${id}.md`,
+    content,
+    frontmatter: { id, category: "fact", created: "2026-08-25T00:00:00.000Z", updated: "2026-08-25T00:00:00.000Z", source: "test", confidence: 1, confidenceTier: "explicit", tags: [] },
+  };
+}
+
+function stubCoordinator(config: PluginConfig) {
+  return new PersistenceIndexCoordinator({
+    config,
+    contentHashIndex: null,
+    contentHashIndexForStorage: async () => null,
+    contentHashIndexesByStorageDir: new Map(),
+    embeddingFallback: { isAvailable: async () => false } as never,
+    graphIndexFor: () => {
+      throw new Error("graph unused");
+    },
+    readAllMemoriesForNamespaces: async () => [],
+    semanticDedupScopeFor: () => ({}),
+  });
+}
+
+test("persist-path: enabled writes update the namespace index; disabled stays quiet", async () => {
+  const dir = await tmpNamespace();
+  const memories = new Map<string, MemoryFile>([
+    ["fact-ssd", memory("fact-ssd", "Running the model off an SSD tier.\nDetails.")],
+  ]);
+  const storage = {
+    dir,
+    getMemoryById: async (id: string) => memories.get(id) ?? null,
+    getMemoryByIdIncludingArchived: async (id: string) => memories.get(id) ?? null,
+    readAllMemories: async () => [...memories.values()],
+    readAllColdMemories: async () => [],
+  };
+  try {
+    const off = stubCoordinator(parseConfig({}));
+    await off.updateTemporalTagIndexes(storage as never, ["fact-ssd"]);
+    assert.equal(await exists(recognitionIndexPath(dir)), false, "off-path persist must not mint an index");
+
+    const on = stubCoordinator(parseConfig({ recallRecognitionTier: true }));
+    await on.updateTemporalTagIndexes(storage as never, ["fact-ssd"]);
+    const index = await loadRecognitionIndex(dir);
+    assert.deepEqual(index?.entries, [
+      { id: "fact-ssd", description: "Running the model off an SSD tier." },
+    ]);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("persist-path: first post-enable persist bootstraps the active corpus, not just the write", async () => {
+  const dir = await tmpNamespace();
+  const memories = new Map<string, MemoryFile>([
+    ["fact-old", memory("fact-old", "Existing SSD rack layout.\nOlder note.")],
+    ["fact-ssd", memory("fact-ssd", "Running the model off an SSD tier.\nDetails.")],
+  ]);
+  const storage = {
+    dir,
+    getMemoryById: async (id: string) => memories.get(id) ?? null,
+    getMemoryByIdIncludingArchived: async (id: string) => memories.get(id) ?? null,
+    readAllMemories: async () => [...memories.values()],
+    readAllColdMemories: async () => [],
+  };
+  try {
+    const on = stubCoordinator(parseConfig({ recallRecognitionTier: true }));
+    await on.updateTemporalTagIndexes(storage as never, ["fact-ssd"]);
+    const index = await loadRecognitionIndex(dir);
+    assert.deepEqual(
+      index?.entries.map((entry) => entry.id).sort(),
+      ["fact-old", "fact-ssd"],
+    );
+    assert.deepEqual(
+      index?.entries.find((entry) => entry.id === "fact-old"),
+      { id: "fact-old", description: "Existing SSD rack layout." },
+    );
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("stale recognition-index lock is broken so a later write can publish", async () => {
+  const dir = await tmpNamespace();
+  const lockDir = `${recognitionIndexPath(dir)}.lock.d`;
+  try {
+    await fsp.mkdir(lockDir, { recursive: true });
+    const stale = new Date(Date.now() - 120_000);
+    await fsp.utimes(lockDir, stale, stale);
+    await maintainRecognitionIndexAfterWrite({
+      memoryDir: dir,
+      enabled: true,
+      changes: [{ action: "upsert", id: "fact-001", content: "SSD inference chips in the lab rack." }],
+    });
+    const index = await loadRecognitionIndex(dir);
+    assert.deepEqual(index?.entries, [
+      { id: "fact-001", description: "SSD inference chips in the lab rack." },
+    ]);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});

package/src/orchestration/recall-recognition-index.ts

@@ -0,0 +1,169 @@
+/**
+ * Recognition-index write-path maintenance (issue #2975).
+ *
+ * Sibling of recall-recognition-search.ts at the memory write-path seam:
+ * when recallRecognitionTier is enabled, a namespace write upserts (or
+ * removes) that memory's id in `<memoryDir>/state/index_recognition.json`
+ * so the recall slice's loadRecognitionIndex sees a fresh entry. Off-path
+ * (`enabled !== true`) returns immediately — zero index I/O.
+ *
+ * Descriptions: layer 1 has no generator. This slice keeps ids current and
+ * fills description from the first non-empty body line (the compact
+ * `id: description` form the tier already renders). Discriminability
+ * rewrite is a later tidy pass.
+ *
+ * Serialization matches temporal-index: an in-process op chain per index
+ * path plus a directory lock around load → mutate → save. saveRecognitionIndex
+ * is single-writer and does not lock on its own.
+ */
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+
+import {
+  buildRecognitionIndex,
+  loadRecognitionIndex,
+  recognitionIndexPath,
+  saveRecognitionIndex,
+  type RecognitionIndexEntry,
+} from "../recall-recognition-tier.js";
+
+export type RecognitionIndexChange =
+  | { readonly action: "upsert"; readonly id: string; readonly content: string }
+  | { readonly action: "remove"; readonly id: string };
+
+const writeChains = new Map<string, Promise<void>>();
+const LOCK_POLL_MS = 10;
+const LOCK_ATTEMPTS = 50;
+const LOCK_STALE_MS = 60_000;
+
+/**
+ * First non-empty line of a memory body. Layer 1 has no description
+ * generator; this is the compact line the tier already renders.
+ */
+export function recognitionDescriptionFromContent(content: string): string {
+  const trimmed = content.trim();
+  if (trimmed.length === 0) return "";
+  const newline = trimmed.indexOf("\n");
+  return newline === -1 ? trimmed : trimmed.slice(0, newline).trimEnd();
+}
+
+function withIndexChain<T>(indexPath: string, op: () => Promise<T>): Promise<T> {
+  const previous = writeChains.get(indexPath) ?? Promise.resolve();
+  const run = previous.then(op, op);
+  const tail = run.then(() => undefined, () => undefined);
+  writeChains.set(indexPath, tail);
+  void tail.then(() => {
+    if (writeChains.get(indexPath) === tail) writeChains.delete(indexPath);
+  });
+  return run;
+}
+
+async function removeAbandonedRecognitionLock(
+  lockDir: string,
+): Promise<"removed" | "wait" | "blocked"> {
+  try {
+    const info = await fsp.lstat(lockDir);
+    if (info.isSymbolicLink()) return "blocked";
+    if (!info.isDirectory()) {
+      await fsp.rm(lockDir, { force: true });
+      return "removed";
+    }
+    if (Date.now() - info.mtimeMs < LOCK_STALE_MS) return "wait";
+    await fsp.rm(lockDir, { recursive: true, force: true });
+    return "removed";
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code === "ENOENT") return "removed";
+    return "blocked";
+  }
+}
+
+async function withRecognitionIndexLock<T>(memoryDir: string, op: () => Promise<T>): Promise<T> {
+  const lockDir = `${recognitionIndexPath(memoryDir)}.lock.d`;
+  for (let attempt = 0; attempt < LOCK_ATTEMPTS; attempt++) {
+    try {
+      await fsp.mkdir(lockDir);
+      try {
+        return await op();
+      } finally {
+        await fsp.rm(lockDir, { recursive: true, force: true }).catch(() => undefined);
+      }
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException)?.code;
+      if (code === "ENOENT") {
+        await fsp.mkdir(path.dirname(lockDir), { recursive: true }).catch(() => undefined);
+        continue;
+      }
+      if (code !== "EEXIST") throw error;
+      const cleanup = await removeAbandonedRecognitionLock(lockDir);
+      if (cleanup === "blocked") {
+        throw new Error(`recognition index lock blocked at ${lockDir}`);
+      }
+      if (cleanup === "removed") continue;
+      await delay(LOCK_POLL_MS);
+    }
+  }
+  throw new Error(`recognition index lock timed out at ${lockDir}`);
+}
+
+function applyChanges(
+  entries: readonly RecognitionIndexEntry[],
+  changes: readonly RecognitionIndexChange[],
+): RecognitionIndexEntry[] {
+  const next = entries.map((entry) => ({ id: entry.id, description: entry.description }));
+  const byId = new Map(next.map((entry, index) => [entry.id, index]));
+  for (const change of changes) {
+    const id = change.id.trim();
+    if (id.length === 0) continue;
+    if (change.action === "remove") {
+      const index = byId.get(id);
+      if (index === undefined) continue;
+      next.splice(index, 1);
+      byId.delete(id);
+      for (const [key, value] of byId) {
+        if (value > index) byId.set(key, value - 1);
+      }
+      continue;
+    }
+    const description = recognitionDescriptionFromContent(change.content);
+    const existing = byId.get(id);
+    if (existing !== undefined) {
+      next[existing] = { id, description };
+    } else {
+      byId.set(id, next.length);
+      next.push({ id, description });
+    }
+  }
+  return next;
+}
+
+function meaningfulChanges(changes: readonly RecognitionIndexChange[]): RecognitionIndexChange[] {
+  return changes.filter((change) => change.id.trim().length > 0);
+}
+
+/**
+ * Incrementally maintain a namespace recognition index after memory writes.
+ * `enabled: false` is a proven no-op: no reads, no writes, no locks.
+ */
+export async function maintainRecognitionIndexAfterWrite(args: {
+  memoryDir: string;
+  enabled: boolean;
+  changes: readonly RecognitionIndexChange[];
+}): Promise<void> {
+  if (args.enabled !== true) return;
+  const changes = meaningfulChanges(args.changes);
+  if (changes.length === 0) return;
+
+  const indexPath = recognitionIndexPath(args.memoryDir);
+  await withIndexChain(indexPath, () =>
+    withRecognitionIndexLock(args.memoryDir, async () => {
+      const loaded = await loadRecognitionIndex(args.memoryDir);
+      // `changes` is the full set the caller wants published. Persist-path
+      // bootstraps from the active corpus when the file is absent so a
+      // first post-enable write cannot mint a 1-id index that recall would
+      // treat as authoritative.
+      const entries = applyChanges(loaded?.entries ?? [], changes);
+      await saveRecognitionIndex(args.memoryDir, buildRecognitionIndex(entries));
+    }),
+  );
+}

package/src/procedural/procedure-miner.ts

@@ -4,14 +4,11 @@
 
 import type { PluginConfig } from "../types.js";
 import type { StorageManager } from "../storage.js";
-import type { CausalTrajectoryRecord } from "../causal-trajectory.js";
 import { createHash } from "node:crypto";
 import { mkdir, rm, stat } from "node:fs/promises";
 import path from "node:path";
-import {
-  readCausalTrajectoryRecords,
-  filterTrajectoriesByLookbackDays,
-} from "../causal-trajectory.js";
+import { readCausalTrajectoryRecords, type CausalTrajectoryRecord } from "../causal-trajectory.js";
+import { collectProcedureMiningRecords } from "../experience/session-experience-mining.js";
 import { buildProcedurePersistBody, normalizeProcedureSteps, type ProcedureStep } from "./procedure-types.js";
 import { clusterByKey } from "./reinforcement-core.js";
 import { log } from "../logger.js";
@@ -207,7 +204,12 @@ export async function runProcedureMining(options: {
     memoryDir: options.memoryDir,
     causalTrajectoryStoreDir: trajectoryDir,
   });
-  const recent = filterTrajectoriesByLookbackDays(trajectories, cfg.lookbackDays);
+  const recent = await collectProcedureMiningRecords({
+    trajectories,
+    lookbackDays: cfg.lookbackDays,
+    storage: options.storage,
+    experienceEnabled: options.config.sessionExperience?.enabled === true,
+  });
 
   const clusters = clusterByKey(recent, clusterKey);
 

package/src/testing/subjects/recall-recognition-index.test.ts

@@ -0,0 +1,97 @@
+/**
+ * Recognition-index write-path subject for the scenario-matrix harness
+ * (issue #2975).
+ *
+ * Every canonical row drives the real maintainRecognitionIndexAfterWrite
+ * seam twice: gate off (zero index I/O, no index file) and gate on
+ * (the write's id is visible to loadRecognitionIndex). Restart rows
+ * reload from disk; replay rows prove an id upsert is idempotent.
+ */
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { promises as fsp } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+
+import { loadRecognitionIndex, recognitionIndexPath } from "../../recall-recognition-tier.js";
+import { maintainRecognitionIndexAfterWrite } from "../../orchestration/recall-recognition-index.js";
+import { type LifecycleSubject, type MatrixRow, runLifecycleMatrix } from "../lifecycle-matrix.js";
+
+interface IndexState {
+  rowId: string;
+  dir: string;
+  restart: boolean;
+  dedupeOrReplay: boolean;
+}
+
+const subject: LifecycleSubject<IndexState> = {
+  async setup(row: MatrixRow): Promise<IndexState> {
+    const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-recognition-index-subject-"));
+    return {
+      rowId: String(row.id),
+      dir,
+      restart: row.dimensions.restart,
+      dedupeOrReplay: row.dimensions.dedupeOrReplay,
+    };
+  },
+
+  async exercise(state): Promise<void> {
+    const id = `fact-${state.rowId}`;
+    await maintainRecognitionIndexAfterWrite({
+      memoryDir: state.dir,
+      enabled: false,
+      changes: [{ action: "upsert", id, content: `off-path body for ${state.rowId}` }],
+    });
+    assert.equal(await loadRecognitionIndex(state.dir), null);
+    try {
+      await fsp.access(recognitionIndexPath(state.dir));
+      assert.fail("off-path must not create the recognition index file");
+    } catch (err) {
+      assert.equal((err as NodeJS.ErrnoException).code, "ENOENT");
+    }
+
+    await maintainRecognitionIndexAfterWrite({
+      memoryDir: state.dir,
+      enabled: true,
+      changes: [{ action: "upsert", id, content: `SSD inference chips — ${state.rowId}\nbody` }],
+    });
+    if (state.dedupeOrReplay) {
+      await maintainRecognitionIndexAfterWrite({
+        memoryDir: state.dir,
+        enabled: true,
+        changes: [{ action: "upsert", id, content: `SSD inference chips — ${state.rowId} replayed\nbody` }],
+      });
+    }
+  },
+
+  async invariants(state): Promise<void> {
+    const id = `fact-${state.rowId}`;
+    const index = await loadRecognitionIndex(state.dir);
+    assert.ok(index, "enabled write must persist an index loadable after the row");
+    assert.equal(index.entries.length, 1);
+    assert.equal(index.entries[0]?.id, id);
+    const expected = state.dedupeOrReplay
+      ? `SSD inference chips — ${state.rowId} replayed`
+      : `SSD inference chips — ${state.rowId}`;
+    assert.equal(index.entries[0]?.description, expected);
+
+    if (state.restart) {
+      const reloaded = await loadRecognitionIndex(state.dir);
+      assert.deepEqual(reloaded, index, "restart must see the same on-disk index");
+    }
+
+    const before = { ...index };
+    await maintainRecognitionIndexAfterWrite({
+      memoryDir: state.dir,
+      enabled: false,
+      changes: [{ action: "remove", id }],
+    });
+    assert.deepEqual(await loadRecognitionIndex(state.dir), before, "off-path after on-path must not mutate the index");
+  },
+
+  async teardown(state): Promise<void> {
+    await rm(state.dir, { recursive: true, force: true });
+  },
+};
+
+runLifecycleMatrix("recall-recognition-index", subject);

package/dist/chunk-72AV2H3R.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/directory-sidecars.ts"],"sourcesContent":["/**\n * @remnic/core — per-directory abstract/overview sidecars (issue #2977).\n *\n * One derived `overview.md` per memory directory (category roots and every\n * directory beneath them, including `namespaces/<ns>/` subtrees), rendered\n * bottom-up from existing memory content:\n *\n *   - the ABSTRACT is a single line (<=256 chars) composed from child titles;\n *   - the OVERVIEW body lists one preview line per child memory and embeds\n *     each child DIRECTORY's abstract, so a parent summarizes its subtree\n *     without embedding full child overviews.\n *\n * Determinism: no LLM, no embeddings. Content is assembled with the same\n * preview machinery the OKF index files use (`normalizeProjectionPreview`).\n *\n * Invalidation: each sidecar stores a content-free fingerprint of its subtree\n * (child name|size|mtime for files, recursive fingerprints for child dirs).\n * Any add/edit/delete anywhere below a directory changes its fingerprint, so\n * `loadDirectorySidecar` can detect staleness with `readdir`+`stat` alone and\n * refresh without reading child memory files first. Eager regeneration runs\n * through {@link runDirectorySidecarMaintenance}; lazy refresh on read covers\n * direct-write paths that bypass scheduled maintenance (Gotcha #43).\n *\n * Isolation: sidecars are derived artifacts, excluded from generic recall via\n * `isGenericRecallExcludedPath` (basename match, the same tradeoff OKF makes\n * for `index.md`/`log.md`) while staying full-text searchable. Files at the\n * sidecar path WITHOUT the marker are user content: never overwritten, never\n * removed.\n *\n * Layer 2 (this slice): {@link refreshDirectorySidecarsAfterWrite} refreshes\n * only the changed directory and its category ancestors, so a memory write\n * populates sidecars without walking the rest of the store. `enabled: false`\n * is a proven no-op (no reads, no writes). Config parsing lives here;\n * `parseConfig` wiring, retrieval drill-down, xray, and LLM summarization\n * remain later layers on #2977 (`config.ts` is at its file-size ratchet).\n */\n\nimport { createHash } from \"node:crypto\";\nimport { lstatSync, readFileSync, readdirSync, statSync, unlinkSync } from \"node:fs\";\nimport path from \"node:path\";\n\nimport { coerceBooleanLike } from \"./connectors/coerce.js\";\nimport { writeFileAtomically } from \"./maintenance/atomic-file.js\";\nimport { normalizeProjectionPreview } from \"./memory-projection-format.js\";\nimport { OKF_RESERVED_BASENAMES } from \"./okf/type-mapping.js\";\nimport { RECALL_FALLBACK_DIRS } from \"./utils/category-dir.js\";\n\nexport const DIRECTORY_SIDECAR_BASENAME = \"overview.md\";\nexport const DIRECTORY_SIDECAR_MARKER = \"<!-- remnic-directory-sidecar -->\";\n\nconst ABSTRACT_MAX_CHARS = 256;\nconst OVERVIEW_MAX_CHARS = 4000;\nconst DEFAULT_QUERY_LIMIT = 5;\nconst CATEGORY_ROOTS: ReadonlySet<string> = new Set(RECALL_FALLBACK_DIRS);\n\n/** Config fields this slice owns. Mix into `PluginConfig` in a later layer. */\nexport interface DirectorySidecarSettings {\n  /** Populate sidecars on memory writes. Default false. */\n  directorySidecarsEnabled: boolean;\n}\n\n/** Strict off-default: only an explicit true/\"true\"/1 opts in. */\nexport function parseDirectorySidecarsEnabled(raw: unknown): boolean {\n  return coerceBooleanLike(raw, \"directorySidecarsEnabled\") === true;\n}\n\n/** Basenames never treated as child memories (ours plus OKF's reserved ones). */\nconst RESERVED_CHILD_BASENAMES: Readonly<Record<string, true>> = Object.freeze({\n  ...OKF_RESERVED_BASENAMES,\n  [DIRECTORY_SIDECAR_BASENAME]: true,\n});\n\nexport interface DirectorySidecar {\n  /** Absolute directory the sidecar describes. */\n  readonly dir: string;\n  /** Single-line L0 abstract (<=256 chars). */\n  readonly abstract: string;\n  /** Abstract plus the per-child preview body (<=4000 chars). */\n  readonly overview: string;\n  /** Number of memory `.md` children in this directory. */\n  readonly childCount: number;\n  /** False when the stored fingerprint no longer matches the subtree. */\n  readonly fresh: boolean;\n}\n\nexport interface DirectorySidecarMatch extends DirectorySidecar {\n  readonly score: number;\n}\n\nexport interface DirectorySidecarReport {\n  written: string[];\n  removed: string[];\n}\n\ninterface ParsedSidecar {\n  abstract: string;\n  overview: string;\n  childCount: number;\n  fingerprint: string;\n}\n\nfunction listEntries(dir: string) {\n  try {\n    return readdirSync(dir, { withFileTypes: true });\n  } catch {\n    return [];\n  }\n}\n\n/** Root check that refuses symlinks (fs-boundary rule, PRs #1938/#1999). */\nfunction isRealDirectory(entryPath: string): boolean {\n  try {\n    const stats = lstatSync(entryPath);\n    return !stats.isSymbolicLink() && stats.isDirectory();\n  } catch {\n    return false;\n  }\n}\n\nfunction memoryChildren(dir: string): string[] {\n  // Dirent.isFile() is false for symlinks, so a linked memory never enters the corpus.\n  return listEntries(dir)\n    .filter((entry) => entry.isFile() && !RESERVED_CHILD_BASENAMES[entry.name] && entry.name.endsWith(\".md\"))\n    .map((entry) => entry.name)\n    .sort((a, b) => a.localeCompare(b));\n}\n\nfunction directoryChildren(dir: string): string[] {\n  // Dirent.isDirectory() is false for symlinks (fs-boundary rule, PRs #1938/#1999).\n  return listEntries(dir)\n    .filter((entry) => entry.isDirectory())\n    .map((entry) => entry.name)\n    .sort((a, b) => a.localeCompare(b));\n}\n\n/**\n * Content-free subtree fingerprint: sha256 over sorted child descriptors.\n * Files contribute `name|size|mtimeMs`; directories contribute their own\n * recursive fingerprint, so any change below a directory invalidates every\n * ancestor. Reads no file contents.\n */\nexport function directoryFingerprint(dir: string): string {\n  const hash = createHash(\"sha256\");\n  for (const name of memoryChildren(dir)) {\n    try {\n      const stats = statSync(path.join(dir, name));\n      hash.update(`f|${name}|${stats.size}|${Math.trunc(stats.mtimeMs)}\\n`);\n    } catch {\n      hash.update(`f|${name}|missing\\n`);\n    }\n  }\n  for (const name of directoryChildren(dir)) {\n    hash.update(`d|${name}|${directoryFingerprint(path.join(dir, name))}\\n`);\n  }\n  return hash.digest(\"hex\");\n}\n\nfunction readFileOrNull(target: string): string | null {\n  try {\n    return readFileSync(target, \"utf8\");\n  } catch {\n    return null;\n  }\n}\n\nfunction parseSidecar(content: string): ParsedSidecar | null {\n  if (!content.startsWith(DIRECTORY_SIDECAR_MARKER)) return null;\n  const fingerprint = /^fingerprint: ([0-9a-f]{64})$/m.exec(content)?.[1];\n  if (!fingerprint) return null;\n  const abstract = /^## Abstract\\n([^\\n]+)$/m.exec(content)?.[1] ?? \"\";\n  const overviewStart = content.indexOf(\"## Abstract\");\n  const overview =\n    overviewStart === -1 ? \"\" : content.slice(overviewStart, overviewStart + OVERVIEW_MAX_CHARS).trim();\n  // The `* name — preview` child bullets are the rendered child count.\n  const childCount = (content.match(/^\\* .+$/gm) ?? []).length;\n  return { abstract, overview, childCount, fingerprint };\n}\n\nfunction sidecarPath(dir: string): string {\n  return path.join(dir, DIRECTORY_SIDECAR_BASENAME);\n}\n\nfunction renderSidecar(dir: string, fingerprint: string, childAbstracts: Map<string, string>): string | null {\n  const children = memoryChildren(dir);\n  const childDirs = directoryChildren(dir).filter((name) => childAbstracts.has(path.join(dir, name)));\n  if (children.length === 0 && childDirs.length === 0) return null;\n\n  const previews = children.map((name) => {\n    try {\n      return normalizeProjectionPreview(readFileSync(path.join(dir, name), \"utf8\"), 120);\n    } catch {\n      return \"\";\n    }\n  });\n  const titles = children.map(\n    (name, index) => previews[index].split(\" \").slice(0, 8).join(\" \") || name.replace(/\\.md$/, \"\"),\n  );\n  const abstract = normalizeProjectionPreview(\n    `${path.basename(dir)}/ — ${children.length} memories: ${titles.slice(0, 5).join(\" · \")}`,\n    ABSTRACT_MAX_CHARS,\n  );\n\n  const lines = [\n    DIRECTORY_SIDECAR_MARKER,\n    `fingerprint: ${fingerprint}`,\n    `# ${path.basename(dir)}/ overview`,\n    \"\",\n    \"## Abstract\",\n    abstract,\n    \"\",\n    \"## Children\",\n  ];\n  for (const [index, name] of children.entries()) {\n    lines.push(`* ${name} — ${previews[index]}`);\n  }\n  for (const name of childDirs) {\n    lines.push(`### ${name}/`);\n    lines.push(childAbstracts.get(path.join(dir, name)) ?? \"\");\n  }\n  lines.push(\"\");\n  return lines.join(\"\\n\");\n}\n\n/** Scope roots whose category subtrees carry sidecars: the memory root plus every namespace root. */\nfunction scopeRoots(memoryDir: string): string[] {\n  const roots = [memoryDir];\n  const namespacesRoot = path.join(memoryDir, \"namespaces\");\n  for (const entry of listEntries(namespacesRoot)) {\n    if (entry.isDirectory() && isRealDirectory(path.join(namespacesRoot, entry.name))) {\n      roots.push(path.join(namespacesRoot, entry.name));\n    }\n  }\n  return roots;\n}\n\n/**\n * Every directory that should carry a sidecar, deepest first (post-order) so\n * parents render after their children and can embed child abstracts.\n */\nfunction collectSidecarDirs(scopeRoot: string): string[] {\n  const dirs: string[] = [];\n  const walk = (dir: string, isCategoryRoot: boolean): boolean => {\n    let carries = memoryChildren(dir).length > 0;\n    for (const name of directoryChildren(dir)) {\n      carries = walk(path.join(dir, name), false) || carries;\n    }\n    // A directory that stopped carrying memories must still be visited so its\n    // orphaned sidecar can be pruned or rewritten (cache-invalidation completeness).\n    const hasSidecar = readFileOrNull(sidecarPath(dir))?.startsWith(DIRECTORY_SIDECAR_MARKER) === true;\n    if (isCategoryRoot || carries || hasSidecar) dirs.push(dir);\n    return carries;\n  };\n  for (const category of RECALL_FALLBACK_DIRS) {\n    const categoryDir = path.join(scopeRoot, category);\n    if (!isRealDirectory(categoryDir)) continue;\n    walk(categoryDir, true);\n  }\n  return dirs;\n}\n\nasync function syncSidecarDir(\n  dir: string,\n  enabled: boolean,\n  childAbstracts: Map<string, string>,\n  written: string[],\n  removed: string[],\n): Promise<void> {\n  const target = sidecarPath(dir);\n  const raw = readFileOrNull(target);\n  const existing = raw !== null && raw.startsWith(DIRECTORY_SIDECAR_MARKER) ? raw : null;\n  if (!enabled) {\n    if (existing !== null) {\n      unlinkSync(target);\n      removed.push(target);\n    }\n    return;\n  }\n  const next = renderSidecar(dir, directoryFingerprint(dir), childAbstracts);\n  if (next === null) {\n    if (existing !== null) {\n      unlinkSync(target);\n      removed.push(target);\n    }\n    return;\n  }\n  const parsedNext = parseSidecar(next);\n  if (parsedNext) childAbstracts.set(dir, parsedNext.abstract);\n  if (raw === next) return;\n  if (existing === null && raw !== null) return; // user-authored file: hands off\n  await writeFileAtomically(target, next);\n  written.push(target);\n}\n\nfunction childAbstractsFromDisk(dir: string): Map<string, string> {\n  const abstracts = new Map<string, string>();\n  for (const name of directoryChildren(dir)) {\n    const childDir = path.join(dir, name);\n    const parsed = parseSidecar(readFileOrNull(sidecarPath(childDir)) ?? \"\");\n    if (parsed) abstracts.set(childDir, parsed.abstract);\n  }\n  return abstracts;\n}\n\n/**\n * Category-root ancestry of a changed memory path, deepest first.\n * Paths outside a recall category return `[]` so writes to `state/` or\n * `namespaces/<ns>/` itself never mint a sidecar.\n */\nexport function directorySidecarAncestry(memoryDir: string, changedPath: string): string[] {\n  const root = path.resolve(memoryDir);\n  const abs = path.isAbsolute(changedPath) ? path.resolve(changedPath) : path.resolve(root, changedPath);\n  const rel = path.relative(root, abs);\n  if (rel.startsWith(\"..\") || path.isAbsolute(rel)) return [];\n  const parts = rel.split(path.sep).filter(Boolean);\n  const dirParts = isRealDirectory(abs) ? parts : parts.slice(0, -1);\n  let categoryAt = -1;\n  if (dirParts[0] === \"namespaces\" && dirParts.length >= 3 && CATEGORY_ROOTS.has(dirParts[2] ?? \"\")) {\n    categoryAt = 2;\n  } else if (CATEGORY_ROOTS.has(dirParts[0] ?? \"\")) {\n    categoryAt = 0;\n  }\n  if (categoryAt === -1) return [];\n  const dirs: string[] = [];\n  for (let i = dirParts.length; i > categoryAt; i--) {\n    dirs.push(path.join(root, ...dirParts.slice(0, i)));\n  }\n  return dirs;\n}\n\n/**\n * Regenerates directory sidecars incrementally. Unchanged sidecars are left\n * untouched; emptied directories lose theirs; user files at the sidecar path\n * (no marker) are never written or removed. With `enabled: false` every\n * generated sidecar is removed — the OKF index-maintenance contract.\n */\nexport async function runDirectorySidecarMaintenance(\n  memoryDir: string,\n  enabled: boolean,\n): Promise<DirectorySidecarReport> {\n  const written: string[] = [];\n  const removed: string[] = [];\n  for (const scope of scopeRoots(memoryDir)) {\n    const childAbstracts = new Map<string, string>();\n    for (const dir of collectSidecarDirs(scope)) {\n      await syncSidecarDir(dir, enabled, childAbstracts, written, removed);\n    }\n  }\n  return { written, removed };\n}\n\n/**\n * Incremental write-path refresh: only the changed directory and its\n * category ancestors, using the same fingerprint/render path as maintenance.\n * `enabled: false` returns immediately — no readdir, no writes.\n */\nexport async function refreshDirectorySidecarsAfterWrite(\n  memoryDir: string,\n  changedPath: string,\n  enabled: boolean,\n): Promise<DirectorySidecarReport> {\n  if (!enabled) return { written: [], removed: [] };\n  const written: string[] = [];\n  const removed: string[] = [];\n  for (const dir of directorySidecarAncestry(memoryDir, changedPath)) {\n    await syncSidecarDir(dir, true, childAbstractsFromDisk(dir), written, removed);\n  }\n  return { written, removed };\n}\n\n/**\n * Read a directory's sidecar for retrieval. By default a stale sidecar is\n * refreshed in place (child directories first), which is what makes direct\n * writes that bypass maintenance still converge. With `{ refresh: false }`\n * the stored sidecar is returned as-is with `fresh: false` so callers can\n * observe staleness without writes.\n */\nexport async function loadDirectorySidecar(\n  dir: string,\n  options: { refresh?: boolean } = {},\n): Promise<DirectorySidecar | null> {\n  const refresh = options.refresh !== false;\n  const target = sidecarPath(dir);\n  const stored = readFileOrNull(target);\n  const generated = stored !== null && stored.startsWith(DIRECTORY_SIDECAR_MARKER);\n  const parsed = generated ? parseSidecar(stored) : null;\n  const fingerprint = directoryFingerprint(dir);\n  if (parsed !== null && (parsed.fingerprint === fingerprint || !refresh)) {\n    return {\n      dir,\n      abstract: parsed.abstract,\n      overview: parsed.overview,\n      childCount: parsed.childCount,\n      fresh: parsed.fingerprint === fingerprint,\n    };\n  }\n  if (!refresh) return null;\n\n  // Refresh bottom-up so this directory's body embeds current child abstracts.\n  const childAbstracts = new Map<string, string>();\n  for (const name of directoryChildren(dir)) {\n    const child = await loadDirectorySidecar(path.join(dir, name));\n    if (child) childAbstracts.set(path.join(dir, name), child.abstract);\n  }\n  const next = renderSidecar(dir, directoryFingerprint(dir), childAbstracts);\n  if (next === null) {\n    if (generated) unlinkSync(target);\n    return null;\n  }\n  if (readFileOrNull(target) !== next) {\n    if (stored !== null && !generated) {\n      // User-authored file at the sidecar path: serve nothing rather than clobber it.\n      return null;\n    }\n    await writeFileAtomically(target, next);\n  }\n  const refreshed = parseSidecar(next);\n  return refreshed\n    ? {\n        dir,\n        abstract: refreshed.abstract,\n        overview: refreshed.overview,\n        childCount: refreshed.childCount,\n        fresh: true,\n      }\n    : null;\n}\n\n/**\n * Overview-query primitive for hierarchical retrieval (layer 1 of #2977):\n * score every sidecar's abstract (+3 per query term) and overview (+1 per\n * term) lexically, then return the most specific matches — when both a\n * directory and its descendant match, only the descendant is kept, matching\n * the drill-down semantics the full retrieval mode will build on.\n */\nexport async function findDirectorySidecarsForQuery(\n  memoryDir: string,\n  query: string,\n  options: { namespace?: string; limit?: number } = {},\n): Promise<DirectorySidecarMatch[]> {\n  const scope = options.namespace ? path.join(memoryDir, \"namespaces\", options.namespace) : memoryDir;\n  if (!isRealDirectory(scope)) return [];\n  const terms = query\n    .toLowerCase()\n    .split(/[^a-z0-9]+/)\n    .filter((term) => term.length >= 2);\n\n  const matches: DirectorySidecarMatch[] = [];\n  for (const root of scopeRoots(scope)) {\n    for (const dir of collectSidecarDirs(root)) {\n      const sidecar = await loadDirectorySidecar(dir);\n      if (!sidecar) continue;\n      const abstractLower = sidecar.abstract.toLowerCase();\n      const overviewLower = sidecar.overview.toLowerCase();\n      let score = 0;\n      for (const term of terms) {\n        if (abstractLower.includes(term)) score += 3;\n        else if (overviewLower.includes(term)) score += 1;\n      }\n      if (score > 0) matches.push({ ...sidecar, score });\n    }\n  }\n  matches.sort((a, b) => b.score - a.score || a.dir.localeCompare(b.dir));\n\n  const limit = options.limit ?? DEFAULT_QUERY_LIMIT;\n  return matches\n    .filter((candidate) => !matches.some((other) => other.dir.startsWith(`${candidate.dir}${path.sep}`)))\n    .slice(0, limit);\n}\n"],"mappings":"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","names":[]}