@agent_memory/dsh 0.4.0 → 0.5.0

package/dist/plugin.mjs

@@ -104,6 +104,9 @@ function memoryPaths(home) {
     manifestFile: join(home, ".index", "manifest.json"),
     stateDir: join(home, ".state"),
     journalDir: join(home, ".state", "journal"),
+    journalArchiveDir: join(home, ".state", "journal", "archive"),
+    checkpointFile: join(home, ".state", "checkpoint.json"),
+    checkpointKeyFile: join(home, ".state", "checkpoint.key"),
     txnDir: join(home, ".state", "txn"),
     snapshotsDir: join(home, ".state", "snapshots")
   };
@@ -1145,17 +1148,17 @@ function loadPolicy(options) {
     hint: "a human must review it and run `mem policy seal --accept`"
   });
   const seal2 = parseSeal(sealText, paths.sealFile);
-  const sha256 = hashBytes(policyText);
-  if (seal2.sha256 !== sha256) {
+  const sha2562 = hashBytes(policyText);
+  if (seal2.sha256 !== sha2562) {
     throw new StartupError("POLICY_MISMATCH", "policy.json does not match its sealed hash", {
       sourcePath: paths.policyFile,
-      details: [`sealed sha256 ${seal2.sha256}`, `actual sha256 ${sha256}`],
+      details: [`sealed sha256 ${seal2.sha256}`, `actual sha256 ${sha2562}`],
       hint: "the policy is immutable at runtime; after a deliberate human edit run `mem policy seal --accept`"
     });
   }
   const { policy, problems } = parsePolicyText(policyText);
   if (problems.length > 0) throw policyProblems(paths.policyFile, problems);
-  return { policy, sha256, sealedAt: seal2.sealed_at, policyPath: paths.policyFile, sealPath: paths.sealFile };
+  return { policy, sha256: sha2562, sealedAt: seal2.sealed_at, policyPath: paths.policyFile, sealPath: paths.sealFile };
 }
 function sealPolicy(options) {
   const paths = memoryPaths(options.home);
@@ -1182,9 +1185,9 @@ function sealPolicy(options) {
 `;
   writeFileAtomic(paths.policyFile, nextText);
   const previous = tryReadSeal(paths.sealFile);
-  const sha256 = hashBytes(nextText);
-  writeSeal(paths.sealFile, { policy: "policy.json", sha256, sealed_at: (options.now ?? /* @__PURE__ */ new Date()).toISOString() });
-  return { sealPath: paths.sealFile, sha256, previousSha256: previous?.sha256 ?? null, sealedFiles };
+  const sha2562 = hashBytes(nextText);
+  writeSeal(paths.sealFile, { policy: "policy.json", sha256: sha2562, sealed_at: (options.now ?? /* @__PURE__ */ new Date()).toISOString() });
+  return { sealPath: paths.sealFile, sha256: sha2562, previousSha256: previous?.sha256 ?? null, sealedFiles };
 }
 function writeSeal(sealPath, record) {
   writeFileAtomic(sealPath, `${JSON.stringify(record, null, 2)}
@@ -1216,15 +1219,15 @@ function parseSeal(text, sealPath) {
       details: unknown.map((key) => `unknown key "${key}"`)
     });
   }
-  const sha256 = record.sha256;
-  if (typeof record.policy !== "string" || typeof sha256 !== "string" || !/^[0-9a-f]{64}$/.test(sha256)) {
+  const sha2562 = record.sha256;
+  if (typeof record.policy !== "string" || typeof sha2562 !== "string" || !/^[0-9a-f]{64}$/.test(sha2562)) {
     throw new StartupError("POLICY_INVALID", "the policy seal file is malformed", {
       sourcePath: sealPath,
       details: ['expected { "policy": string, "sha256": <64 hex chars>, "sealed_at": string }']
     });
   }
   const sealedAt = typeof record.sealed_at === "string" ? record.sealed_at : "";
-  return { policy: record.policy, sha256, sealed_at: sealedAt };
+  return { policy: record.policy, sha256: sha2562, sealed_at: sealedAt };
 }
 function tryReadSeal(sealPath) {
   let text;
@@ -1428,9 +1431,114 @@ function deleteProject(home, name2) {
   return true;
 }
 
+// packages/core/src/journal/checkpoint.ts
+import { createHash as createHash3, createHmac, randomBytes as randomBytes2, timingSafeEqual } from "node:crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+var CHECKPOINT_SCHEMA = 1;
+function sha256(text) {
+  return createHash3("sha256").update(text, "utf8").digest("hex");
+}
+function merkleRoot(leaves) {
+  if (leaves.length === 0) return sha256("");
+  let level = leaves.map((leaf) => sha256(leaf));
+  while (level.length > 1) {
+    const next = [];
+    for (let index = 0; index < level.length; index += 2) {
+      const left = level[index];
+      const right = level[index + 1];
+      next.push(right === void 0 ? left : sha256(`${left}${right}`));
+    }
+    level = next;
+  }
+  return level[0];
+}
+function docsRoot(docs) {
+  return merkleRoot(docs.map((doc) => `${doc.id}:${doc.sha256}:${doc.deleted ? "1" : "0"}`).sort());
+}
+function readKey(home) {
+  const file = memoryPaths(home).checkpointKeyFile;
+  if (!existsSync4(file)) return void 0;
+  const key = readFileSync4(file);
+  if (key.length !== 32) throw new Error("checkpoint key must be 32 bytes");
+  return key;
+}
+function checkpointKey(home) {
+  const existing = readKey(home);
+  if (existing !== void 0) return existing;
+  const file = memoryPaths(home).checkpointKeyFile;
+  const key = randomBytes2(32);
+  try {
+    writeFileSync2(file, key, { flag: "wx", mode: 384 });
+    return key;
+  } catch {
+    const raced = readKey(home);
+    if (raced !== void 0) return raced;
+    throw new Error("checkpoint key is unreadable");
+  }
+}
+function canonical(checkpoint) {
+  return JSON.stringify({
+    schema: checkpoint.schema,
+    created_at: checkpoint.created_at,
+    journal: checkpoint.journal,
+    docs: checkpoint.docs,
+    journal_root: checkpoint.journal_root,
+    docs_root: checkpoint.docs_root
+  });
+}
+function writeCheckpoint(home, input) {
+  const docs = input.docs.slice().sort((left, right) => left.id.localeCompare(right.id));
+  const body = {
+    schema: CHECKPOINT_SCHEMA,
+    created_at: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    journal: input.journal,
+    docs,
+    journal_root: input.journalRoot,
+    docs_root: docsRoot(docs)
+  };
+  const hmac = createHmac("sha256", checkpointKey(home)).update(canonical(body), "utf8").digest("hex");
+  const checkpoint = { ...body, hmac };
+  writeFileAtomic(memoryPaths(home).checkpointFile, `${JSON.stringify(checkpoint, null, 2)}
+`);
+  return checkpoint;
+}
+function readCheckpoint(home) {
+  const file = memoryPaths(home).checkpointFile;
+  if (!existsSync4(file)) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync4(file, "utf8"));
+  } catch {
+    return { error: "checkpoint is not valid JSON" };
+  }
+  if (parsed.schema !== CHECKPOINT_SCHEMA) return { error: `unsupported checkpoint schema ${String(parsed.schema)}` };
+  if (typeof parsed.hmac !== "string" || parsed.hmac === "") return { error: "checkpoint has no HMAC" };
+  if (docsRoot(parsed.docs) !== parsed.docs_root) return { error: "checkpoint docs root mismatch" };
+  let key;
+  try {
+    const found = readKey(home);
+    if (found === void 0) return { error: "checkpoint key is missing (restore .state/checkpoint.key or remove checkpoint)" };
+    key = found;
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+  const expected = createHmac("sha256", key).update(canonical({
+    schema: parsed.schema,
+    created_at: parsed.created_at,
+    journal: parsed.journal,
+    docs: parsed.docs,
+    journal_root: parsed.journal_root,
+    docs_root: parsed.docs_root
+  }), "utf8").digest("hex");
+  const left = Buffer.from(expected, "hex");
+  const right = Buffer.from(parsed.hmac, "hex");
+  if (left.length !== right.length || !timingSafeEqual(left, right)) return { error: "checkpoint HMAC mismatch" };
+  return { checkpoint: parsed };
+}
+
 // packages/core/src/fs/lock.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
-import { closeSync as closeSync2, fsyncSync as fsyncSync2, openSync as openSync2, readFileSync as readFileSync4, statSync as statSync2, unlinkSync, writeFileSync as writeFileSync2, writeSync } from "node:fs";
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { closeSync as closeSync2, fsyncSync as fsyncSync2, openSync as openSync2, readFileSync as readFileSync5, statSync as statSync2, unlinkSync, writeFileSync as writeFileSync3, writeSync } from "node:fs";
 var LockError = class extends Error {
   code;
   constructor(code, message) {
@@ -1441,7 +1549,7 @@ var LockError = class extends Error {
 };
 function readLock(file) {
   try {
-    const raw = JSON.parse(readFileSync4(file, "utf8"));
+    const raw = JSON.parse(readFileSync5(file, "utf8"));
     if (typeof raw.pid === "number" && typeof raw.token === "string" && typeof raw.acquired_at === "number" && typeof raw.heartbeat_at === "number") {
       return { pid: raw.pid, token: raw.token, acquired_at: raw.acquired_at, heartbeat_at: raw.heartbeat_at };
     }
@@ -1518,7 +1626,7 @@ var FileLock = class {
 function acquireLock(options) {
   const now = options.now ?? Date.now;
   const deadline = now() + options.config.timeoutMs;
-  const token = randomBytes2(8).toString("hex");
+  const token = randomBytes3(8).toString("hex");
   for (; ; ) {
     const info = {
       pid: process.pid,
@@ -1558,7 +1666,7 @@ function acquireLock(options) {
 }
 
 // packages/core/src/model/ids.ts
-import { randomBytes as randomBytes3 } from "node:crypto";
+import { randomBytes as randomBytes4 } from "node:crypto";
 var ID_PATTERN = /^mem-\d{8}-[0-9a-f]{8}$/;
 function isMemoryId(value) {
   return ID_PATTERN.test(value);
@@ -1569,7 +1677,7 @@ function formatDate(date) {
   const day = String(date.getDate()).padStart(2, "0");
   return `${year}-${month}-${day}`;
 }
-function newMemoryId(now = /* @__PURE__ */ new Date(), bytes = () => randomBytes3(4)) {
+function newMemoryId(now = /* @__PURE__ */ new Date(), bytes = () => randomBytes4(4)) {
   return `mem-${formatDate(now).replaceAll("-", "")}-${bytes().toString("hex")}`;
 }
 
@@ -1661,13 +1769,26 @@ function supersedeProblems(candidate, docs) {
 }
 
 // packages/core/src/journal/journal.ts
-import { createHash as createHash3 } from "node:crypto";
-import { closeSync as closeSync3, fsyncSync as fsyncSync3, mkdirSync as mkdirSync2, openSync as openSync3, readFileSync as readFileSync5, readdirSync, statSync as statSync3, writeSync as writeSync2 } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { closeSync as closeSync3, existsSync as existsSync5, fsyncSync as fsyncSync3, mkdirSync as mkdirSync2, openSync as openSync3, readFileSync as readFileSync6, readdirSync, statSync as statSync3, writeSync as writeSync2 } from "node:fs";
 import { join as join3 } from "node:path";
 var SEGMENT_BYTES = 5 * 1024 * 1024;
 var ZERO_HASH = "0".repeat(64);
+function readArchiveIndex(dir) {
+  const file = join3(dir, "archive", "index.json");
+  if (!existsSync5(file)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync6(file, "utf8"));
+    if (parsed.schema !== 1 || typeof parsed.through_seq !== "number" || typeof parsed.through_hash !== "string") {
+      return void 0;
+    }
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
 function hashLine(line) {
-  return createHash3("sha256").update(line, "utf8").digest("hex");
+  return createHash4("sha256").update(line, "utf8").digest("hex");
 }
 var Journal = class {
   dir;
@@ -1686,7 +1807,7 @@ var Journal = class {
     const segments = this.segments();
     for (let index = segments.length - 1; index >= 0; index -= 1) {
       const file = join3(this.dir, segments[index]);
-      const lines = readFileSync5(file, "utf8").split("\n").filter((line) => line !== "");
+      const lines = readFileSync6(file, "utf8").split("\n").filter((line) => line !== "");
       if (lines.length === 0) continue;
       const last = lines[lines.length - 1];
       try {
@@ -1696,20 +1817,22 @@ var Journal = class {
         return null;
       }
     }
-    return null;
+    const archive = readArchiveIndex(this.dir);
+    return archive === void 0 ? null : { seq: archive.through_seq, hash: archive.through_hash };
   }
   readAll() {
     const entries = [];
     const hashes = [];
     const issues = [];
     const opIds = /* @__PURE__ */ new Set();
-    let expectedSeq = 1;
-    let prev = ZERO_HASH;
+    const archive = readArchiveIndex(this.dir);
+    let expectedSeq = archive === void 0 ? 1 : archive.through_seq + 1;
+    let prev = archive === void 0 ? ZERO_HASH : archive.through_hash;
     for (const name2 of this.segments()) {
       const file = join3(this.dir, name2);
       let text;
       try {
-        text = readFileSync5(file, "utf8");
+        text = readFileSync6(file, "utf8");
       } catch (error) {
         issues.push({ kind: "parse", message: `cannot read ${name2}: ${String(error)}` });
         continue;
@@ -1726,6 +1849,7 @@ var Journal = class {
           return { entries, hashes, issues, head: entries.length === 0 ? null : { seq: entries.length, hash: prev } };
         }
         const hash = hashLine(line);
+        if (archive !== void 0 && entry.seq < expectedSeq) continue;
         if (entry.seq !== expectedSeq) {
           issues.push({
             kind: "seq",
@@ -1750,7 +1874,92 @@ var Journal = class {
         prev = hash;
       }
     }
-    const head = entries.length === 0 ? null : { seq: entries[entries.length - 1]?.seq ?? 0, hash: prev };
+    const head = entries.length === 0 ? archive === void 0 ? null : { seq: archive.through_seq, hash: archive.through_hash } : { seq: entries[entries.length - 1]?.seq ?? 0, hash: prev };
+    return { entries, hashes, issues, head };
+  }
+  /** Cheap operational summary for `mem doctor` / metrics. */
+  stats() {
+    const segments = this.segments();
+    let lines = 0;
+    let bytes = 0;
+    let largest = 0;
+    let firstSeq = null;
+    let lastSeq = null;
+    for (const name2 of segments) {
+      const text = readFileSync6(join3(this.dir, name2), "utf8");
+      const size = Buffer.byteLength(text);
+      bytes += size;
+      largest = Math.max(largest, size);
+      const rows = text.split("\n").filter((line) => line !== "");
+      lines += rows.length;
+      if (firstSeq === null && rows.length > 0) {
+        try {
+          firstSeq = JSON.parse(rows[0]).seq ?? null;
+        } catch {
+          firstSeq = null;
+        }
+      }
+      if (rows.length > 0) {
+        try {
+          lastSeq = JSON.parse(rows[rows.length - 1]).seq ?? lastSeq;
+        } catch {
+        }
+      }
+    }
+    return { segments: segments.length, lines, bytes, first_seq: firstSeq, last_seq: lastSeq, largest_segment_bytes: largest };
+  }
+  /**
+   * Replay only entries after a checkpoint. Old lines are skipped without JSON
+   * parsing; the checkpoint's last line hash is the expected `prev`.
+   */
+  readAfter(afterSeq, prevHash, fromSegment) {
+    if (afterSeq === 0) return this.readAll();
+    const allSegments = this.segments();
+    const start = fromSegment === void 0 ? 0 : allSegments.indexOf(fromSegment);
+    const segments = start < 0 ? allSegments : allSegments.slice(start);
+    const entries = [];
+    const hashes = [];
+    const issues = [];
+    let expectedSeq = afterSeq + 1;
+    let prev = prevHash;
+    let seenTail = false;
+    for (const name2 of segments) {
+      const text = readFileSync6(join3(this.dir, name2), "utf8");
+      for (const line of text.split("\n")) {
+        if (line === "") continue;
+        const seqMatch = /^\{"seq":(\d+)/.exec(line);
+        if (seqMatch !== null && Number(seqMatch[1]) <= afterSeq) continue;
+        let entry;
+        try {
+          entry = JSON.parse(line);
+        } catch {
+          issues.push({ kind: "parse", message: `${name2}: line is not valid JSON`, seq: expectedSeq });
+          return { entries, hashes, issues, head: { seq: afterSeq, hash: prevHash } };
+        }
+        if (entry.seq !== expectedSeq) {
+          issues.push({
+            kind: "seq",
+            message: `${name2}: expected seq ${expectedSeq}, found ${entry.seq}`,
+            seq: entry.seq
+          });
+        }
+        if (entry.prev !== prev) {
+          issues.push({
+            kind: "chain",
+            message: `${name2}: seq ${entry.seq} prev does not match the checkpoint/previous line`,
+            seq: entry.seq
+          });
+        }
+        const hash = hashLine(line);
+        if (entry.seq < expectedSeq) continue;
+        entries.push(entry);
+        hashes.push(hash);
+        expectedSeq = entry.seq + 1;
+        prev = hash;
+        seenTail = true;
+      }
+    }
+    const head = seenTail ? { seq: expectedSeq - 1, hash: prev } : { seq: afterSeq, hash: prevHash };
     return { entries, hashes, issues, head };
   }
   findByOpId(opId) {
@@ -1802,10 +2011,64 @@ var Journal = class {
     }
     return entry;
   }
+  /**
+   * Append a batch with one fsync. Bulk import writes files first, then one
+   * journal batch makes the whole import durable. A torn final line is ignored
+   * by recovery just like a single torn append.
+   */
+  appendBatch(inputs) {
+    if (inputs.length === 0) return [];
+    mkdirSync2(this.dir, { recursive: true });
+    const segments = this.segments();
+    let segmentPath = join3(this.dir, segments[segments.length - 1] ?? "0001.jsonl");
+    let size = 0;
+    try {
+      size = statSync3(segmentPath).size;
+    } catch {
+      size = 0;
+    }
+    let head = this.head();
+    const entries = [];
+    let fd = openSync3(segmentPath, "a");
+    try {
+      for (const input of inputs) {
+        const seq = head === null ? 1 : head.seq + 1;
+        const prev = head === null ? ZERO_HASH : head.hash;
+        const entry = {
+          seq,
+          prev,
+          at: input.at ?? (/* @__PURE__ */ new Date()).toISOString(),
+          op: input.op,
+          op_id: input.opId ?? `op-${seq}-${hashLine(`${seq}:${input.op}:${JSON.stringify(input.data)}`).slice(0, 8)}`,
+          data: input.data
+        };
+        const line = JSON.stringify(entry);
+        if (size > 0 && size + Buffer.byteLength(line) + 1 > SEGMENT_BYTES) {
+          closeSync3(fd);
+          const baseName = segmentPath.split(/[\\/]/).pop();
+          const nextNumber = Number(baseName.slice(0, 4)) + 1;
+          segmentPath = join3(this.dir, `${String(nextNumber).padStart(4, "0")}.jsonl`);
+          fd = openSync3(segmentPath, "a");
+          size = 0;
+        }
+        writeSync2(fd, `${line}
+`);
+        size += Buffer.byteLength(line) + 1;
+        head = { seq, hash: hashLine(line) };
+        entries.push(entry);
+      }
+      fsyncSync3(fd);
+    } finally {
+      closeSync3(fd);
+    }
+    return entries;
+  }
 };
 
 // packages/core/src/store/store.ts
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync7, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync8, rmSync as rmSync3, statSync as statSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { gzipSync } from "node:zlib";
+import { createHash as createHash5 } from "node:crypto";
 import { join as join5 } from "node:path";
 
 // packages/core/src/index/tokenizer.ts
@@ -2011,7 +2274,7 @@ function fuseScores(lexical, vector, embeddingWeightPermille) {
 }
 
 // packages/core/src/embed/cache.ts
-import { mkdtempSync, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { mkdtempSync, readFileSync as readFileSync7, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join4 } from "node:path";
 import { spawn } from "node:child_process";
@@ -2021,7 +2284,7 @@ function embeddingsFile(home) {
 }
 function readEmbeddingCache(home) {
   try {
-    const parsed = JSON.parse(readFileSync6(embeddingsFile(home), "utf8"));
+    const parsed = JSON.parse(readFileSync7(embeddingsFile(home), "utf8"));
     if (parsed.schema !== CACHE_SCHEMA) return void 0;
     if (typeof parsed.provider !== "string" || typeof parsed.dimensions !== "number") return void 0;
     if (typeof parsed.generated_at !== "string" || typeof parsed.docs !== "object" || parsed.docs === null) {
@@ -2041,7 +2304,7 @@ async function embedTexts(command, texts) {
   const inputPath = join4(dir, "input.json");
   const outputPath = join4(dir, "output.json");
   try {
-    writeFileSync3(inputPath, JSON.stringify({ texts }));
+    writeFileSync4(inputPath, JSON.stringify({ texts }));
     await new Promise((resolve3, reject) => {
       const child = spawn(command, [inputPath, outputPath], {
         stdio: "ignore",
@@ -2054,7 +2317,7 @@ async function embedTexts(command, texts) {
         else reject(new Error(`vectorizer exited with ${code ?? "no code"}`));
       });
     });
-    const parsed = JSON.parse(readFileSync6(outputPath, "utf8"));
+    const parsed = JSON.parse(readFileSync7(outputPath, "utf8"));
     if (!Array.isArray(parsed.vectors) || parsed.vectors.length !== texts.length) {
       throw new Error("vectorizer output must contain one vector per text");
     }
@@ -2151,6 +2414,15 @@ var MemoryStore = class {
   accounted = /* @__PURE__ */ new Map();
   issues = [];
   head = null;
+  lastReloadMs = 0;
+  lastCheckpointSeq = 0;
+  checkpointState = null;
+  cachedIndex = null;
+  revision = 0;
+  fileMeta = /* @__PURE__ */ new Map();
+  dirtyDerived = 0;
+  pendingAdds = [];
+  addTimer;
   constructor(options) {
     this.paths = memoryPaths(options.home);
     this.config = options.config;
@@ -2158,17 +2430,68 @@ var MemoryStore = class {
     this.beforeStep = options.beforeStep;
     this.journal = new Journal(this.paths.journalDir);
     this.reload();
+    if (this.journal.stats().lines > 5e4) {
+      try {
+        this.maintain({ force: true });
+      } catch (error) {
+        this.issues.push(`automatic journal maintenance failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
   }
-  /** Re-read the journal and the memory files; classify each file. */
+  /** Re-read the journal checkpoint and the memory files; classify each file. */
   reload() {
-    const read = this.journal.readAll();
-    this.issues = read.issues.map((issue) => issue.message);
-    this.head = read.head;
+    const started = performance.now();
+    const previousDocs = this.docs;
+    const previousMeta = this.fileMeta;
+    this.issues = [];
     this.docs = /* @__PURE__ */ new Map();
     this.quarantined = /* @__PURE__ */ new Map();
     this.deleted = /* @__PURE__ */ new Set();
     this.accounted = /* @__PURE__ */ new Map();
+    this.revision += 1;
+    this.cachedIndex = null;
+    this.fileMeta = /* @__PURE__ */ new Map();
     const latest = /* @__PURE__ */ new Map();
+    const checkpointRead = readCheckpoint(this.paths.home);
+    let read;
+    if (checkpointRead.checkpoint !== void 0) {
+      const checkpoint = checkpointRead.checkpoint;
+      this.lastCheckpointSeq = checkpoint.journal.seq;
+      this.checkpointState = { seq: checkpoint.journal.seq, created_at: checkpoint.created_at };
+      for (const doc of checkpoint.docs) {
+        latest.set(doc.id, { hash: doc.sha256, deleted: doc.deleted });
+        if (doc.deleted) this.deleted.add(doc.id);
+        if (doc.sha256 !== "") this.accounted.set(doc.id, doc.sha256);
+      }
+      const tail = this.journal.readAfter(
+        checkpoint.journal.seq,
+        checkpoint.journal.hash,
+        checkpoint.journal.segment
+      );
+      read = { entries: tail.entries, issues: tail.issues, head: tail.head ?? checkpoint.journal };
+      const journalHead = this.journal.head();
+      if (journalHead !== null && journalHead.seq < checkpoint.journal.seq) {
+        read = {
+          ...read,
+          issues: [...read.issues, {
+            kind: "chain",
+            message: `journal is behind checkpoint (#${checkpoint.journal.seq}): possible truncation`
+          }]
+        };
+      }
+    } else {
+      this.lastCheckpointSeq = 0;
+      this.checkpointState = null;
+      read = this.journal.readAll();
+      if (checkpointRead.error !== void 0) {
+        read = {
+          ...read,
+          issues: [...read.issues, { kind: "parse", message: `checkpoint: ${checkpointRead.error}` }]
+        };
+      }
+    }
+    this.issues = read.issues.map((issue) => issue.message);
+    this.head = read.head;
     for (const entry of read.entries) {
       const id = typeof entry.data.id === "string" ? entry.data.id : void 0;
       if (entry.op === "record" || entry.op === "adopt") {
@@ -2182,6 +2505,7 @@ var MemoryStore = class {
     }
     for (const [id, value] of latest) {
       if (value.hash !== "") this.accounted.set(id, value.hash);
+      if (value.deleted) this.deleted.add(id);
     }
     for (const kind of KINDS2) {
       const dir = join5(this.paths.memoriesDir, kind);
@@ -2195,12 +2519,20 @@ var MemoryStore = class {
         const file = join5(dir, name2);
         const id = name2.slice(0, -3);
         try {
-          const text = readFileSync7(file, "utf8");
-          const doc = parseMemoryFile(text, file, {
-            abstractChars: this.config.limits.abstract_chars,
-            bodyChars: this.config.limits.body_chars,
-            maxRecordChars: this.config.storage.max_record_chars
-          });
+          const stat = statSync4(file);
+          const cachedDoc = previousDocs.get(id);
+          const cachedMeta = previousMeta.get(id);
+          let doc;
+          if (cachedDoc !== void 0 && cachedMeta !== void 0 && cachedMeta.mtimeMs === stat.mtimeMs && cachedMeta.size === stat.size) {
+            doc = cachedDoc;
+          } else {
+            const text = readFileSync8(file, "utf8");
+            doc = parseMemoryFile(text, file, {
+              abstractChars: this.config.limits.abstract_chars,
+              bodyChars: this.config.limits.body_chars,
+              maxRecordChars: this.config.storage.max_record_chars
+            });
+          }
           if (!isMemoryId(id) || doc.id !== id) {
             this.quarantined.set(doc.id || id, "id does not match filename");
             continue;
@@ -2219,6 +2551,7 @@ var MemoryStore = class {
             continue;
           }
           this.docs.set(doc.id, doc);
+          this.fileMeta.set(doc.id, { mtimeMs: stat.mtimeMs, size: stat.size });
         } catch (error) {
           this.quarantined.set(id, `parse: ${error instanceof Error ? error.message : String(error)}`);
         }
@@ -2231,7 +2564,7 @@ var MemoryStore = class {
       }
     }
     try {
-      const manifest = JSON.parse(readFileSync7(this.paths.manifestFile, "utf8"));
+      const manifest = JSON.parse(readFileSync8(this.paths.manifestFile, "utf8"));
       const expected = manifest.journal_head;
       const expectedSeq = expected?.seq;
       const expectedHash = expected?.hash;
@@ -2251,6 +2584,7 @@ var MemoryStore = class {
       }
     } catch {
     }
+    this.lastReloadMs = performance.now() - started;
   }
   active(date = today(this.now())) {
     const live = activeDocs(this.docs.values(), date);
@@ -2271,7 +2605,7 @@ var MemoryStore = class {
   recall(query, options = {}) {
     const text = query.trim();
     if (text === "") return { hits: [], warnings: ["empty query"] };
-    this.reload();
+    this.reloadIfJournalChanged();
     const date = options.asOf ?? today(this.now());
     const limit = Math.min(
       options.limit ?? this.config.recall.limit,
@@ -2280,7 +2614,7 @@ var MemoryStore = class {
     const activeSet = activeDocs(this.docs.values(), date).filter(
       (doc) => !this.deleted.has(doc.id) && !this.quarantined.has(doc.id)
     );
-    const index = buildIndex(activeSet, TOKENIZER_VERSION);
+    const index = this.indexFor(activeSet, date);
     const byId = new Map(activeSet.map((doc) => [doc.id, doc]));
     const minScore = this.config.recall.min_score / 1e3;
     let ranked;
@@ -2360,13 +2694,13 @@ ${doc.body}`), queryVector));
       if (queryVector === void 0 || queryVector.length !== cache.dimensions) {
         throw new Error(`query vector does not match cache dimensions (${cache.dimensions})`);
       }
-      this.reload();
+      this.reloadIfJournalChanged();
       const date = options.asOf ?? today(this.now());
       const limit = Math.min(options.limit ?? this.config.recall.limit, this.config.recall.max_limit);
       const activeSet = activeDocs(this.docs.values(), date).filter(
         (doc) => !this.deleted.has(doc.id) && !this.quarantined.has(doc.id)
       );
-      const index = buildIndex(activeSet, TOKENIZER_VERSION);
+      const index = this.indexFor(activeSet, date);
       const lexicalHits = search(index, text, {
         limit: activeSet.length,
         minScorePermille: 0,
@@ -2543,6 +2877,123 @@ ${doc.body}`), queryVector));
       lock.release();
     }
   }
+  /** Force checkpoint + archive old segments; returns what moved. */
+  maintain(options = {}) {
+    const lock = acquireLock({
+      file: this.paths.lockFile,
+      config: {
+        heartbeatMs: this.config.lock.heartbeat_ms,
+        staleMs: this.config.lock.stale_ms,
+        timeoutMs: this.config.lock.timeout_ms
+      },
+      now: () => this.now().getTime()
+    });
+    try {
+      this.reload();
+      if (this.issues.length > 0) {
+        throw new MemoryStoreError("CONFLICT", `journal is inconsistent, repair before maintain: ${this.issues[0]}`);
+      }
+      const checkpointed = this.checkpoint();
+      const archived = this.archiveOldSegments(options.force ?? false);
+      const pruned = this.pruneArchives(options.retentionDays ?? 365);
+      this.reload();
+      return { archived, pruned, checkpointed };
+    } finally {
+      lock.release();
+    }
+  }
+  archiveOldSegments(force) {
+    if (this.head === null) return [];
+    const read = readCheckpoint(this.paths.home);
+    if (read.checkpoint === void 0) return [];
+    const checkpointSegment = read.checkpoint.journal.segment;
+    if (checkpointSegment === void 0) return [];
+    const segments = this.journal.segments();
+    const at = segments.indexOf(checkpointSegment);
+    if (at <= 0) return [];
+    if (!force && this.journal.stats().lines <= 5e4) return [];
+    const archiveDir = this.paths.journalArchiveDir;
+    ensureDir(archiveDir);
+    const archived = [];
+    const toDelete = [];
+    let throughSeq = 0;
+    let throughHash = "";
+    for (const name2 of segments.slice(0, at)) {
+      const file = join5(this.paths.journalDir, name2);
+      const text = readFileSync8(file, "utf8");
+      const lines = text.split("\n").filter((line) => line !== "");
+      if (lines.length === 0) continue;
+      const hashes = lines.map((line) => hashLine(line));
+      const first = JSON.parse(lines[0]);
+      const last = JSON.parse(lines[lines.length - 1]);
+      const lastHash = hashLine(lines[lines.length - 1]);
+      const meta = {
+        schema: 1,
+        segment: name2,
+        first_seq: first.seq,
+        last_seq: last.seq,
+        count: lines.length,
+        bytes: Buffer.byteLength(text),
+        sha256: createHash5("sha256").update(text, "utf8").digest("hex"),
+        root: merkleRoot(hashes),
+        archived_at: this.now().toISOString()
+      };
+      const base = name2.replace(/\.jsonl$/, "");
+      writeFileSync5(join5(archiveDir, `${base}.jsonl.gz`), gzipSync(Buffer.from(text)));
+      writeFileAtomic(join5(archiveDir, `${base}.meta.json`), `${JSON.stringify(meta, null, 2)}
+`);
+      throughSeq = last.seq;
+      throughHash = lastHash;
+      toDelete.push(file);
+      archived.push(name2);
+    }
+    if (archived.length > 0) {
+      writeFileAtomic(
+        join5(archiveDir, "index.json"),
+        `${JSON.stringify({ schema: 1, through_seq: throughSeq, through_hash: throughHash, segments: archived }, null, 2)}
+`
+      );
+      for (const file of toDelete) rmSync3(file, { force: true });
+      this.journal.append({ op: "audit", data: { event: "journal-archive", segments: archived, through_seq: throughSeq } });
+    }
+    return archived;
+  }
+  pruneArchives(retentionDays) {
+    if (retentionDays <= 0) return [];
+    const dir = this.paths.journalArchiveDir;
+    if (!existsSync6(dir)) return [];
+    const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+    const pruned = [];
+    for (const name2 of readdirSync2(dir)) {
+      if (!name2.endsWith(".jsonl.gz")) continue;
+      const file = join5(dir, name2);
+      try {
+        const stat = statSync4(file);
+        if (stat.mtimeMs < cutoff) {
+          rmSync3(file, { force: true });
+          pruned.push(name2);
+        }
+      } catch {
+      }
+    }
+    return pruned;
+  }
+  indexFor(activeSet, asOf) {
+    if (this.cachedIndex !== null && this.cachedIndex.revision === this.revision && this.cachedIndex.asOf === asOf) {
+      return this.cachedIndex.index;
+    }
+    const index = buildIndex(activeSet, TOKENIZER_VERSION);
+    this.cachedIndex = { revision: this.revision, asOf, index };
+    return index;
+  }
+  /** Recall fast path: skip a full reload when the journal head is unchanged. */
+  reloadIfJournalChanged() {
+    const head = this.journal.head();
+    if (this.issues.length === 0 && head !== null && this.head !== null && head.seq === this.head.seq && head.hash === this.head.hash) {
+      return;
+    }
+    this.reload();
+  }
   stats() {
     return {
       active: this.active().length,
@@ -2623,20 +3074,87 @@ ${doc.body}`), queryVector));
       writeFileAtomic(filePath, text);
       this.beforeStep?.("before-journal");
       const hash = hashContent(text);
-      this.journal.append({
+      const entry = this.journal.append({
         op: "record",
         ...options.opId === void 0 ? {} : { opId: options.opId },
         data: { id: doc.id, sha256: hash }
       });
       this.beforeStep?.("before-derived");
-      this.reload();
+      const parsed = parseMemoryFile(text, filePath, {
+        abstractChars: this.config.limits.abstract_chars,
+        bodyChars: this.config.limits.body_chars,
+        maxRecordChars: this.config.storage.max_record_chars
+      });
+      this.docs.set(parsed.id, parsed);
+      this.accounted.set(parsed.id, hash);
+      this.deleted.delete(parsed.id);
+      this.head = { seq: entry.seq, hash: hashLine(JSON.stringify(entry)) };
+      this.revision += 1;
+      this.cachedIndex = null;
+      try {
+        const stat = statSync4(filePath);
+        this.fileMeta.set(parsed.id, { mtimeMs: stat.mtimeMs, size: stat.size });
+      } catch {
+      }
       this.writeDerived();
-      this.reload();
       return { id: doc.id, content_hash: hash, deduplicated: false, warnings: [] };
     } finally {
       lock.release();
     }
   }
+  /**
+   * Group-commit variant of `add`: concurrent callers are coalesced for a short
+   * window, then written with one journal fsync. Sequential awaited calls still
+   * pay one commit each; use it when several producers write at once.
+   */
+  addAsync(input, options) {
+    return new Promise((resolve3, reject) => {
+      this.pendingAdds.push({ input, options, resolve: resolve3, reject });
+      if (this.addTimer === void 0) {
+        this.addTimer = setTimeout(() => {
+          this.addTimer = void 0;
+          this.flushAddGroup();
+        }, 2);
+      }
+    });
+  }
+  flushAddGroup() {
+    const pending = this.pendingAdds.splice(0);
+    if (pending.length === 0) return;
+    try {
+      this.reload();
+      if (this.issues.length > 0) {
+        throw new MemoryStoreError("CONFLICT", `journal is inconsistent, writes are blocked: ${this.issues[0]}`);
+      }
+      const unique = [];
+      for (const job of pending) {
+        const duplicate = this.findDuplicate(job.input, job.options.author);
+        if (duplicate === void 0) {
+          unique.push(job);
+        } else {
+          this.appendAudit({ event: "dedupe", id: duplicate.id });
+          job.resolve({ id: duplicate.id, content_hash: duplicate.content_hash, deduplicated: true, warnings: [] });
+        }
+      }
+      for (const author of ["human", "agent"]) {
+        const group = unique.filter((job) => job.options.author === author);
+        if (group.length === 0) continue;
+        const commonOpId = group.length === 1 ? group[0]?.options.opId : void 0;
+        const results = this.addMany(
+          group.map((job) => ({
+            ...job.input,
+            ...job.options.provenance === void 0 ? {} : { provenance: job.options.provenance }
+          })),
+          { author, ...commonOpId === void 0 ? {} : { opId: commonOpId } }
+        );
+        for (let index = 0; index < group.length; index += 1) {
+          group[index].resolve(results[index]);
+        }
+      }
+    } catch (error) {
+      for (const job of pending) job.reject(error);
+    }
+  }
   /**
    * Accept a hand-placed or hand-edited file after a human reviewed it: append
    * an `adopt` journal line with the file's current hash. The file itself is
@@ -2667,7 +3185,7 @@ ${doc.body}`), queryVector));
       if (file === void 0) {
         throw new MemoryStoreError("NOT_FOUND", `no memory file for ${id}`);
       }
-      const text = readFileSync7(file, "utf8");
+      const text = readFileSync8(file, "utf8");
       let doc;
       try {
         doc = parseMemoryFile(text, file, {
@@ -2828,19 +3346,37 @@ ${doc.body}`), queryVector));
         throw error;
       }
       this.beforeStep?.("before-journal");
-      for (const entry of prepared) {
-        const hash = hashContent(entry.text);
-        this.journal.append({
+      const journalEntries = this.journal.appendBatch(
+        prepared.map((entry) => ({
           op: "record",
           ...options.opId === void 0 ? {} : { opId: `${options.opId}-${entry.id}` },
-          data: { id: entry.id, sha256: hash }
+          data: { id: entry.id, sha256: hashContent(entry.text) }
+        }))
+      );
+      for (let index = 0; index < prepared.length; index += 1) {
+        const entry = prepared[index];
+        entry.hash = hashContent(entry.text);
+        const file = join5(this.paths.memoriesDir, entry.kind, `${entry.id}.md`);
+        const parsed = parseMemoryFile(entry.text, file, {
+          abstractChars: this.config.limits.abstract_chars,
+          bodyChars: this.config.limits.body_chars,
+          maxRecordChars: this.config.storage.max_record_chars
         });
-        entry.hash = hash;
+        this.docs.set(parsed.id, parsed);
+        this.accounted.set(parsed.id, entry.hash);
+        this.deleted.delete(parsed.id);
+        try {
+          const stat = statSync4(file);
+          this.fileMeta.set(parsed.id, { mtimeMs: stat.mtimeMs, size: stat.size });
+        } catch {
+        }
       }
+      const lastJournalEntry = journalEntries[journalEntries.length - 1];
+      this.head = { seq: lastJournalEntry.seq, hash: hashLine(JSON.stringify(lastJournalEntry)) };
       this.beforeStep?.("before-derived");
-      this.reload();
+      this.revision += 1;
+      this.cachedIndex = null;
       this.writeDerived();
-      this.reload();
       return prepared.map((entry) => ({
         id: entry.id,
         content_hash: entry.hash,
@@ -2911,7 +3447,7 @@ ${doc.body}`), queryVector));
       for (const name2 of names) {
         const path = join5(this.paths.pendingDir, name2);
         try {
-          const proposal = JSON.parse(readFileSync7(path, "utf8"));
+          const proposal = JSON.parse(readFileSync8(path, "utf8"));
           if (Array.isArray(proposal.targets) && proposal.targets.includes(id)) {
             rmSync3(path, { force: true });
             this.journal.append({
@@ -2949,7 +3485,8 @@ ${doc.body}`), queryVector));
           `journal is inconsistent, repair it before rebuild: ${this.issues[0]}`
         );
       }
-      this.writeDerived();
+      this.writeDerived(true);
+      this.checkpoint();
       return {
         records: this.accounted.size,
         files: this.docs.size,
@@ -2965,9 +3502,25 @@ ${doc.body}`), queryVector));
   }
   /** Quarantine and journal diagnostics, used by `mem doctor`. */
   diagnostics() {
-    return { quarantined: this.quarantined, issues: this.issues, head: this.head };
+    return {
+      quarantined: this.quarantined,
+      issues: this.issues,
+      head: this.head,
+      journal: this.journal.stats(),
+      reload_ms: Number(this.lastReloadMs.toFixed(3)),
+      checkpoint: this.checkpointState
+    };
   }
-  writeDerived() {
+  writeDerived(force = false) {
+    if (!force && this.docs.size > 1e3) {
+      this.dirtyDerived += 1;
+      if (this.dirtyDerived < 50) {
+        this.maybeCheckpoint();
+        if (this.head !== null && this.head.seq % 500 === 0) this.maybeArchive();
+        return;
+      }
+    }
+    this.dirtyDerived = 0;
     const active = this.active();
     const manifest = {
       schema: 1,
@@ -2999,6 +3552,38 @@ ${doc.body}`), queryVector));
     for (const doc of sorted) lines.push(`- [${doc.kind}] ${doc.abstract} \u2014 ${doc.id}`);
     writeFileAtomic(this.paths.memoryIndexFile, `${lines.join("\n")}
 `);
+    this.maybeCheckpoint();
+    this.maybeArchive();
+  }
+  /** Force a checkpoint (maintenance/tests); returns false when journal is empty. */
+  checkpoint() {
+    if (this.head === null) return false;
+    const full = this.journal.readAll();
+    const docs = [...this.accounted.entries()].map(([id, sha2562]) => ({
+      id,
+      sha256: sha2562,
+      deleted: this.deleted.has(id)
+    }));
+    writeCheckpoint(this.paths.home, {
+      journal: {
+        ...this.head,
+        segment: this.journal.segments().at(-1)
+      },
+      docs,
+      journalRoot: merkleRoot(full.hashes)
+    });
+    this.lastCheckpointSeq = this.head.seq;
+    return true;
+  }
+  maybeCheckpoint(force = false) {
+    if (this.head === null) return;
+    if (!force && this.head.seq - this.lastCheckpointSeq < 1e3) return;
+    this.checkpoint();
+  }
+  maybeArchive() {
+    if (this.journal.stats().lines <= 5e4) return;
+    if (readCheckpoint(this.paths.home).checkpoint === void 0) this.checkpoint();
+    this.archiveOldSegments(true);
   }
   validateInput(input) {
     if (!KINDS2.includes(input.kind)) {
@@ -3056,7 +3641,7 @@ ${doc.body}`), queryVector));
   findMemoryFile(id) {
     for (const kind of KINDS2) {
       const file = join5(this.paths.memoriesDir, kind, `${id}.md`);
-      if (existsSync4(file)) return file;
+      if (existsSync6(file)) return file;
     }
     return void 0;
   }
@@ -3075,7 +3660,7 @@ ${doc.body}`), queryVector));
   allocateId(now) {
     for (let attempt = 0; attempt < 100; attempt += 1) {
       const id = newMemoryId(now);
-      const exists = this.docs.has(id) || this.accounted.has(id) || existsSync4(join5(this.paths.memoriesDir, "fact", `${id}.md`)) || existsSync4(join5(this.paths.memoriesDir, "pitfall", `${id}.md`)) || existsSync4(join5(this.paths.memoriesDir, "exp", `${id}.md`));
+      const exists = this.docs.has(id) || this.accounted.has(id) || existsSync6(join5(this.paths.memoriesDir, "fact", `${id}.md`)) || existsSync6(join5(this.paths.memoriesDir, "pitfall", `${id}.md`)) || existsSync6(join5(this.paths.memoriesDir, "exp", `${id}.md`));
       if (!exists) return id;
     }
     throw new MemoryStoreError("CONFLICT", "could not allocate a unique memory id");
@@ -3090,7 +3675,7 @@ function countPending(dir) {
 }
 
 // packages/core/src/rules/rules.ts
-import { existsSync as existsSync5, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync9 } from "node:fs";
 import { join as join6 } from "node:path";
 var HEADER = /^(\d+)\.\s*\[(机器门禁|模型指引|废止)\]\s*(.*)$/;
 var EXTRA = /^\s+(check|test):\s*(.+)$/;
@@ -3147,8 +3732,8 @@ function checkSymbolExists(check, rootDir) {
   const [path, symbol] = check.split("#");
   if (path === void 0 || symbol === void 0 || path === "" || symbol === "") return false;
   const file = join6(rootDir, path);
-  if (!existsSync5(file)) return false;
-  return readFileSync8(file, "utf8").includes(symbol);
+  if (!existsSync7(file)) return false;
+  return readFileSync9(file, "utf8").includes(symbol);
 }
 function validateRules(rules, options) {
   const errors = [];
@@ -3159,11 +3744,11 @@ function validateRules(rules, options) {
     }
     if (rule.test === void 0) continue;
     const testFile = join6(options.rootDir, rule.test);
-    if (!existsSync5(testFile)) {
+    if (!existsSync7(testFile)) {
       errors.push(`rule ${rule.number}: test file "${rule.test}" does not exist`);
       continue;
     }
-    if (!/\[neg\]/.test(readFileSync8(testFile, "utf8"))) {
+    if (!/\[neg\]/.test(readFileSync9(testFile, "utf8"))) {
       errors.push(`rule ${rule.number}: test file "${rule.test}" has no [neg] case`);
     }
   }
@@ -3175,8 +3760,8 @@ function parseAndValidateRules(text, options) {
 }
 function loadRules(home) {
   const file = memoryPaths(home).rulesFile;
-  if (!existsSync5(file)) return [];
-  return parseRules(readFileSync8(file, "utf8")).rules;
+  if (!existsSync7(file)) return [];
+  return parseRules(readFileSync9(file, "utf8")).rules;
 }
 function renderRules(rules, options = {}) {
   const lines = [];
@@ -3189,7 +3774,7 @@ function renderRules(rules, options = {}) {
 }
 function readRulesFile(home) {
   const file = memoryPaths(home).rulesFile;
-  return existsSync5(file) ? readFileSync8(file, "utf8") : "";
+  return existsSync7(file) ? readFileSync9(file, "utf8") : "";
 }
 function saveRulesFile(home, text) {
   const parsed = parseAndValidateRules(text, { rootDir: home });
@@ -3200,20 +3785,20 @@ function saveRulesFile(home, text) {
 }
 
 // packages/core/src/inject/snapshot.ts
-import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync6, readFileSync as readFileSync9, readdirSync as readdirSync3, rmSync as rmSync4, statSync as statSync4 } from "node:fs";
+import { createHash as createHash6 } from "node:crypto";
+import { existsSync as existsSync8, readFileSync as readFileSync10, readdirSync as readdirSync3, rmSync as rmSync4, statSync as statSync5 } from "node:fs";
 import { join as join7 } from "node:path";
 var PROMPT_SCHEMA_VERSION = 4;
 var SNAPSHOT_KEEP = 20;
 function snapshotPath(home, sessionId) {
-  const name2 = createHash4("sha256").update(sessionId, "utf8").digest("hex").slice(0, 32);
+  const name2 = createHash6("sha256").update(sessionId, "utf8").digest("hex").slice(0, 32);
   return join7(memoryPaths(home).snapshotsDir, `${name2}.json`);
 }
 function readSnapshot(home, sessionId) {
   const file = snapshotPath(home, sessionId);
-  if (!existsSync6(file)) return null;
+  if (!existsSync8(file)) return null;
   try {
-    const record = JSON.parse(readFileSync9(file, "utf8"));
+    const record = JSON.parse(readFileSync10(file, "utf8"));
     if (record.session_id !== sessionId || typeof record.text !== "string" || typeof record.memory_revision !== "string" || typeof record.prompt_schema_version !== "number") {
       return null;
     }
@@ -3236,7 +3821,7 @@ function pruneSnapshots(home, keep = SNAPSHOT_KEEP) {
     return;
   }
   if (names.length <= keep) return;
-  const byAge = names.map((name2) => ({ name: name2, mtime: statSync4(join7(dir, name2)).mtimeMs })).sort((left, right) => right.mtime - left.mtime);
+  const byAge = names.map((name2) => ({ name: name2, mtime: statSync5(join7(dir, name2)).mtimeMs })).sort((left, right) => right.mtime - left.mtime);
   for (const entry of byAge.slice(keep)) {
     try {
       rmSync4(join7(dir, entry.name), { force: true });
@@ -3246,10 +3831,10 @@ function pruneSnapshots(home, keep = SNAPSHOT_KEEP) {
 }
 
 // packages/core/src/inject/assemble.ts
-import { createHash as createHash5, randomBytes as randomBytes4 } from "node:crypto";
+import { createHash as createHash7, randomBytes as randomBytes5 } from "node:crypto";
 
 // packages/core/src/inject/sections.ts
-import { existsSync as existsSync7, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync11 } from "node:fs";
 
 // packages/core/src/personalization/guidance.ts
 function renderGuidance(mode) {
@@ -3276,7 +3861,7 @@ function truncate(text, budget) {
   return `${points.slice(0, budget - 1).join("")}\u2026`;
 }
 function readIfExists(file) {
-  return existsSync7(file) ? readFileSync10(file, "utf8").replace(COMMENT, "").trim() : "";
+  return existsSync9(file) ? readFileSync11(file, "utf8").replace(COMMENT, "").trim() : "";
 }
 var SECTION_ORDERS = { SOUL: 100, GUIDANCE: 110, RULES: 150, USER: 200, MEMORY: 300 };
 function builtinSectionSources(context) {
@@ -3364,7 +3949,7 @@ function charCount2(text) {
 }
 function memoryRevision(docs) {
   const lines = [...docs].map((doc) => `${doc.id}:${doc.content_hash}`).sort((left, right) => left.localeCompare(right));
-  return createHash5("sha256").update(lines.join("\n"), "utf8").digest("hex");
+  return createHash7("sha256").update(lines.join("\n"), "utf8").digest("hex");
 }
 function catalogLines(docs) {
   const sorted = [...docs].sort((left, right) => {
@@ -3447,7 +4032,7 @@ ${section.text}`).join("\n\n");
       throw new InjectionError("OVER_BUDGET", `injection is over inject.total_max_chars (${input.config.inject.total_max_chars})`);
     }
   }
-  const delimiter = input.delimiter ?? randomBytes4(8).toString("hex");
+  const delimiter = input.delimiter ?? randomBytes5(8).toString("hex");
   const escaped = body.split(delimiter).join("<escaped>");
   const text = `<<AM-${delimiter}>>
 ${escaped}
@@ -3497,7 +4082,7 @@ ${escaped}
 }
 
 // packages/core/src/proposals/proposals.ts
-import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync11, rmSync as rmSync5 } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync12, rmSync as rmSync5 } from "node:fs";
 import { join as join8 } from "node:path";
 var ProposalError = class extends Error {
   code;
@@ -3523,7 +4108,7 @@ function listProposals(store) {
   const proposals = [];
   for (const name2 of names) {
     try {
-      proposals.push(JSON.parse(readFileSync11(join8(pendingDir(store), name2), "utf8")));
+      proposals.push(JSON.parse(readFileSync12(join8(pendingDir(store), name2), "utf8")));
     } catch {
     }
   }
@@ -3531,8 +4116,8 @@ function listProposals(store) {
 }
 function readProposal(store, id) {
   const file = proposalPath(store, id);
-  if (!existsSync8(file)) throw new ProposalError("NOT_FOUND", `no pending proposal ${id}`);
-  return JSON.parse(readFileSync11(file, "utf8"));
+  if (!existsSync10(file)) throw new ProposalError("NOT_FOUND", `no pending proposal ${id}`);
+  return JSON.parse(readFileSync12(file, "utf8"));
 }
 function currentHash(store, id) {
   const doc = store.read(id);
@@ -3632,7 +4217,7 @@ function decideProposal(deps, input) {
 }
 
 // packages/core/src/actor.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 var EvidenceError = class extends Error {
   constructor(message) {
     super(message);
@@ -3652,8 +4237,8 @@ function bindEvidence(input) {
   if (!event.text.includes(input.quote)) {
     throw new EvidenceError("quote is not a substring of the referenced event");
   }
-  const sha256 = createHash6("sha256").update(event.text, "utf8").digest("hex");
-  if (input.expectedSha256 !== void 0 && input.expectedSha256 !== sha256) {
+  const sha2562 = createHash8("sha256").update(event.text, "utf8").digest("hex");
+  if (input.expectedSha256 !== void 0 && input.expectedSha256 !== sha2562) {
     throw new EvidenceError("event hash does not match the resolved event");
   }
   return {
@@ -3661,7 +4246,7 @@ function bindEvidence(input) {
     event_seq: input.eventSeq,
     speaker: event.speaker,
     quote: input.quote,
-    event_sha256: sha256
+    event_sha256: sha2562
   };
 }
 
@@ -3685,14 +4270,14 @@ var SessionQuota = class {
 };
 
 // packages/core/src/distill/closeout.ts
-import { createHash as createHash7 } from "node:crypto";
-import { existsSync as existsSync9, readFileSync as readFileSync12 } from "node:fs";
+import { createHash as createHash9 } from "node:crypto";
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "node:fs";
 import { join as join9 } from "node:path";
 function loadRejected(home) {
   const file = join9(memoryPaths(home).stateDir, "distill-rejected.json");
-  if (!existsSync9(file)) return /* @__PURE__ */ new Set();
+  if (!existsSync11(file)) return /* @__PURE__ */ new Set();
   try {
-    const parsed = JSON.parse(readFileSync12(file, "utf8"));
+    const parsed = JSON.parse(readFileSync13(file, "utf8"));
     return new Set(Array.isArray(parsed.hashes) ? parsed.hashes.filter((value) => typeof value === "string") : []);
   } catch {
     return /* @__PURE__ */ new Set();
@@ -3776,7 +4361,7 @@ function summaryHash(candidate) {
     [...candidate.targets].sort().join(","),
     ...candidate.replacements.map((replacement) => normalizedAbstract(replacement.abstract))
   ].join("|");
-  return createHash7("sha256").update(material, "utf8").digest("hex");
+  return createHash9("sha256").update(material, "utf8").digest("hex");
 }
 function findJson(text) {
   const start = text.indexOf("{");
@@ -3945,8 +4530,8 @@ var CloseoutRound = class {
 };
 
 // packages/core/src/ops/ops.ts
-import { createHash as createHash8 } from "node:crypto";
-import { cpSync, existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync13, readdirSync as readdirSync5, statSync as statSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { createHash as createHash10 } from "node:crypto";
+import { cpSync, existsSync as existsSync12, mkdirSync as mkdirSync3, readFileSync as readFileSync14, readdirSync as readdirSync5, statSync as statSync6, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join10, relative } from "node:path";
 var INCLUDE = [
   "config.toml",
@@ -3965,7 +4550,7 @@ function exportStore(options) {
   mkdirSync3(options.out, { recursive: true });
   for (const entry of INCLUDE) {
     const source = join10(paths.home, entry);
-    if (!existsSync10(source)) continue;
+    if (!existsSync12(source)) continue;
     const target = join10(options.out, entry);
     cpSync(source, target, { recursive: true });
   }
@@ -3975,13 +4560,13 @@ function exportStore(options) {
   const walk2 = (dir, base) => {
     for (const name2 of readdirSync5(dir)) {
       const full = join10(dir, name2);
-      if (statSync5(full).isDirectory()) {
+      if (statSync6(full).isDirectory()) {
         walk2(full, base);
         continue;
       }
       const rel = relative(base, full).replaceAll("\\", "/");
-      const data = readFileSync13(full);
-      lines.push(`${createHash8("sha256").update(data).digest("hex")}  ${rel}`);
+      const data = readFileSync14(full);
+      lines.push(`${createHash10("sha256").update(data).digest("hex")}  ${rel}`);
       files += 1;
       bytes += data.length;
     }
@@ -3989,7 +4574,7 @@ function exportStore(options) {
   walk2(options.out, options.out);
   lines.sort();
   const sums = join10(options.out, "SHA256SUMS");
-  writeFileSync4(sums, `${lines.join("\n")}
+  writeFileSync6(sums, `${lines.join("\n")}
 `, "utf8");
   return { out: options.out, files, bytes, sums };
 }
@@ -3997,8 +4582,8 @@ function personalizationChars(home) {
   const paths = memoryPaths(home);
   const charsOf = (file) => {
     try {
-      if (!existsSync10(file)) return 0;
-      return [...readFileSync13(file, "utf8").replace(/<!--[\s\S]*?-->/g, "")].length;
+      if (!existsSync12(file)) return 0;
+      return [...readFileSync14(file, "utf8").replace(/<!--[\s\S]*?-->/g, "")].length;
     } catch {
       return 0;
     }
@@ -4039,7 +4624,7 @@ function inspectStore(options) {
 }
 
 // packages/core/src/profile/profile.ts
-import { existsSync as existsSync11, readFileSync as readFileSync14 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync15 } from "node:fs";
 var PROFILE_SEPARATOR = "\xA7";
 var PROFILE_MAX_CHARS = 1e4;
 var ProfileError = class extends Error {
@@ -4099,7 +4684,7 @@ function validateProfileEntries(entries) {
 }
 function loadProfile(home) {
   const file = memoryPaths(home).userFile;
-  const text = existsSync11(file) ? readFileSync14(file, "utf8") : "";
+  const text = existsSync13(file) ? readFileSync15(file, "utf8") : "";
   const entries = parseProfileEntries(text);
   return { entries, chars: profileChars(entries) };
 }
@@ -4128,7 +4713,7 @@ function findProfileEntry(entries, oldText) {
 }
 
 // packages/core/src/personalization/scaffold.ts
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 var SOUL_TEMPLATE = `<!--
 \u4EBA\u683C\u6458\u8981\uFF1A\u6CE8\u5165\u65F6\u53EA\u53D6\u524D 200 \u5B57\u3002\u7528\u6563\u6587\u5199\u300C\u4F60\u662F\u8C01\u3001\u600E\u4E48\u8BF4\u8BDD\u3001\u8FB9\u754C\u5728\u54EA\u300D\uFF0C\u4E0D\u8981\u5199\u4E8B\u5B9E\u6761\u76EE\u3002
 \u793A\u4F8B\uFF1A\u4F60\u7684\u89D2\u8272\u662F\u2026\u2026\uFF0C\u4EE5\u2026\u2026\u7684\u8EAB\u4EFD\u4E0E\u7528\u6237\u4EA4\u6D41\uFF1B\u8BED\u6C14\u2026\u2026\uFF1B\u4E0D\u786E\u5B9A\u65F6\u5148\u95EE\uFF0C\u4E0D\u66FF\u7528\u6237\u505A\u51B3\u5B9A\u3002
@@ -4160,7 +4745,7 @@ function scaffoldPersonalization(options) {
   const created = [];
   const kept = [];
   for (const [file, template] of targets) {
-    if (existsSync12(file)) {
+    if (existsSync14(file)) {
       kept.push(file);
       continue;
     }