@agent_memory/dsh 0.2.1 → 0.4.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"),
@@ -553,7 +554,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 +721,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 +809,10 @@ var FIELD_ORDER = [
   "mem_schema",
   "kind",
   "scope",
+  "project",
+  "tags",
+  "relations",
+  "source",
   "abstract",
   "created_at",
   "valid_from",
@@ -805,10 +885,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 +983,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 +1010,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,
@@ -1228,9 +1338,99 @@ 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/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 { closeSync as closeSync2, fsyncSync as fsyncSync2, openSync as openSync2, readFileSync as readFileSync4, statSync as statSync2, unlinkSync, writeFileSync as writeFileSync2, writeSync } from "node:fs";
 var LockError = class extends Error {
   code;
   constructor(code, message) {
@@ -1241,7 +1441,7 @@ var LockError = class extends Error {
 };
 function readLock(file) {
   try {
-    const raw = JSON.parse(readFileSync3(file, "utf8"));
+    const raw = JSON.parse(readFileSync4(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 };
     }
@@ -1462,7 +1662,7 @@ 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 { closeSync as closeSync3, fsyncSync as fsyncSync3, mkdirSync as mkdirSync2, openSync as openSync3, readFileSync as readFileSync5, readdirSync, statSync as statSync3, writeSync as writeSync2 } from "node:fs";
 import { join as join3 } from "node:path";
 var SEGMENT_BYTES = 5 * 1024 * 1024;
 var ZERO_HASH = "0".repeat(64);
@@ -1486,7 +1686,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 = readFileSync5(file, "utf8").split("\n").filter((line) => line !== "");
       if (lines.length === 0) continue;
       const last = lines[lines.length - 1];
       try {
@@ -1509,7 +1709,7 @@ var Journal = class {
       const file = join3(this.dir, name2);
       let text;
       try {
-        text = readFileSync4(file, "utf8");
+        text = readFileSync5(file, "utf8");
       } catch (error) {
         issues.push({ kind: "parse", message: `cannot read ${name2}: ${String(error)}` });
         continue;
@@ -1605,8 +1805,8 @@ var Journal = class {
 };
 
 // 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 existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync7, rmSync as rmSync3 } from "node:fs";
+import { join as join5 } from "node:path";
 
 // packages/core/src/index/tokenizer.ts
 var TOKENIZER_VERSION = 1;
@@ -1762,6 +1962,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 readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync3 } 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(readFileSync6(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 {
+    writeFileSync3(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(readFileSync6(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;
@@ -1874,7 +2184,7 @@ var MemoryStore = class {
       if (value.hash !== "") this.accounted.set(id, value.hash);
     }
     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,10 +2192,10 @@ 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 text = readFileSync7(file, "utf8");
           const doc = parseMemoryFile(text, file, {
             abstractChars: this.config.limits.abstract_chars,
             bodyChars: this.config.limits.body_chars,
@@ -1921,7 +2231,7 @@ var MemoryStore = class {
       }
     }
     try {
-      const manifest = JSON.parse(readFileSync5(this.paths.manifestFile, "utf8"));
+      const manifest = JSON.parse(readFileSync7(this.paths.manifestFile, "utf8"));
       const expected = manifest.journal_head;
       const expectedSeq = expected?.seq;
       const expectedHash = expected?.hash;
@@ -1971,14 +2281,43 @@ var MemoryStore = class {
       (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 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 +2335,214 @@ 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.reload();
+      const date = options.asOf ?? today(this.now());
+      const limit = Math.min(options.limit ?? this.config.recall.limit, this.config.recall.max_limit);
+      const activeSet = activeDocs(this.docs.values(), date).filter(
+        (doc) => !this.deleted.has(doc.id) && !this.quarantined.has(doc.id)
+      );
+      const index = buildIndex(activeSet, TOKENIZER_VERSION);
+      const 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();
+    }
+  }
   stats() {
     return {
       active: this.active().length,
@@ -2047,11 +2594,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,9 +2617,9 @@ 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);
@@ -2114,7 +2667,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 = readFileSync7(file, "utf8");
       let doc;
       try {
         doc = parseMemoryFile(text, file, {
@@ -2237,11 +2790,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,13 +2818,13 @@ 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");
@@ -2341,7 +2900,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 +2909,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(readFileSync7(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 }
@@ -2445,6 +3004,12 @@ var MemoryStore = class {
     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 +3055,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 (existsSync4(file)) return file;
     }
     return void 0;
   }
@@ -2510,7 +3075,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) || existsSync4(join5(this.paths.memoriesDir, "fact", `${id}.md`)) || existsSync4(join5(this.paths.memoriesDir, "pitfall", `${id}.md`)) || existsSync4(join5(this.paths.memoriesDir, "exp", `${id}.md`));
       if (!exists) return id;
     }
     throw new MemoryStoreError("CONFLICT", "could not allocate a unique memory id");
@@ -2525,8 +3090,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 existsSync5, readFileSync as readFileSync8 } 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 +3146,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 (!existsSync5(file)) return false;
+  return readFileSync8(file, "utf8").includes(symbol);
 }
 function validateRules(rules, options) {
   const errors = [];
@@ -2593,12 +3158,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 (!existsSync5(testFile)) {
       errors.push(`rule ${rule.number}: test file "${rule.test}" does not exist`);
       continue;
     }
-    if (!/\[neg\]/.test(readFileSync6(testFile, "utf8"))) {
+    if (!/\[neg\]/.test(readFileSync8(testFile, "utf8"))) {
       errors.push(`rule ${rule.number}: test file "${rule.test}" has no [neg] case`);
     }
   }
@@ -2610,8 +3175,8 @@ function parseAndValidateRules(text, options) {
 }
 function loadRules(home) {
   const file = memoryPaths(home).rulesFile;
-  if (!existsSync4(file)) return [];
-  return parseRules(readFileSync6(file, "utf8")).rules;
+  if (!existsSync5(file)) return [];
+  return parseRules(readFileSync8(file, "utf8")).rules;
 }
 function renderRules(rules, options = {}) {
   const lines = [];
@@ -2624,7 +3189,7 @@ function renderRules(rules, options = {}) {
 }
 function readRulesFile(home) {
   const file = memoryPaths(home).rulesFile;
-  return existsSync4(file) ? readFileSync6(file, "utf8") : "";
+  return existsSync5(file) ? readFileSync8(file, "utf8") : "";
 }
 function saveRulesFile(home, text) {
   const parsed = parseAndValidateRules(text, { rootDir: home });
@@ -2636,19 +3201,19 @@ 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 { existsSync as existsSync6, readFileSync as readFileSync9, readdirSync as readdirSync3, rmSync as rmSync4, statSync as statSync4 } 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`);
+  return join7(memoryPaths(home).snapshotsDir, `${name2}.json`);
 }
 function readSnapshot(home, sessionId) {
   const file = snapshotPath(home, sessionId);
-  if (!existsSync5(file)) return null;
+  if (!existsSync6(file)) return null;
   try {
-    const record = JSON.parse(readFileSync7(file, "utf8"));
+    const record = JSON.parse(readFileSync9(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,10 +3236,10 @@ 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: statSync4(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 {
     }
   }
@@ -2684,7 +3249,7 @@ function pruneSnapshots(home, keep = SNAPSHOT_KEEP) {
 import { createHash as createHash5, randomBytes as randomBytes4 } from "node:crypto";
 
 // packages/core/src/inject/sections.ts
-import { existsSync as existsSync6, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync10 } from "node:fs";
 
 // packages/core/src/personalization/guidance.ts
 function renderGuidance(mode) {
@@ -2711,7 +3276,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 existsSync7(file) ? readFileSync10(file, "utf8").replace(COMMENT, "").trim() : "";
 }
 var SECTION_ORDERS = { SOUL: 100, GUIDANCE: 110, RULES: 150, USER: 200, MEMORY: 300 };
 function builtinSectionSources(context) {
@@ -2932,8 +3497,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 existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync11, rmSync as rmSync5 } from "node:fs";
+import { join as join8 } from "node:path";
 var ProposalError = class extends Error {
   code;
   constructor(code, message) {
@@ -2946,7 +3511,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 +3523,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(readFileSync11(join8(pendingDir(store), name2), "utf8")));
     } catch {
     }
   }
@@ -2966,8 +3531,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 (!existsSync8(file)) throw new ProposalError("NOT_FOUND", `no pending proposal ${id}`);
+  return JSON.parse(readFileSync11(file, "utf8"));
 }
 function currentHash(store, id) {
   const doc = store.read(id);
@@ -3033,7 +3598,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 +3609,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,7 +3628,7 @@ 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
@@ -3121,13 +3686,13 @@ 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 { existsSync as existsSync9, readFileSync as readFileSync12 } 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 (!existsSync9(file)) return /* @__PURE__ */ new Set();
   try {
-    const parsed = JSON.parse(readFileSync10(file, "utf8"));
+    const parsed = JSON.parse(readFileSync12(file, "utf8"));
     return new Set(Array.isArray(parsed.hashes) ? parsed.hashes.filter((value) => typeof value === "string") : []);
   } catch {
     return /* @__PURE__ */ new Set();
@@ -3137,7 +3702,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)}
 `
   );
@@ -3381,8 +3946,8 @@ 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 { cpSync, existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync13, readdirSync as readdirSync5, statSync as statSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join10, relative } from "node:path";
 var INCLUDE = [
   "config.toml",
   "policy.json",
@@ -3399,9 +3964,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 (!existsSync10(source)) continue;
+    const target = join10(options.out, entry);
     cpSync(source, target, { recursive: true });
   }
   const lines = [];
@@ -3409,13 +3974,13 @@ function exportStore(options) {
   let bytes = 0;
   const walk2 = (dir, base) => {
     for (const name2 of readdirSync5(dir)) {
-      const full = join9(dir, name2);
+      const full = join10(dir, name2);
       if (statSync5(full).isDirectory()) {
         walk2(full, base);
         continue;
       }
       const rel = relative(base, full).replaceAll("\\", "/");
-      const data = readFileSync11(full);
+      const data = readFileSync13(full);
       lines.push(`${createHash8("sha256").update(data).digest("hex")}  ${rel}`);
       files += 1;
       bytes += data.length;
@@ -3423,8 +3988,8 @@ function exportStore(options) {
   };
   walk2(options.out, options.out);
   lines.sort();
-  const sums = join9(options.out, "SHA256SUMS");
-  writeFileSync3(sums, `${lines.join("\n")}
+  const sums = join10(options.out, "SHA256SUMS");
+  writeFileSync4(sums, `${lines.join("\n")}
 `, "utf8");
   return { out: options.out, files, bytes, sums };
 }
@@ -3432,8 +3997,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 (!existsSync10(file)) return 0;
+      return [...readFileSync13(file, "utf8").replace(/<!--[\s\S]*?-->/g, "")].length;
     } catch {
       return 0;
     }
@@ -3474,7 +4039,7 @@ function inspectStore(options) {
 }
 
 // packages/core/src/profile/profile.ts
-import { existsSync as existsSync10, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync14 } from "node:fs";
 var PROFILE_SEPARATOR = "\xA7";
 var PROFILE_MAX_CHARS = 1e4;
 var ProfileError = class extends Error {
@@ -3534,7 +4099,7 @@ function validateProfileEntries(entries) {
 }
 function loadProfile(home) {
   const file = memoryPaths(home).userFile;
-  const text = existsSync10(file) ? readFileSync12(file, "utf8") : "";
+  const text = existsSync11(file) ? readFileSync14(file, "utf8") : "";
   const entries = parseProfileEntries(text);
   return { entries, chars: profileChars(entries) };
 }
@@ -3563,7 +4128,7 @@ function findProfileEntry(entries, oldText) {
 }
 
 // packages/core/src/personalization/scaffold.ts
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } 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 +4160,7 @@ function scaffoldPersonalization(options) {
   const created = [];
   const kept = [];
   for (const [file, template] of targets) {
-    if (existsSync11(file)) {
+    if (existsSync12(file)) {
       kept.push(file);
       continue;
     }
@@ -3965,8 +4530,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 +4553,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 +4610,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 +4638,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 +5381,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 +5418,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 +5434,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 +5512,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 +5622,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 +5664,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 +5766,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 +5942,10 @@ function guiRoutes(deps) {
   return [
     status,
     list,
+    graph,
+    projects,
+    moveProject,
+    meta,
     item,
     search2,
     exportRoute,
@@ -5292,8 +6029,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 +6061,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 +6111,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
         });