@agent_memory/dsh 0.2.1 → 0.5.0

package/dist/plugin.mjs

@@ -89,6 +89,7 @@ function memoryPaths(home) {
   return {
     home,
     configFile: join(home, "config.toml"),
+    projectsFile: join(home, "projects.json"),
     policyFile: join(home, "policy.json"),
     sealFile: join(home, ".state", "policy.seal.json"),
     lockFile: join(home, ".state", "lock"),
@@ -103,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")
   };
@@ -553,7 +557,9 @@ var configSchema = {
   recall: {
     limit: { type: "int", default: 5, min: 1, max: 100 },
     min_score: { type: "int", default: 500, min: 0, max: 1e3 },
-    max_limit: { type: "int", default: 20, min: 1, max: 100 }
+    max_limit: { type: "int", default: 20, min: 1, max: 100 },
+    hybrid: { type: "bool", default: false },
+    embedding_weight: { type: "int", default: 400, min: 0, max: 1e3 }
   },
   distill: {
     max_proposals: { type: "int", default: 5, min: 1, max: 5 },
@@ -718,6 +724,79 @@ function ensureDir(dir) {
 
 // packages/core/src/model/frontmatter.ts
 import { createHash } from "node:crypto";
+
+// packages/core/src/model/metadata.ts
+var PROJECT_NAME_MAX = 64;
+var TAG_MAX = 32;
+var TAGS_MAX = 8;
+var RELATIONS_MAX = 16;
+var RELATION_TYPES = ["relates_to", "derived_from"];
+var MEMORY_ID = /^mem-\d{8}-[0-9a-f]{8}$/;
+function projectProblem(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value !== "string") return "project must be a string or null";
+  const name2 = value.trim();
+  if (name2 === "") return "project must not be empty";
+  if (name2 !== value) return "project must not have leading or trailing whitespace";
+  if ([...name2].length > PROJECT_NAME_MAX) {
+    return `project must be at most ${PROJECT_NAME_MAX} characters`;
+  }
+  if (/[\r\n]/.test(name2)) return "project must be a single line";
+  if (/[\\/]/.test(name2)) return "project must not contain path separators";
+  if (name2 === "\u672A\u5F52\u7C7B") return 'project name "\u672A\u5F52\u7C7B" is reserved for the default bucket';
+  return void 0;
+}
+function tagsProblem(value) {
+  if (!Array.isArray(value)) return "tags must be an array";
+  if (value.length > TAGS_MAX) return `tags allows at most ${TAGS_MAX} entries`;
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    if (typeof entry !== "string") return "each tag must be a string";
+    if (entry.length === 0) return "tags must not contain empty entries";
+    if ([...entry].length > TAG_MAX) return `each tag must be at most ${TAG_MAX} characters`;
+    if (/[\r\n]/.test(entry)) return "tags must be single-line";
+    if (seen.has(entry)) return `duplicate tag "${entry}"`;
+    seen.add(entry);
+  }
+  return void 0;
+}
+function relationsProblem(value, selfId) {
+  if (!Array.isArray(value)) return "relations must be an array";
+  if (value.length > RELATIONS_MAX) return `relations allows at most ${RELATIONS_MAX} entries`;
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      return "each relation must be an object";
+    }
+    const relation = entry;
+    if (typeof relation.type !== "string" || !RELATION_TYPES.includes(relation.type)) {
+      return "relation.type must be relates_to or derived_from";
+    }
+    if (typeof relation.target !== "string" || !MEMORY_ID.test(relation.target)) {
+      return "relation.target must look like mem-YYYYMMDD-8hex";
+    }
+    if (relation.target === selfId) return "a relation must not target itself";
+    const key = `${relation.type}:${relation.target}`;
+    if (seen.has(key)) return "relations must not contain duplicates";
+    seen.add(key);
+  }
+  return void 0;
+}
+function sourceProblem(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value !== "object" || Array.isArray(value)) return "source must be an object or null";
+  const source = value;
+  if (typeof source.type !== "string" || source.type.length === 0 || [...source.type].length > 32) {
+    return "source.type must be a non-empty string up to 32 characters";
+  }
+  if (typeof source.id !== "string" || source.id.length === 0 || [...source.id].length > 128) {
+    return "source.id must be a non-empty string up to 128 characters";
+  }
+  if (/[\r\n]/.test(source.type) || /[\r\n]/.test(source.id)) return "source values must be single-line";
+  return void 0;
+}
+
+// packages/core/src/model/frontmatter.ts
 var FrontmatterError = class extends Error {
   field;
   filePath;
@@ -733,6 +812,10 @@ var FIELD_ORDER = [
   "mem_schema",
   "kind",
   "scope",
+  "project",
+  "tags",
+  "relations",
+  "source",
   "abstract",
   "created_at",
   "valid_from",
@@ -805,10 +888,32 @@ function parseMemoryFile(text, filePath, limits) {
   }
   const id = requireString(values.get("id"), "id", filePath);
   if (!ID.test(id)) fail("id", "must look like mem-YYYYMMDD-8hex", filePath);
-  if (values.get("mem_schema") !== 1) fail("mem_schema", "must be 1", filePath);
+  if (values.get("mem_schema") !== 1 && values.get("mem_schema") !== 2) {
+    fail("mem_schema", "must be 1 or 2", filePath);
+  }
+  const memSchema = values.get("mem_schema");
   const kind = requireString(values.get("kind"), "kind", filePath);
   if (!KINDS.has(kind)) fail("kind", "must be fact, pitfall or exp", filePath);
   if (values.get("scope") !== "local") fail("scope", 'must be "local" in V1', filePath);
+  const rawProject = values.has("project") ? values.get("project") : null;
+  const projectIssue = projectProblem(rawProject);
+  if (projectIssue !== void 0) fail("project", projectIssue, filePath);
+  const project = rawProject === null || rawProject === void 0 ? null : rawProject;
+  const rawTags = values.has("tags") ? values.get("tags") : [];
+  const tagsIssue = tagsProblem(rawTags);
+  if (tagsIssue !== void 0) fail("tags", tagsIssue, filePath);
+  const tags = requireArray(rawTags, "tags", filePath).map((entry) => entry);
+  const rawRelations = values.has("relations") ? values.get("relations") : [];
+  const relationsIssue = relationsProblem(rawRelations, id);
+  if (relationsIssue !== void 0) fail("relations", relationsIssue, filePath);
+  const relations = requireArray(rawRelations, "relations", filePath).map((entry) => {
+    const relation = entry;
+    return { type: relation.type, target: relation.target };
+  });
+  const rawSource = values.has("source") ? values.get("source") : null;
+  const sourceIssue = sourceProblem(rawSource);
+  if (sourceIssue !== void 0) fail("source", sourceIssue, filePath);
+  const source = rawSource === null || rawSource === void 0 ? null : rawSource;
   const abstract = requireString(values.get("abstract"), "abstract", filePath);
   if (abstract.trim() === "") fail("abstract", "must not be empty", filePath);
   if (/[\r\n]/.test(abstract)) fail("abstract", "must be a single line", filePath);
@@ -881,9 +986,13 @@ function parseMemoryFile(text, filePath, limits) {
   }
   return {
     id,
-    mem_schema: 1,
+    mem_schema: memSchema,
     kind,
     scope: "local",
+    project,
+    tags,
+    relations,
+    source,
     abstract,
     created_at: createdAt,
     valid_from: validFrom,
@@ -904,6 +1013,10 @@ function serializeMemory(doc) {
     mem_schema: doc.mem_schema,
     kind: doc.kind,
     scope: doc.scope,
+    project: doc.project ?? null,
+    tags: doc.tags ?? [],
+    relations: doc.relations ?? [],
+    source: doc.source ?? null,
     abstract: doc.abstract,
     created_at: doc.created_at,
     valid_from: doc.valid_from,
@@ -1035,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);
@@ -1072,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)}
@@ -1106,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;
@@ -1228,9 +1341,204 @@ function missingContentWarnings(paths) {
   return expected.filter(([filePath]) => !existsSync2(filePath)).map(([, name2]) => `${name2} is not present yet; that injection section will be empty`);
 }
 
+// packages/core/src/projects/projects.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+var ProjectError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ProjectError";
+    this.code = code;
+  }
+};
+var DESCRIPTION_MAX = 280;
+var TIMESTAMP2 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+function readRegistry(home) {
+  const file = memoryPaths(home).projectsFile;
+  if (!existsSync3(file)) return { schema: 1, projects: [] };
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync3(file, "utf8").replace(/^\uFEFF/, ""));
+  } catch {
+    throw new ProjectError("INVALID", `projects.json is not valid JSON: ${file}`);
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new ProjectError("INVALID", "projects.json must be an object");
+  }
+  const record = parsed;
+  if (record.schema !== 1) throw new ProjectError("INVALID", "projects.json schema must be 1");
+  if (!Array.isArray(record.projects)) throw new ProjectError("INVALID", "projects.json projects must be an array");
+  const seen = /* @__PURE__ */ new Set();
+  const projects = [];
+  for (const raw of record.projects) {
+    if (typeof raw !== "object" || raw === null) throw new ProjectError("INVALID", "each project must be an object");
+    const entry = raw;
+    const issue = projectProblem(entry.name);
+    if (issue !== void 0) throw new ProjectError("INVALID", issue);
+    if (typeof entry.description !== "string" || [...entry.description].length > DESCRIPTION_MAX) {
+      throw new ProjectError("INVALID", `project description must be a string up to ${DESCRIPTION_MAX} characters`);
+    }
+    if (typeof entry.created_at !== "string" || !TIMESTAMP2.test(entry.created_at)) {
+      throw new ProjectError("INVALID", "project created_at must be an ISO timestamp");
+    }
+    if (typeof entry.updated_at !== "string" || !TIMESTAMP2.test(entry.updated_at)) {
+      throw new ProjectError("INVALID", "project updated_at must be an ISO timestamp");
+    }
+    const name2 = entry.name;
+    if (seen.has(name2.toLocaleLowerCase())) throw new ProjectError("INVALID", `duplicate project name: ${name2}`);
+    seen.add(name2.toLocaleLowerCase());
+    projects.push({
+      name: name2,
+      description: entry.description,
+      created_at: entry.created_at,
+      updated_at: entry.updated_at
+    });
+  }
+  return { schema: 1, projects };
+}
+function writeRegistry(home, registry) {
+  writeFileAtomic(memoryPaths(home).projectsFile, `${JSON.stringify(registry, null, 2)}
+`);
+}
+function listProjects(home) {
+  return readRegistry(home).projects;
+}
+function createProject(options) {
+  const name2 = options.name.trim();
+  const issue = projectProblem(name2);
+  if (issue !== void 0) throw new ProjectError("INVALID", issue);
+  if (name2.length > PROJECT_NAME_MAX) throw new ProjectError("INVALID", "project name is too long");
+  const description = (options.description ?? "").trim();
+  if ([...description].length > DESCRIPTION_MAX) {
+    throw new ProjectError("INVALID", `project description must be at most ${DESCRIPTION_MAX} characters`);
+  }
+  if (/[\r\n]/.test(description)) throw new ProjectError("INVALID", "project description must be a single line");
+  const registry = readRegistry(options.home);
+  if (registry.projects.some((project2) => project2.name.toLocaleLowerCase() === name2.toLocaleLowerCase())) {
+    throw new ProjectError("EXISTS", `project already exists: ${name2}`);
+  }
+  const at = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const project = { name: name2, description, created_at: at, updated_at: at };
+  writeRegistry(options.home, { schema: 1, projects: [...registry.projects, project] });
+  return project;
+}
+function deleteProject(home, name2) {
+  const registry = readRegistry(home);
+  const lower = name2.toLocaleLowerCase();
+  const kept = registry.projects.filter((project) => project.name.toLocaleLowerCase() !== lower);
+  if (kept.length === registry.projects.length) return false;
+  writeRegistry(home, { schema: 1, projects: kept });
+  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 readFileSync3, 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) {
@@ -1241,7 +1549,7 @@ var LockError = class extends Error {
 };
 function readLock(file) {
   try {
-    const raw = JSON.parse(readFileSync3(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 };
     }
@@ -1318,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,
@@ -1358,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);
@@ -1369,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")}`;
 }
 
@@ -1461,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 readFileSync4, 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;
@@ -1486,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 = readFileSync4(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 {
@@ -1496,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 = readFileSync4(file, "utf8");
+        text = readFileSync6(file, "utf8");
       } catch (error) {
         issues.push({ kind: "parse", message: `cannot read ${name2}: ${String(error)}` });
         continue;
@@ -1526,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",
@@ -1550,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) {
@@ -1602,11 +2011,65 @@ 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 existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync5, rmSync as rmSync2 } from "node:fs";
-import { join as join4 } from "node:path";
+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
 var TOKENIZER_VERSION = 1;
@@ -1762,6 +2225,116 @@ function search(index, query, options) {
   }).slice(0, options.limit).map((entry) => ({ id: entry.doc.id, score: Number(entry.normalized.toFixed(6)) }));
 }
 
+// packages/core/src/index/embedding.ts
+var DIMENSIONS = 256;
+function hashFeature(feature) {
+  let hash = 2166136261;
+  for (let index = 0; index < feature.length; index += 1) {
+    hash ^= feature.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+var HashEmbeddingProvider = class {
+  name = "hash-256";
+  dimensions = DIMENSIONS;
+  embed(text) {
+    const vector = new Float32Array(DIMENSIONS);
+    const tokens = tokenize(text);
+    const features = [...tokens, ...tokens.map((token) => `#${token}`)];
+    for (const feature of features) {
+      const bucket = hashFeature(feature) % DIMENSIONS;
+      vector[bucket] = (vector[bucket] ?? 0) + 1;
+    }
+    let norm = 0;
+    for (const value of vector) norm += value * value;
+    norm = Math.sqrt(norm);
+    if (norm > 0) for (let index = 0; index < vector.length; index += 1) vector[index] = (vector[index] ?? 0) / norm;
+    return vector;
+  }
+};
+function cosine(left, right) {
+  if (left.length !== right.length) throw new Error("embedding dimensions differ");
+  let dot = 0;
+  for (let index = 0; index < left.length; index += 1) dot += (left[index] ?? 0) * (right[index] ?? 0);
+  return Math.max(0, Math.min(1, dot));
+}
+
+// packages/core/src/index/hybrid.ts
+function fuseScores(lexical, vector, embeddingWeightPermille) {
+  const weight = Math.min(1e3, Math.max(0, embeddingWeightPermille)) / 1e3;
+  const ids = /* @__PURE__ */ new Set([...lexical.keys(), ...vector.keys()]);
+  const fused = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const lexicalScore = lexical.get(id) ?? 0;
+    const vectorScore = vector.get(id) ?? 0;
+    fused.set(id, (1 - weight) * lexicalScore + weight * vectorScore);
+  }
+  return fused;
+}
+
+// packages/core/src/embed/cache.ts
+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";
+var CACHE_SCHEMA = 1;
+function embeddingsFile(home) {
+  return join4(memoryPaths(home).indexDir, "embeddings.json");
+}
+function readEmbeddingCache(home) {
+  try {
+    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) {
+      return void 0;
+    }
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function vectorizerCommand() {
+  const command = process.env.AGENT_MEMORY_VECTORIZER?.trim();
+  return command === void 0 || command === "" ? void 0 : command;
+}
+async function embedTexts(command, texts) {
+  const dir = mkdtempSync(join4(tmpdir(), "agent-memory-embed-"));
+  const inputPath = join4(dir, "input.json");
+  const outputPath = join4(dir, "output.json");
+  try {
+    writeFileSync4(inputPath, JSON.stringify({ texts }));
+    await new Promise((resolve3, reject) => {
+      const child = spawn(command, [inputPath, outputPath], {
+        stdio: "ignore",
+        shell: true,
+        windowsHide: true
+      });
+      child.once("error", reject);
+      child.once("exit", (code) => {
+        if (code === 0) resolve3();
+        else reject(new Error(`vectorizer exited with ${code ?? "no code"}`));
+      });
+    });
+    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");
+    }
+    let dimensions = 0;
+    for (const vector of parsed.vectors) {
+      if (!Array.isArray(vector) || vector.some((value) => typeof value !== "number" || !Number.isFinite(value))) {
+        throw new Error("vectorizer vectors must be arrays of finite numbers");
+      }
+      if (dimensions === 0) dimensions = vector.length;
+      if (vector.length !== dimensions) throw new Error("vectorizer vectors have inconsistent dimensions");
+    }
+    return { vectors: parsed.vectors, dimensions };
+  } finally {
+    rmSync2(dir, { recursive: true, force: true });
+  }
+}
+
 // packages/core/src/scan/scan.ts
 var ScanError = class extends Error {
   findings;
@@ -1841,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;
@@ -1848,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") {
@@ -1872,9 +2505,10 @@ 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 = join4(this.paths.memoriesDir, kind);
+      const dir = join5(this.paths.memoriesDir, kind);
       let names;
       try {
         names = readdirSync2(dir).filter((name2) => name2.endsWith(".md"));
@@ -1882,15 +2516,23 @@ var MemoryStore = class {
         continue;
       }
       for (const name2 of names) {
-        const file = join4(dir, name2);
+        const file = join5(dir, name2);
         const id = name2.slice(0, -3);
         try {
-          const text = readFileSync5(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;
@@ -1909,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)}`);
         }
@@ -1921,7 +2564,7 @@ var MemoryStore = class {
       }
     }
     try {
-      const manifest = JSON.parse(readFileSync5(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;
@@ -1941,6 +2584,7 @@ var MemoryStore = class {
       }
     } catch {
     }
+    this.lastReloadMs = performance.now() - started;
   }
   active(date = today(this.now())) {
     const live = activeDocs(this.docs.values(), date);
@@ -1961,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,
@@ -1970,15 +2614,44 @@ 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 found = search(index, text, {
-      limit,
-      minScorePermille: this.config.recall.min_score,
-      ...options.kinds === void 0 ? {} : { kinds: options.kinds }
-    });
+    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;
+    if (this.config.recall.hybrid) {
+      const lexicalHits = search(index, text, {
+        limit: activeSet.length,
+        minScorePermille: 0,
+        ...options.kinds === void 0 ? {} : { kinds: options.kinds }
+      });
+      const lexical = new Map(lexicalHits.map((hit) => [hit.id, hit.score]));
+      const provider = new HashEmbeddingProvider();
+      const queryVector = provider.embed(text);
+      const vector = /* @__PURE__ */ new Map();
+      const kindFilter = options.kinds === void 0 ? void 0 : new Set(options.kinds);
+      for (const doc of activeSet) {
+        if (kindFilter !== void 0 && !kindFilter.has(doc.kind)) continue;
+        vector.set(doc.id, cosine(provider.embed(`${doc.abstract}
+${doc.body}`), queryVector));
+      }
+      ranked = [...fuseScores(lexical, vector, this.config.recall.embedding_weight).entries()].filter(([, score]) => score >= minScore).map(([id, score]) => ({ id, score })).sort((left, right) => {
+        if (right.score !== left.score) return right.score - left.score;
+        const leftDoc = byId.get(left.id);
+        const rightDoc = byId.get(right.id);
+        if (leftDoc !== void 0 && rightDoc !== void 0 && rightDoc.valid_from !== leftDoc.valid_from) {
+          return rightDoc.valid_from.localeCompare(leftDoc.valid_from);
+        }
+        return left.id.localeCompare(right.id);
+      }).slice(0, limit);
+    } else {
+      ranked = search(index, text, {
+        limit,
+        minScorePermille: this.config.recall.min_score,
+        ...options.kinds === void 0 ? {} : { kinds: options.kinds }
+      });
+    }
     const hits = [];
-    for (const hit of found) {
+    for (const hit of ranked) {
       const doc = byId.get(hit.id);
       if (doc === void 0) continue;
       hits.push({
@@ -1996,6 +2669,331 @@ var MemoryStore = class {
       warnings: this.quarantined.size === 0 ? [] : [...this.quarantined.values()].slice(0, 5)
     };
   }
+  /**
+   * Hybrid retrieval entry point. Sync `recall` stays BM25/hash-only so the
+   * CLI/tests keep a cheap path; the host calls this async version when the
+   * sidecar vector cache exists.
+   */
+  async recallAsync(query, options = {}) {
+    const text = query.trim();
+    if (text === "" || !this.config.recall.hybrid) return this.recall(query, options);
+    const cache = readEmbeddingCache(this.paths.home);
+    const command = vectorizerCommand();
+    if (cache === void 0 || command === void 0) {
+      const fallback = this.recall(query, options);
+      return {
+        ...fallback,
+        warnings: [
+          ...fallback.warnings,
+          cache === void 0 ? "hybrid requested but .index/embeddings.json is missing; run `mem embed --apply`" : "hybrid requested but AGENT_MEMORY_VECTORIZER is not set"
+        ]
+      };
+    }
+    try {
+      const queryVector = (await embedTexts(command, [text])).vectors[0];
+      if (queryVector === void 0 || queryVector.length !== cache.dimensions) {
+        throw new Error(`query vector does not match cache dimensions (${cache.dimensions})`);
+      }
+      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 = this.indexFor(activeSet, date);
+      const lexicalHits = search(index, text, {
+        limit: activeSet.length,
+        minScorePermille: 0,
+        ...options.kinds === void 0 ? {} : { kinds: options.kinds }
+      });
+      const lexical = new Map(lexicalHits.map((hit) => [hit.id, hit.score]));
+      const kindFilter = options.kinds === void 0 ? void 0 : new Set(options.kinds);
+      const vector = /* @__PURE__ */ new Map();
+      for (const doc of activeSet) {
+        if (kindFilter !== void 0 && !kindFilter.has(doc.kind)) continue;
+        const cached = cache.docs[doc.id];
+        if (cached === void 0 || cached.length !== queryVector.length) continue;
+        let dot = 0;
+        for (let at = 0; at < queryVector.length; at += 1) dot += (queryVector[at] ?? 0) * (cached[at] ?? 0);
+        vector.set(doc.id, Math.max(0, Math.min(1, dot)));
+      }
+      const minScore = this.config.recall.min_score / 1e3;
+      const byId = new Map(activeSet.map((doc) => [doc.id, doc]));
+      const ranked = [...fuseScores(lexical, vector, this.config.recall.embedding_weight).entries()].filter(([, score]) => score >= minScore).map(([id, score]) => ({ id, score })).sort((left, right) => {
+        if (right.score !== left.score) return right.score - left.score;
+        const leftDoc = byId.get(left.id);
+        const rightDoc = byId.get(right.id);
+        if (leftDoc !== void 0 && rightDoc !== void 0 && rightDoc.valid_from !== leftDoc.valid_from) {
+          return rightDoc.valid_from.localeCompare(leftDoc.valid_from);
+        }
+        return left.id.localeCompare(right.id);
+      }).slice(0, limit);
+      const hits = [];
+      for (const hit of ranked) {
+        const doc = byId.get(hit.id);
+        if (doc === void 0) continue;
+        hits.push({
+          id: doc.id,
+          kind: doc.kind,
+          abstract: doc.abstract,
+          score: hit.score,
+          valid_from: doc.valid_from,
+          valid_until: doc.valid_until,
+          provenance_verifiable: doc.provenance.length > 0
+        });
+      }
+      return { hits, warnings: this.quarantined.size === 0 ? [] : [...this.quarantined.values()].slice(0, 5) };
+    } catch (error) {
+      const fallback = this.recall(query, options);
+      return {
+        ...fallback,
+        warnings: [
+          ...fallback.warnings,
+          `hybrid vectorizer failed (${error instanceof Error ? error.message : String(error)}); fell back to lexical`
+        ]
+      };
+    }
+  }
+  /**
+   * Move records between project labels by rewriting only the `project` field.
+   * This is an organisational change, not a supersede: the id and history stay,
+   * and the journal records the new content hash plus an audit line.
+   */
+  moveProjects(ids, project) {
+    const projectIssue = projectProblem(project);
+    if (projectIssue !== void 0) throw new MemoryStoreError("INVALID", projectIssue);
+    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, writes are blocked: ${this.issues[0]}`);
+      }
+      const moved = [];
+      const failed = [];
+      for (const id of ids) {
+        const doc = this.docs.get(id);
+        if (doc === void 0) {
+          failed.push({ id, reason: "not found" });
+          continue;
+        }
+        const next = {
+          id: doc.id,
+          mem_schema: doc.mem_schema,
+          kind: doc.kind,
+          scope: doc.scope,
+          project,
+          tags: doc.tags ?? [],
+          relations: doc.relations ?? [],
+          source: doc.source ?? null,
+          abstract: doc.abstract,
+          created_at: doc.created_at,
+          valid_from: doc.valid_from,
+          valid_until: doc.valid_until,
+          supersedes: doc.supersedes,
+          author: doc.author,
+          evidence_level: doc.evidence_level,
+          error_signatures: doc.error_signatures,
+          provenance: doc.provenance,
+          body: doc.body
+        };
+        const text = serializeMemory(next);
+        const file = join5(this.paths.memoriesDir, doc.kind, `${doc.id}.md`);
+        this.beforeStep?.("before-write");
+        writeFileAtomic(file, text);
+        const hash = hashContent(text);
+        this.journal.append({ op: "record", data: { id, sha256: hash } });
+        this.journal.append({ op: "audit", data: { event: "project-move", id, project } });
+        moved.push(id);
+      }
+      this.reload();
+      this.writeDerived();
+      return { moved, failed };
+    } finally {
+      lock.release();
+    }
+  }
+  /** Update tags/relations in place (organisational metadata, not a revision). */
+  updateMeta(id, patch) {
+    if (patch.tags !== void 0) {
+      const issue = tagsProblem(patch.tags);
+      if (issue !== void 0) throw new MemoryStoreError("INVALID", issue);
+    }
+    if (patch.relations !== void 0) {
+      const issue = relationsProblem(patch.relations, id);
+      if (issue !== void 0) throw new MemoryStoreError("INVALID", issue);
+    }
+    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, writes are blocked: ${this.issues[0]}`);
+      }
+      const doc = this.docs.get(id);
+      if (doc === void 0) throw new MemoryStoreError("NOT_FOUND", `no memory with id ${id}`);
+      const next = {
+        id: doc.id,
+        mem_schema: doc.mem_schema,
+        kind: doc.kind,
+        scope: doc.scope,
+        project: doc.project ?? null,
+        tags: patch.tags ?? doc.tags ?? [],
+        relations: patch.relations ?? doc.relations ?? [],
+        source: doc.source ?? null,
+        abstract: doc.abstract,
+        created_at: doc.created_at,
+        valid_from: doc.valid_from,
+        valid_until: doc.valid_until,
+        supersedes: doc.supersedes,
+        author: doc.author,
+        evidence_level: doc.evidence_level,
+        error_signatures: doc.error_signatures,
+        provenance: doc.provenance,
+        body: doc.body
+      };
+      const text = serializeMemory(next);
+      writeFileAtomic(join5(this.paths.memoriesDir, doc.kind, `${doc.id}.md`), text);
+      this.journal.append({ op: "record", data: { id, sha256: hashContent(text) } });
+      this.journal.append({ op: "audit", data: { event: "memory-meta", id } });
+      this.reload();
+      this.writeDerived();
+      return this.docs.get(id);
+    } finally {
+      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,
@@ -2047,11 +3045,17 @@ var MemoryStore = class {
         throw new MemoryStoreError("INVALID", `valid_from must be a real YYYY-MM-DD date, found ${validFrom}`);
       }
       const duplicateId = this.allocateId(now);
+      const relationIssue = relationsProblem(input.relations ?? [], duplicateId);
+      if (relationIssue !== void 0) throw new MemoryStoreError("INVALID", relationIssue);
       const doc = {
         id: duplicateId,
-        mem_schema: 1,
+        mem_schema: 2,
         kind: input.kind,
         scope: "local",
+        project: input.project ?? null,
+        tags: input.tags ?? [],
+        relations: input.relations ?? [],
+        source: input.source ?? null,
         abstract: input.abstract,
         created_at: now.toISOString(),
         valid_from: validFrom,
@@ -2064,26 +3068,93 @@ var MemoryStore = class {
         body: input.body
       };
       const text = serializeMemory(doc);
-      const filePath = join4(this.paths.memoriesDir, doc.kind, `${doc.id}.md`);
+      const filePath = join5(this.paths.memoriesDir, doc.kind, `${doc.id}.md`);
       this.beforeStep?.("before-write");
-      ensureDir(join4(this.paths.memoriesDir, doc.kind));
+      ensureDir(join5(this.paths.memoriesDir, doc.kind));
       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
@@ -2114,7 +3185,7 @@ var MemoryStore = class {
       if (file === void 0) {
         throw new MemoryStoreError("NOT_FOUND", `no memory file for ${id}`);
       }
-      const text = readFileSync5(file, "utf8");
+      const text = readFileSync8(file, "utf8");
       let doc;
       try {
         doc = parseMemoryFile(text, file, {
@@ -2237,11 +3308,17 @@ var MemoryStore = class {
           this.docs
         );
         if (problems.length > 0) throw new MemoryStoreError("INVALID", problems.join("; "));
+        const relationIssue = relationsProblem(input.relations ?? [], id);
+        if (relationIssue !== void 0) throw new MemoryStoreError("INVALID", relationIssue);
         const doc = {
           id,
-          mem_schema: 1,
+          mem_schema: 2,
           kind: input.kind,
           scope: "local",
+          project: input.project ?? null,
+          tags: input.tags ?? [],
+          relations: input.relations ?? [],
+          source: input.source ?? null,
           abstract: input.abstract,
           created_at: now.toISOString(),
           valid_from: input.valid_from ?? today(now),
@@ -2259,29 +3336,47 @@ var MemoryStore = class {
       const written = [];
       try {
         for (const entry of prepared) {
-          const file = join4(this.paths.memoriesDir, entry.kind, `${entry.id}.md`);
-          ensureDir(join4(this.paths.memoriesDir, entry.kind));
+          const file = join5(this.paths.memoriesDir, entry.kind, `${entry.id}.md`);
+          ensureDir(join5(this.paths.memoriesDir, entry.kind));
           writeFileAtomic(file, entry.text);
           written.push(file);
         }
       } catch (error) {
-        for (const file of written) rmSync2(file, { force: true });
+        for (const file of written) rmSync3(file, { force: true });
         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,
@@ -2341,7 +3436,7 @@ var MemoryStore = class {
         op: "delete",
         data: { id, purged: true, reason: options.reason, sha256: doc?.content_hash ?? "" }
       });
-      rmSync2(file, { force: true });
+      rmSync3(file, { force: true });
       let proposals = 0;
       let names = [];
       try {
@@ -2350,11 +3445,11 @@ var MemoryStore = class {
         names = [];
       }
       for (const name2 of names) {
-        const path = join4(this.paths.pendingDir, name2);
+        const path = join5(this.paths.pendingDir, name2);
         try {
-          const proposal = JSON.parse(readFileSync5(path, "utf8"));
+          const proposal = JSON.parse(readFileSync8(path, "utf8"));
           if (Array.isArray(proposal.targets) && proposal.targets.includes(id)) {
-            rmSync2(path, { force: true });
+            rmSync3(path, { force: true });
             this.journal.append({
               op: "audit",
               data: { event: "proposal-invalidated", proposal: proposal.id ?? name2, target: id }
@@ -2390,7 +3485,8 @@ var MemoryStore = class {
           `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,
@@ -2406,9 +3502,25 @@ var MemoryStore = class {
   }
   /** 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,
@@ -2440,11 +3552,49 @@ var MemoryStore = class {
     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)) {
       throw new MemoryStoreError("INVALID", `kind must be one of ${KINDS2.join(", ")}`);
     }
+    const projectIssue = projectProblem(input.project ?? null);
+    if (projectIssue !== void 0) throw new MemoryStoreError("INVALID", projectIssue);
+    const tagsIssue = tagsProblem(input.tags ?? []);
+    if (tagsIssue !== void 0) throw new MemoryStoreError("INVALID", tagsIssue);
+    const sourceIssue = sourceProblem(input.source ?? null);
+    if (sourceIssue !== void 0) throw new MemoryStoreError("INVALID", sourceIssue);
     if (typeof input.abstract !== "string" || input.abstract.trim() === "") {
       throw new MemoryStoreError("INVALID", "abstract must not be empty");
     }
@@ -2490,8 +3640,8 @@ var MemoryStore = class {
   }
   findMemoryFile(id) {
     for (const kind of KINDS2) {
-      const file = join4(this.paths.memoriesDir, kind, `${id}.md`);
-      if (existsSync3(file)) return file;
+      const file = join5(this.paths.memoriesDir, kind, `${id}.md`);
+      if (existsSync6(file)) return file;
     }
     return void 0;
   }
@@ -2510,7 +3660,7 @@ var MemoryStore = class {
   allocateId(now) {
     for (let attempt = 0; attempt < 100; attempt += 1) {
       const id = newMemoryId(now);
-      const exists = this.docs.has(id) || this.accounted.has(id) || existsSync3(join4(this.paths.memoriesDir, "fact", `${id}.md`)) || existsSync3(join4(this.paths.memoriesDir, "pitfall", `${id}.md`)) || existsSync3(join4(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");
@@ -2525,8 +3675,8 @@ function countPending(dir) {
 }
 
 // packages/core/src/rules/rules.ts
-import { existsSync as existsSync4, readFileSync as readFileSync6 } from "node:fs";
-import { join as join5 } from "node:path";
+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*(.+)$/;
 function parseRules(text) {
@@ -2581,9 +3731,9 @@ function parseRules(text) {
 function checkSymbolExists(check, rootDir) {
   const [path, symbol] = check.split("#");
   if (path === void 0 || symbol === void 0 || path === "" || symbol === "") return false;
-  const file = join5(rootDir, path);
-  if (!existsSync4(file)) return false;
-  return readFileSync6(file, "utf8").includes(symbol);
+  const file = join6(rootDir, path);
+  if (!existsSync7(file)) return false;
+  return readFileSync9(file, "utf8").includes(symbol);
 }
 function validateRules(rules, options) {
   const errors = [];
@@ -2593,12 +3743,12 @@ function validateRules(rules, options) {
       errors.push(`rule ${rule.number}: check "${rule.check ?? ""}" does not name an existing symbol`);
     }
     if (rule.test === void 0) continue;
-    const testFile = join5(options.rootDir, rule.test);
-    if (!existsSync4(testFile)) {
+    const testFile = join6(options.rootDir, rule.test);
+    if (!existsSync7(testFile)) {
       errors.push(`rule ${rule.number}: test file "${rule.test}" does not exist`);
       continue;
     }
-    if (!/\[neg\]/.test(readFileSync6(testFile, "utf8"))) {
+    if (!/\[neg\]/.test(readFileSync9(testFile, "utf8"))) {
       errors.push(`rule ${rule.number}: test file "${rule.test}" has no [neg] case`);
     }
   }
@@ -2610,8 +3760,8 @@ function parseAndValidateRules(text, options) {
 }
 function loadRules(home) {
   const file = memoryPaths(home).rulesFile;
-  if (!existsSync4(file)) return [];
-  return parseRules(readFileSync6(file, "utf8")).rules;
+  if (!existsSync7(file)) return [];
+  return parseRules(readFileSync9(file, "utf8")).rules;
 }
 function renderRules(rules, options = {}) {
   const lines = [];
@@ -2624,7 +3774,7 @@ function renderRules(rules, options = {}) {
 }
 function readRulesFile(home) {
   const file = memoryPaths(home).rulesFile;
-  return existsSync4(file) ? readFileSync6(file, "utf8") : "";
+  return existsSync7(file) ? readFileSync9(file, "utf8") : "";
 }
 function saveRulesFile(home, text) {
   const parsed = parseAndValidateRules(text, { rootDir: home });
@@ -2635,20 +3785,20 @@ function saveRulesFile(home, text) {
 }
 
 // packages/core/src/inject/snapshot.ts
-import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync7, readdirSync as readdirSync3, rmSync as rmSync3, statSync as statSync4 } from "node:fs";
-import { join as join6 } from "node:path";
+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);
-  return join6(memoryPaths(home).snapshotsDir, `${name2}.json`);
+  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 (!existsSync5(file)) return null;
+  if (!existsSync8(file)) return null;
   try {
-    const record = JSON.parse(readFileSync7(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;
     }
@@ -2671,20 +3821,20 @@ function pruneSnapshots(home, keep = SNAPSHOT_KEEP) {
     return;
   }
   if (names.length <= keep) return;
-  const byAge = names.map((name2) => ({ name: name2, mtime: statSync4(join6(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 {
-      rmSync3(join6(dir, entry.name), { force: true });
+      rmSync4(join7(dir, entry.name), { force: true });
     } catch {
     }
   }
 }
 
 // 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 existsSync6, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync11 } from "node:fs";
 
 // packages/core/src/personalization/guidance.ts
 function renderGuidance(mode) {
@@ -2711,7 +3861,7 @@ function truncate(text, budget) {
   return `${points.slice(0, budget - 1).join("")}\u2026`;
 }
 function readIfExists(file) {
-  return existsSync6(file) ? readFileSync8(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) {
@@ -2799,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) => {
@@ -2882,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}
@@ -2932,8 +4082,8 @@ ${escaped}
 }
 
 // packages/core/src/proposals/proposals.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync9, rmSync as rmSync4 } from "node:fs";
-import { join as join7 } from "node:path";
+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;
   constructor(code, message) {
@@ -2946,7 +4096,7 @@ function pendingDir(store) {
   return store.paths.pendingDir;
 }
 function proposalPath(store, id) {
-  return join7(pendingDir(store), `${id}.json`);
+  return join8(pendingDir(store), `${id}.json`);
 }
 function listProposals(store) {
   let names;
@@ -2958,7 +4108,7 @@ function listProposals(store) {
   const proposals = [];
   for (const name2 of names) {
     try {
-      proposals.push(JSON.parse(readFileSync9(join7(pendingDir(store), name2), "utf8")));
+      proposals.push(JSON.parse(readFileSync12(join8(pendingDir(store), name2), "utf8")));
     } catch {
     }
   }
@@ -2966,8 +4116,8 @@ function listProposals(store) {
 }
 function readProposal(store, id) {
   const file = proposalPath(store, id);
-  if (!existsSync7(file)) throw new ProposalError("NOT_FOUND", `no pending proposal ${id}`);
-  return JSON.parse(readFileSync9(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);
@@ -3033,7 +4183,7 @@ function decideProposal(deps, input) {
   const proposal = readProposal(store, input.id);
   if (input.decision === "reject") {
     store.appendJournal("decide", { proposal: proposal.id, decision: "reject", reason: input.reason ?? "" });
-    rmSync4(proposalPath(store, proposal.id), { force: true });
+    rmSync5(proposalPath(store, proposal.id), { force: true });
     return;
   }
   if (proposal.op === "delete") {
@@ -3044,13 +4194,13 @@ function decideProposal(deps, input) {
     }
     store.remove(target, { reason: proposal.reason, baseHash: hash });
     store.journal.append({ op: "decide", data: { proposal: proposal.id, decision: "accept" } });
-    rmSync4(proposalPath(store, proposal.id), { force: true });
+    rmSync5(proposalPath(store, proposal.id), { force: true });
     return;
   }
   if (proposal.op === "create") {
     store.addMany(proposal.replacements, { author: "human", opId: `decide-${proposal.id}` });
     store.appendJournal("decide", { proposal: proposal.id, decision: "accept" });
-    rmSync4(proposalPath(store, proposal.id), { force: true });
+    rmSync5(proposalPath(store, proposal.id), { force: true });
     return;
   }
   proposal.targets.forEach((target, index) => {
@@ -3063,11 +4213,11 @@ function decideProposal(deps, input) {
     { author: "human", opId: `decide-${proposal.id}` }
   );
   store.appendJournal("decide", { proposal: proposal.id, decision: "accept" });
-  rmSync4(proposalPath(store, proposal.id), { force: true });
+  rmSync5(proposalPath(store, proposal.id), { force: true });
 }
 
 // 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);
@@ -3087,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 {
@@ -3096,7 +4246,7 @@ function bindEvidence(input) {
     event_seq: input.eventSeq,
     speaker: event.speaker,
     quote: input.quote,
-    event_sha256: sha256
+    event_sha256: sha2562
   };
 }
 
@@ -3120,14 +4270,14 @@ var SessionQuota = class {
 };
 
 // packages/core/src/distill/closeout.ts
-import { createHash as createHash7 } from "node:crypto";
-import { existsSync as existsSync8, readFileSync as readFileSync10 } from "node:fs";
-import { join as join8 } from "node:path";
+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 = join8(memoryPaths(home).stateDir, "distill-rejected.json");
-  if (!existsSync8(file)) return /* @__PURE__ */ new Set();
+  const file = join9(memoryPaths(home).stateDir, "distill-rejected.json");
+  if (!existsSync11(file)) return /* @__PURE__ */ new Set();
   try {
-    const parsed = JSON.parse(readFileSync10(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();
@@ -3137,7 +4287,7 @@ function addRejected(home, hashes) {
   const set = loadRejected(home);
   for (const hash of hashes) set.add(hash);
   writeFileAtomic(
-    join8(memoryPaths(home).stateDir, "distill-rejected.json"),
+    join9(memoryPaths(home).stateDir, "distill-rejected.json"),
     `${JSON.stringify({ hashes: [...set].sort() }, null, 2)}
 `
   );
@@ -3211,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("{");
@@ -3380,9 +4530,9 @@ var CloseoutRound = class {
 };
 
 // packages/core/src/ops/ops.ts
-import { createHash as createHash8 } from "node:crypto";
-import { cpSync, existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync11, readdirSync as readdirSync5, statSync as statSync5, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join9, relative } from "node:path";
+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",
   "policy.json",
@@ -3399,9 +4549,9 @@ function exportStore(options) {
   const paths = memoryPaths(options.home);
   mkdirSync3(options.out, { recursive: true });
   for (const entry of INCLUDE) {
-    const source = join9(paths.home, entry);
-    if (!existsSync9(source)) continue;
-    const target = join9(options.out, entry);
+    const source = join10(paths.home, entry);
+    if (!existsSync12(source)) continue;
+    const target = join10(options.out, entry);
     cpSync(source, target, { recursive: true });
   }
   const lines = [];
@@ -3409,22 +4559,22 @@ function exportStore(options) {
   let bytes = 0;
   const walk2 = (dir, base) => {
     for (const name2 of readdirSync5(dir)) {
-      const full = join9(dir, name2);
-      if (statSync5(full).isDirectory()) {
+      const full = join10(dir, name2);
+      if (statSync6(full).isDirectory()) {
         walk2(full, base);
         continue;
       }
       const rel = relative(base, full).replaceAll("\\", "/");
-      const data = readFileSync11(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;
     }
   };
   walk2(options.out, options.out);
   lines.sort();
-  const sums = join9(options.out, "SHA256SUMS");
-  writeFileSync3(sums, `${lines.join("\n")}
+  const sums = join10(options.out, "SHA256SUMS");
+  writeFileSync6(sums, `${lines.join("\n")}
 `, "utf8");
   return { out: options.out, files, bytes, sums };
 }
@@ -3432,8 +4582,8 @@ function personalizationChars(home) {
   const paths = memoryPaths(home);
   const charsOf = (file) => {
     try {
-      if (!existsSync9(file)) return 0;
-      return [...readFileSync11(file, "utf8").replace(/<!--[\s\S]*?-->/g, "")].length;
+      if (!existsSync12(file)) return 0;
+      return [...readFileSync14(file, "utf8").replace(/<!--[\s\S]*?-->/g, "")].length;
     } catch {
       return 0;
     }
@@ -3474,7 +4624,7 @@ function inspectStore(options) {
 }
 
 // packages/core/src/profile/profile.ts
-import { existsSync as existsSync10, readFileSync as readFileSync12 } 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 {
@@ -3534,7 +4684,7 @@ function validateProfileEntries(entries) {
 }
 function loadProfile(home) {
   const file = memoryPaths(home).userFile;
-  const text = existsSync10(file) ? readFileSync12(file, "utf8") : "";
+  const text = existsSync13(file) ? readFileSync15(file, "utf8") : "";
   const entries = parseProfileEntries(text);
   return { entries, chars: profileChars(entries) };
 }
@@ -3563,7 +4713,7 @@ function findProfileEntry(entries, oldText) {
 }
 
 // packages/core/src/personalization/scaffold.ts
-import { existsSync as existsSync11 } 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
@@ -3595,7 +4745,7 @@ function scaffoldPersonalization(options) {
   const created = [];
   const kept = [];
   for (const [file, template] of targets) {
-    if (existsSync11(file)) {
+    if (existsSync14(file)) {
       kept.push(file);
       continue;
     }
@@ -3965,8 +5115,8 @@ var LEVELS = /* @__PURE__ */ new Set(["user_explicit", "user_confirmed", "observ
 function importBundle(store, bundle) {
   if (typeof bundle !== "object" || bundle === null) throw new Error("bundle must be an object");
   const record = bundle;
-  if (record.format !== "agent-memory-export-v1") {
-    throw new Error("unsupported bundle format (expected agent-memory-export-v1)");
+  if (record.format !== "agent-memory-export-v1" && record.format !== "agent-memory-export-v2") {
+    throw new Error("unsupported bundle format (expected agent-memory-export-v1 or v2)");
   }
   if (!Array.isArray(record.memories)) throw new Error("bundle.memories must be an array");
   let imported = 0;
@@ -3988,6 +5138,14 @@ function importBundle(store, bundle) {
           kind: raw.kind,
           abstract,
           body,
+          ...typeof raw.project === "string" || raw.project === null ? { project: raw.project } : {},
+          ...Array.isArray(raw.tags) ? { tags: raw.tags.filter((entry) => typeof entry === "string") } : {},
+          ...Array.isArray(raw.relations) ? {
+            relations: raw.relations.filter(
+              (entry) => typeof entry === "object" && entry !== null && typeof entry.type === "string" && typeof entry.target === "string"
+            )
+          } : {},
+          ...typeof raw.source === "object" && raw.source !== null && typeof raw.source.type === "string" && typeof raw.source.id === "string" ? { source: { type: raw.source.type, id: raw.source.id } } : {},
           evidence_level: evidenceLevel,
           ...typeof raw.valid_from === "string" ? { valid_from: raw.valid_from } : {},
           ...Array.isArray(raw.error_signatures) ? { error_signatures: raw.error_signatures.filter((entry) => typeof entry === "string") } : {}
@@ -4037,6 +5195,8 @@ var TOOL_SCHEMAS = {
         )
       },
       valid_from: { type: "string" },
+      project: { type: "string" },
+      tags: { type: "array", items: { type: "string" }, maxItems: 8 },
       error_signatures: { type: "array", items: { type: "string" }, maxItems: 3 }
     },
     ["kind", "abstract", "body", "evidence"]
@@ -4063,6 +5223,8 @@ var TOOL_SCHEMAS = {
               )
             },
             valid_from: { type: "string" },
+            project: { type: "string" },
+            tags: { type: "array", items: { type: "string" }, maxItems: 8 },
             error_signatures: { type: "array", items: { type: "string" }, maxItems: 3 }
           },
           ["kind", "abstract", "body", "evidence"]
@@ -4804,6 +5966,10 @@ function summary(doc, serial) {
     id: doc.id,
     kind: doc.kind,
     abstract: doc.abstract,
+    project: doc.project ?? null,
+    tags: doc.tags ?? [],
+    relations: doc.relations ?? [],
+    source: doc.source ?? null,
     author: doc.author,
     valid_from: doc.valid_from,
     valid_until: doc.valid_until,
@@ -4837,8 +6003,8 @@ function buildItem(store, id) {
     content_hash: doc.content_hash
   };
 }
-function buildSearch(store, query, limit = 20) {
-  const result = store.recall(query, { limit });
+async function buildSearch(store, query, limit = 20) {
+  const result = await store.recallAsync(query, { limit });
   const serials = serialsFor(store.active());
   return {
     query,
@@ -4853,6 +6019,73 @@ function buildSearch(store, query, limit = 20) {
     warnings: result.warnings
   };
 }
+function buildGraph(store, home) {
+  const active = store.active();
+  const serials = serialsFor(active);
+  const registered = listProjects(home).map((project) => project.name);
+  const registeredSet = new Set(registered);
+  const effectiveProject = (doc) => doc.project !== null && doc.project !== void 0 && registeredSet.has(doc.project) ? doc.project : "\u672A\u5F52\u7C7B";
+  const names = new Set(registered);
+  for (const doc of active) names.add(effectiveProject(doc));
+  const projects = [...names].map((name2) => {
+    const docs = active.filter((doc) => effectiveProject(doc) === name2);
+    const last = docs.map((doc) => doc.valid_from).sort().at(-1) ?? null;
+    return { name: name2, count: docs.length, last_updated: last };
+  });
+  projects.sort((left, right) => right.count - left.count || left.name.localeCompare(right.name));
+  const limited = active.slice().sort((left, right) => right.valid_from.localeCompare(left.valid_from) || right.created_at.localeCompare(left.created_at)).slice(0, 200);
+  const ids = new Set(limited.map((doc) => doc.id));
+  const nodes = limited.map((doc) => {
+    const serial = serials.get(doc.id) ?? "";
+    return {
+      id: doc.id,
+      serial,
+      display: displayName(serial, doc.abstract),
+      kind: doc.kind,
+      project: effectiveProject(doc),
+      tags: doc.tags ?? [],
+      relations: (doc.relations ?? []).map((relation) => ({ type: relation.type, target: relation.target })),
+      supersedes: doc.supersedes,
+      valid_from: doc.valid_from
+    };
+  });
+  const edges = [];
+  for (const doc of limited) {
+    for (const target of doc.supersedes) {
+      if (ids.has(target)) edges.push({ from: doc.id, to: target, type: "supersedes" });
+    }
+    for (const relation of doc.relations ?? []) {
+      if (ids.has(relation.target)) edges.push({ from: doc.id, to: relation.target, type: relation.type });
+    }
+  }
+  const conflicts = [];
+  for (let left = 0; left < limited.length; left += 1) {
+    for (let right = left + 1; right < limited.length; right += 1) {
+      const a = limited[left];
+      const b = limited[right];
+      if (effectiveProject(a) !== effectiveProject(b)) continue;
+      const shared = (a.tags ?? []).some((tag) => (b.tags ?? []).includes(tag));
+      if (!shared) continue;
+      const charsA = /* @__PURE__ */ new Set([...a.abstract.replace(/\s+/g, "")]);
+      const charsB = /* @__PURE__ */ new Set([...b.abstract.replace(/\s+/g, "")]);
+      let overlap = 0;
+      for (const char of charsA) if (charsB.has(char)) overlap += 1;
+      const similarity = overlap / Math.max(1, (/* @__PURE__ */ new Set([...charsA, ...charsB])).size);
+      if (similarity >= 0.8) {
+        conflicts.push({ a: a.id, b: b.id, project: effectiveProject(a), reason: "\u540C\u9879\u76EE\u540C\u6807\u7B7E\u4E14\u6458\u8981\u9AD8\u5EA6\u91CD\u53E0" });
+      }
+    }
+  }
+  return {
+    schema: 1,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    truncated: active.length > limited.length,
+    projects,
+    nodes,
+    edges,
+    conflicts
+  };
+}
 function exportBundle(store) {
   const active = store.active();
   const serials = serialsFor(active);
@@ -4864,7 +6097,7 @@ function exportBundle(store) {
     content_hash: doc.content_hash
   }));
   return {
-    format: "agent-memory-export-v1",
+    format: "agent-memory-export-v2",
     exported_at: (/* @__PURE__ */ new Date()).toISOString(),
     memories,
     proposals: listProposals(store).map((proposal) => ({
@@ -4974,7 +6207,11 @@ function saveRulesGui(home, store, text) {
 function json(value, status = 200) {
   return new Response(JSON.stringify(value), {
     status,
-    headers: { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" }
+    headers: {
+      "content-type": "application/json; charset=utf-8",
+      "cache-control": "no-store",
+      "x-agent-memory-api-version": "1"
+    }
   });
 }
 function errorResponse(message, status = 400) {
@@ -5012,6 +6249,87 @@ function guiRoutes(deps) {
     requestBody: "buffered",
     fetch: async () => json(buildList(deps.store))
   };
+  const graph = {
+    path: "/api/agent-memory/graph",
+    methods: ["GET"],
+    requestBody: "buffered",
+    fetch: async () => json(buildGraph(deps.store, deps.home))
+  };
+  const projects = {
+    path: "/api/agent-memory/projects",
+    methods: ["GET", "POST", "DELETE"],
+    requestBody: "buffered",
+    fetch: async (request) => {
+      if (request.method === "GET") return json({ projects: listProjects(deps.home) });
+      if (request.method === "DELETE") {
+        const name2 = new URL(request.url).searchParams.get("name") ?? "";
+        if (name2 === "") return errorResponse("name is required");
+        return deleteProject(deps.home, name2) ? json({ ok: true }) : errorResponse("project not found", 404);
+      }
+      const body = await readJson(request);
+      if (typeof body.name !== "string" || body.name.trim() === "") return errorResponse("name is required");
+      try {
+        const project = createProject({
+          home: deps.home,
+          name: body.name,
+          ...typeof body.description === "string" ? { description: body.description } : {}
+        });
+        return json({ project });
+      } catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error), 409);
+      }
+    }
+  };
+  const moveProject = {
+    path: "/api/agent-memory/projects/move",
+    methods: ["POST"],
+    requestBody: "buffered",
+    fetch: async (request) => {
+      const body = await readJson(request);
+      if (!Array.isArray(body.ids) || body.ids.some((id) => typeof id !== "string")) {
+        return errorResponse("ids must be a string array");
+      }
+      if (body.project !== null && typeof body.project !== "string") {
+        return errorResponse("project must be a string or null");
+      }
+      const target = body.project;
+      if (target !== null && !listProjects(deps.home).some((project) => project.name === target)) {
+        return errorResponse(`unknown project: ${target}`, 409);
+      }
+      try {
+        const result = deps.store.moveProjects(body.ids, target);
+        return json({ ok: true, ...result });
+      } catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error), 409);
+      }
+    }
+  };
+  const meta = {
+    path: "/api/agent-memory/meta",
+    methods: ["POST"],
+    requestBody: "buffered",
+    fetch: async (request) => {
+      const body = await readJson(request);
+      if (typeof body.id !== "string" || body.id === "") return errorResponse("id is required");
+      if (body.tags !== void 0 && (!Array.isArray(body.tags) || body.tags.some((tag) => typeof tag !== "string"))) {
+        return errorResponse("tags must be a string array");
+      }
+      if (body.relations !== void 0 && (!Array.isArray(body.relations) || body.relations.some(
+        (relation) => typeof relation !== "object" || relation === null || typeof relation.type !== "string" || typeof relation.target !== "string"
+      ))) {
+        return errorResponse("relations must be {type,target} objects");
+      }
+      try {
+        const doc = deps.store.updateMeta(body.id, {
+          ...body.tags === void 0 ? {} : { tags: body.tags },
+          ...body.relations === void 0 ? {} : { relations: body.relations }
+        });
+        return json({ ok: true, id: doc.id, project: doc.project ?? null, tags: doc.tags ?? [], relations: doc.relations ?? [] });
+      } catch (error) {
+        return errorResponse(error instanceof Error ? error.message : String(error), 409);
+      }
+    }
+  };
   const item = {
     path: "/api/agent-memory/item",
     methods: ["GET"],
@@ -5033,7 +6351,7 @@ function guiRoutes(deps) {
     fetch: async (request) => {
       const query = (new URL(request.url).searchParams.get("q") ?? "").trim();
       if (query === "") return errorResponse("q is required");
-      return json(buildSearch(deps.store, query));
+      return json(await buildSearch(deps.store, query));
     }
   };
   const exportRoute = {
@@ -5209,6 +6527,10 @@ function guiRoutes(deps) {
   return [
     status,
     list,
+    graph,
+    projects,
+    moveProject,
+    meta,
     item,
     search2,
     exportRoute,
@@ -5292,8 +6614,8 @@ function openHostService(home, session, options = {}) {
     mode: runtime.config.personalization.mode,
     session,
     config: runtime.config,
-    recall(input) {
-      return store.recall(input.query, {
+    async recall(input) {
+      return store.recallAsync(input.query, {
         ...input.limit === void 0 ? {} : { limit: input.limit },
         ...input.kind === void 0 ? {} : { kinds: [input.kind] }
       });
@@ -5324,6 +6646,8 @@ function openHostService(home, session, options = {}) {
           body: raw.body,
           evidence_level: "observed",
           ...raw.valid_from === void 0 ? {} : { valid_from: raw.valid_from },
+          ...raw.project === void 0 ? {} : { project: raw.project },
+          ...raw.tags === void 0 ? {} : { tags: raw.tags },
           ...raw.error_signatures === void 0 ? {} : { error_signatures: raw.error_signatures }
         },
         { author: "agent", provenance }
@@ -5372,6 +6696,8 @@ function openHostService(home, session, options = {}) {
           body: replacement.body,
           evidence_level: replacement.evidence_level ?? "observed",
           ...replacement.valid_from === void 0 ? {} : { valid_from: replacement.valid_from },
+          ...replacement.project === void 0 ? {} : { project: replacement.project },
+          ...replacement.tags === void 0 ? {} : { tags: replacement.tags },
           ...replacement.error_signatures === void 0 ? {} : { error_signatures: replacement.error_signatures },
           provenance
         });