musememory 1.6.1 → 1.7.1

package/dist/index.js

@@ -3577,6 +3577,16 @@ function isExpired(entry, now) {
   const t = Date.parse(entry.expires_at);
   return !Number.isNaN(t) && t <= now;
 }
+function graphSymbolOverlapBonus(entry, queryTokens) {
+  const symbols = entry.graph?.symbol_names;
+  if (!symbols || symbols.length === 0 || queryTokens.length === 0)
+    return 0;
+  const symSet = new Set(symbols.map((s) => s.toLowerCase()));
+  const matches = queryTokens.filter((t) => symSet.has(t.toLowerCase())).length;
+  if (matches === 0)
+    return 0;
+  return Math.min(0.2, matches / queryTokens.length * 0.2);
+}
 function scoreEntry(entry, queryTokens, now) {
   const app = applicability(entry, queryTokens);
   const statusPenalty = STATUS_PENALTY[entry.status] ?? 0;
@@ -3586,9 +3596,10 @@ function scoreEntry(entry, queryTokens, now) {
   const r = entry.reinforcement ?? 0;
   const reinforcementBonus = Math.sign(r) * 0.05 * Math.min(Math.abs(r), 5);
   const dueBonus = dueDateBonus(entry, now);
+  const graphBonus = graphSymbolOverlapBonus(entry, queryTokens);
   const decayBase = entry.valid_from ?? entry.updated_at;
   const decay = 0.3 * Math.exp(-daysSince(decayBase, now) / 90);
-  return app + statusPenalty + verificationBonus + salienceBonus + reinforcementBonus + dueBonus + decay;
+  return app + statusPenalty + verificationBonus + salienceBonus + reinforcementBonus + dueBonus + graphBonus + decay;
 }
 function sortCandidates(candidates, queryTokens, now) {
   return candidates.map((entry) => ({ entry, score: scoreEntry(entry, queryTokens, now) })).sort((a, b) => {
@@ -4747,8 +4758,212 @@ var init_harvest = __esm(() => {
   ];
 });
 
+// src/graph.ts
+import { existsSync as existsSync8, readdirSync, readFileSync as readFileSync7, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5 } from "node:fs";
+import { join as join6 } from "node:path";
+function detectProvider(projectRoot) {
+  if (!projectRoot || !existsSync8(projectRoot))
+    return "none";
+  if (existsSync8(join6(projectRoot, ".codegraph"))) {
+    return "codegraph";
+  }
+  if (existsSync8(join6(projectRoot, ".graphify"))) {
+    return "graphify";
+  }
+  return "none";
+}
+function getGraphStatus(projectRoot) {
+  const provider = detectProvider(projectRoot);
+  if (provider === "codegraph") {
+    const codegraphDir = join6(projectRoot, ".codegraph");
+    let symbolCount;
+    let graphRevision;
+    try {
+      if (existsSync8(codegraphDir)) {
+        const files = readdirSync(codegraphDir);
+        symbolCount = files.length;
+        const metaPath = join6(codegraphDir, "meta.json");
+        if (existsSync8(metaPath)) {
+          const meta = JSON.parse(readFileSync7(metaPath, "utf8"));
+          graphRevision = meta.revision ?? meta.commit ?? meta.version;
+        }
+      }
+    } catch {}
+    return {
+      provider: "codegraph",
+      available: true,
+      root: codegraphDir,
+      graphRevision,
+      symbolCount
+    };
+  }
+  if (provider === "graphify") {
+    const graphifyDir = join6(projectRoot, ".graphify");
+    let symbolCount;
+    let graphRevision;
+    try {
+      if (existsSync8(graphifyDir)) {
+        const files = readdirSync(graphifyDir);
+        symbolCount = files.length;
+        const metaPath = join6(graphifyDir, "meta.json");
+        if (existsSync8(metaPath)) {
+          const meta = JSON.parse(readFileSync7(metaPath, "utf8"));
+          graphRevision = meta.revision ?? meta.commit ?? meta.version;
+        }
+      }
+    } catch {}
+    return {
+      provider: "graphify",
+      available: true,
+      root: graphifyDir,
+      graphRevision,
+      symbolCount
+    };
+  }
+  return {
+    provider: "none",
+    available: false,
+    root: projectRoot
+  };
+}
+function graphSymbolsPath(memoryDir) {
+  return join6(memoryDir, "graph-symbols.json");
+}
+function indexGraph(projectRoot, memoryDir) {
+  const status = getGraphStatus(projectRoot);
+  const symbols = {};
+  if (status.provider === "codegraph") {
+    const codegraphDir = join6(projectRoot, ".codegraph");
+    try {
+      const candidates = [
+        join6(codegraphDir, "symbols.json"),
+        join6(codegraphDir, "index.json"),
+        join6(codegraphDir, "graph.json")
+      ];
+      for (const c of candidates) {
+        if (existsSync8(c)) {
+          const data = JSON.parse(readFileSync7(c, "utf8"));
+          if (Array.isArray(data)) {
+            for (const item of data) {
+              if (item.name && item.path) {
+                symbols[String(item.name)] = String(item.path);
+              }
+            }
+          } else if (typeof data === "object" && data !== null) {
+            if (data.symbols && typeof data.symbols === "object") {
+              for (const [k, v] of Object.entries(data.symbols)) {
+                symbols[k] = typeof v === "string" ? v : v?.path || "";
+              }
+            } else {
+              for (const [k, v] of Object.entries(data)) {
+                if (typeof v === "string")
+                  symbols[k] = v;
+              }
+            }
+          }
+        }
+      }
+      if (Object.keys(symbols).length === 0 && existsSync8(codegraphDir)) {
+        const files = readdirSync(codegraphDir);
+        for (const file of files) {
+          if (file.endsWith(".json") && file !== "meta.json") {
+            try {
+              const content = JSON.parse(readFileSync7(join6(codegraphDir, file), "utf8"));
+              if (content.name && content.path) {
+                symbols[String(content.name)] = String(content.path);
+              } else if (content.symbols && Array.isArray(content.symbols)) {
+                for (const s of content.symbols) {
+                  if (s.name && (s.path || content.path)) {
+                    symbols[String(s.name)] = String(s.path || content.path);
+                  }
+                }
+              }
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  } else if (status.provider === "graphify") {
+    const graphifyDir = join6(projectRoot, ".graphify");
+    try {
+      const candidates = [
+        join6(graphifyDir, "graph.json"),
+        join6(graphifyDir, "symbols.json")
+      ];
+      for (const c of candidates) {
+        if (existsSync8(c)) {
+          const data = JSON.parse(readFileSync7(c, "utf8"));
+          if (data.nodes && Array.isArray(data.nodes)) {
+            for (const node of data.nodes) {
+              if (node.name && node.path) {
+                symbols[String(node.name)] = String(node.path);
+              }
+            }
+          }
+        }
+      }
+    } catch {}
+  }
+  const index = {
+    provider: status.provider,
+    indexedAt: new Date().toISOString(),
+    symbolCount: Object.keys(symbols).length,
+    symbols
+  };
+  try {
+    mkdirSync5(memoryDir, { recursive: true });
+    writeFileSync4(graphSymbolsPath(memoryDir), JSON.stringify(index, null, 2), "utf8");
+  } catch {}
+  return index;
+}
+function loadGraphSymbolIndex(memoryDir) {
+  const p = graphSymbolsPath(memoryDir);
+  if (!existsSync8(p))
+    return null;
+  try {
+    const raw = readFileSync7(p, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function extractReferencedSymbols(text, memoryDir) {
+  const index = loadGraphSymbolIndex(memoryDir);
+  if (!index || index.symbolCount === 0) {
+    return { symbol_names: [], affected_paths: [], provider: "none" };
+  }
+  const matchedSymbols = new Set;
+  const affectedPaths = new Set;
+  const words = text.match(/[a-zA-Z_$][a-zA-Z0-9_$]*/g) || [];
+  const wordSet = new Set(words);
+  for (const [symbol, path] of Object.entries(index.symbols)) {
+    if (wordSet.has(symbol)) {
+      matchedSymbols.add(symbol);
+      if (path)
+        affectedPaths.add(path);
+    }
+  }
+  return {
+    symbol_names: Array.from(matchedSymbols),
+    affected_paths: Array.from(affectedPaths),
+    provider: index.provider
+  };
+}
+function autoStampGraphMetadata(text, memoryDir) {
+  const extracted = extractReferencedSymbols(text, memoryDir);
+  if (extracted.symbol_names.length === 0)
+    return;
+  return {
+    provider: extracted.provider,
+    symbol_names: extracted.symbol_names,
+    affected_paths: extracted.affected_paths,
+    graph_verified_at: new Date().toISOString()
+  };
+}
+var init_graph = () => {};
+
 // src/sqlite.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6 } from "node:fs";
 import { dirname } from "node:path";
 function getDriver() {
   if (sqliteDriver !== "none")
@@ -4769,8 +4984,8 @@ function getDriver() {
 }
 function openDatabase(dbPath) {
   const dir = dirname(dbPath);
-  if (!existsSync8(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  if (!existsSync9(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
   const driver = getDriver();
   let rawDb;
@@ -4980,29 +5195,29 @@ var init_sqlite = () => {};
 
 // src/store.ts
 import { resolve } from "node:path";
-import { readdirSync, readFileSync as readFileSync7, writeFileSync as writeFileSync4, renameSync, unlinkSync, mkdirSync as mkdirSync6, existsSync as existsSync9 } from "node:fs";
-import { join as join6 } from "node:path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync5, renameSync, unlinkSync, mkdirSync as mkdirSync7, existsSync as existsSync10 } from "node:fs";
+import { join as join7 } from "node:path";
 function getStorageLayout(memoryDir) {
   return {
     root: workspaceRootFor(memoryDir),
     memoryDir,
-    memoriesDir: join6(memoryDir, "memories"),
-    dbPath: join6(memoryDir, "memory.db"),
-    currentMd: join6(memoryDir, "CURRENT.md"),
-    userMd: join6(memoryDir, "USER.md"),
-    auditJsonl: join6(memoryDir, "audit.jsonl")
+    memoriesDir: join7(memoryDir, "memories"),
+    dbPath: join7(memoryDir, "memory.db"),
+    currentMd: join7(memoryDir, "CURRENT.md"),
+    userMd: join7(memoryDir, "USER.md"),
+    auditJsonl: join7(memoryDir, "audit.jsonl")
   };
 }
 function openStore(memoryDir) {
   const layout = getStorageLayout(memoryDir);
-  mkdirSync6(layout.memoriesDir, { recursive: true });
-  mkdirSync6(memoryDir, { recursive: true });
+  mkdirSync7(layout.memoriesDir, { recursive: true });
+  mkdirSync7(memoryDir, { recursive: true });
   let db;
   try {
     db = openDatabase(layout.dbPath);
   } catch (err) {}
   const store = { dir: layout.memoriesDir, memoryDir, layout, db };
-  if (db && existsSync9(layout.memoriesDir)) {
+  if (db && existsSync10(layout.memoriesDir)) {
     try {
       const yamlIds = listIds(store);
       for (const yId of yamlIds) {
@@ -5054,8 +5269,8 @@ function listIds(store) {
       ids.add(e.id);
     }
   }
-  if (existsSync9(store.dir)) {
-    for (const f of readdirSync(store.dir)) {
+  if (existsSync10(store.dir)) {
+    for (const f of readdirSync2(store.dir)) {
       if (f.endsWith(".yaml")) {
         ids.add(f.slice(0, -5));
       }
@@ -5065,10 +5280,10 @@ function listIds(store) {
 }
 function getFromYaml(store, id) {
   const file = fileForId(store, id);
-  if (!existsSync9(file))
+  if (!existsSync10(file))
     return null;
   try {
-    const raw = readFileSync7(file, "utf8");
+    const raw = readFileSync8(file, "utf8");
     const parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
     if (!parsed || typeof parsed !== "object")
       return null;
@@ -5079,7 +5294,7 @@ function getFromYaml(store, id) {
 }
 function get2(store, id) {
   const file = fileForId(store, id);
-  if (existsSync9(file)) {
+  if (existsSync10(file)) {
     const fromYaml = getFromYaml(store, id);
     if (!fromYaml) {
       return null;
@@ -5129,7 +5344,7 @@ function save(store, entry, options = {}) {
   try {
     const file = fileForId(store, entry.id);
     const tmp = `${file}.tmp`;
-    writeFileSync4(tmp, yaml.dump(entry, { lineWidth: 120 }), "utf8");
+    writeFileSync5(tmp, yaml.dump(entry, { lineWidth: 120 }), "utf8");
     renameSync(tmp, file);
   } catch {}
 }
@@ -5186,7 +5401,8 @@ function propose(store, opts) {
     due_at: opts.dueAt ?? opts.due_at,
     expires_at: opts.expiresAt ?? opts.expires_at,
     test_command: opts.test_command,
-    verification: opts.verification ?? (opts.confirmed ? { level: "user-confirmed", verified_at: now } : { level: "unverified" })
+    verification: opts.verification ?? (opts.confirmed ? { level: "user-confirmed", verified_at: now } : { level: "unverified" }),
+    graph: opts.graph ?? (store.memoryDir ? autoStampGraphMetadata(`${opts.title ?? ""} ${opts.content}`, store.memoryDir) : undefined)
   };
   if (opts.confirmed)
     entry.last_confirmed_at = now;
@@ -5395,7 +5611,7 @@ function deleteEntry(store, id, reason, actor) {
     deleted = deleteMemoryById(store.db, id) || deleted;
   }
   const file = fileForId(store, id);
-  if (existsSync9(file)) {
+  if (existsSync10(file)) {
     unlinkSync(file);
     deleted = true;
   }
@@ -5440,6 +5656,7 @@ var init_store = __esm(() => {
   init_current();
   init_compiler();
   init_harvest();
+  init_graph();
   init_root();
   init_sqlite();
 });
@@ -5539,8 +5756,8 @@ var init_cluster = __esm(() => {
 });
 
 // src/entities/extractor.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join8 } from "node:path";
 function slugify(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
 }
@@ -5749,17 +5966,17 @@ function extractEntitiesFromText(text, config = {}) {
   return results;
 }
 function saveEntities(memoryDir, data) {
-  const filePath = join7(memoryDir, "entities.json");
-  mkdirSync7(memoryDir, { recursive: true });
+  const filePath = join8(memoryDir, "entities.json");
+  mkdirSync8(memoryDir, { recursive: true });
   const entities = Array.isArray(data) ? data : data.entities;
-  writeFileSync5(filePath, JSON.stringify(entities, null, 2), "utf8");
+  writeFileSync6(filePath, JSON.stringify(entities, null, 2), "utf8");
 }
 function loadEntities(memoryDir) {
-  const filePath = join7(memoryDir, "entities.json");
-  if (!existsSync10(filePath))
+  const filePath = join8(memoryDir, "entities.json");
+  if (!existsSync11(filePath))
     return [];
   try {
-    return JSON.parse(readFileSync8(filePath, "utf8"));
+    return JSON.parse(readFileSync9(filePath, "utf8"));
   } catch {
     return [];
   }
@@ -5961,8 +6178,8 @@ ${entries}
 }
 
 // src/wiki/compiler.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, writeFileSync as writeFileSync6, readFileSync as readFileSync9, readdirSync as readdirSync2 } from "node:fs";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, writeFileSync as writeFileSync7, readFileSync as readFileSync10, readdirSync as readdirSync3 } from "node:fs";
+import { join as join9 } from "node:path";
 function compileWiki(store, memoryDir, options = {}) {
   const project = options.project;
   const dryRun = options.dryRun ?? false;
@@ -5986,12 +6203,12 @@ function compileWiki(store, memoryDir, options = {}) {
     }
   }
   const memories = project ? allMemories.filter((e) => e.project === project) : allMemories;
-  const wikiDir = join8(memoryDir, "wiki");
-  const conceptsDir = join8(wikiDir, "concepts");
-  const entitiesDir = join8(wikiDir, "entities");
+  const wikiDir = join9(memoryDir, "wiki");
+  const conceptsDir = join9(wikiDir, "concepts");
+  const entitiesDir = join9(wikiDir, "entities");
   if (!dryRun) {
-    mkdirSync8(conceptsDir, { recursive: true });
-    mkdirSync8(entitiesDir, { recursive: true });
+    mkdirSync9(conceptsDir, { recursive: true });
+    mkdirSync9(entitiesDir, { recursive: true });
   }
   const result = { pagesCreated: [], pagesUpdated: [], logEntries: [], errors: [] };
   const existingConcepts = loadExistingConcepts(conceptsDir);
@@ -6244,14 +6461,14 @@ function stripFrontmatter(content) {
 }
 function loadExistingConcepts(dir) {
   const map2 = new Map;
-  if (!existsSync11(dir))
+  if (!existsSync12(dir))
     return map2;
-  for (const file of readdirSync2(dir)) {
+  for (const file of readdirSync3(dir)) {
     if (!file.endsWith(".md"))
       continue;
     const slug = file.slice(0, -3);
     try {
-      const content = readFileSync9(join8(dir, file), "utf8");
+      const content = readFileSync10(join9(dir, file), "utf8");
       const frontmatter = parseFrontmatter(content);
       map2.set(slug, { ...frontmatter, slug, content: stripFrontmatter(content) });
     } catch {}
@@ -6260,14 +6477,14 @@ function loadExistingConcepts(dir) {
 }
 function loadExistingEntities(dir) {
   const map2 = new Map;
-  if (!existsSync11(dir))
+  if (!existsSync12(dir))
     return map2;
-  for (const file of readdirSync2(dir)) {
+  for (const file of readdirSync3(dir)) {
     if (!file.endsWith(".md"))
       continue;
     const slug = file.slice(0, -3);
     try {
-      const content = readFileSync9(join8(dir, file), "utf8");
+      const content = readFileSync10(join9(dir, file), "utf8");
       const frontmatter = parseFrontmatter(content);
       map2.set(slug, { ...frontmatter, slug, content: stripFrontmatter(content) });
     } catch {}
@@ -6311,22 +6528,22 @@ function parseFrontmatter(content) {
 function writeConceptPages(map2, dir) {
   for (const [slug, page] of map2) {
     const content = renderConceptPage(page);
-    writeFileSync6(join8(dir, slug + ".md"), content, "utf8");
+    writeFileSync7(join9(dir, slug + ".md"), content, "utf8");
   }
 }
 function writeEntityPages(map2, dir) {
   for (const [slug, page] of map2) {
     const content = renderEntityPage(page);
-    writeFileSync6(join8(dir, slug + ".md"), content, "utf8");
+    writeFileSync7(join9(dir, slug + ".md"), content, "utf8");
   }
 }
 function writeIndexPage(page, dir) {
   const content = renderIndexPage(page);
-  writeFileSync6(join8(dir, "index.md"), content, "utf8");
+  writeFileSync7(join9(dir, "index.md"), content, "utf8");
 }
 function writeLogPage(page, dir) {
   const content = renderLogPage(page);
-  writeFileSync6(join8(dir, "log.md"), content, "utf8");
+  writeFileSync7(join9(dir, "log.md"), content, "utf8");
 }
 function applyDetailLevel(page, detailLevel) {
   if (detailLevel === "l1") {
@@ -6337,11 +6554,11 @@ function applyDetailLevel(page, detailLevel) {
   return page;
 }
 function listWikiPages(memoryDir, options = {}) {
-  const wikiDir = join8(memoryDir, "wiki");
+  const wikiDir = join9(memoryDir, "wiki");
   const pages = [];
   const detailLevel = options.detailLevel ?? "full";
   if (options.type === undefined || options.type === "concept") {
-    const concepts = loadExistingConcepts(join8(wikiDir, "concepts"));
+    const concepts = loadExistingConcepts(join9(wikiDir, "concepts"));
     for (const page of concepts.values()) {
       if (!options.project || page.project === options.project) {
         pages.push(applyDetailLevel(page, detailLevel));
@@ -6349,7 +6566,7 @@ function listWikiPages(memoryDir, options = {}) {
     }
   }
   if (options.type === undefined || options.type === "entity") {
-    const entities = loadExistingEntities(join8(wikiDir, "entities"));
+    const entities = loadExistingEntities(join9(wikiDir, "entities"));
     for (const page of entities.values()) {
       if (!options.project || page.project === options.project) {
         pages.push(applyDetailLevel(page, detailLevel));
@@ -6357,20 +6574,20 @@ function listWikiPages(memoryDir, options = {}) {
     }
   }
   if (options.type === undefined || options.type === "index") {
-    const idxPath = join8(wikiDir, "index.md");
-    if (existsSync11(idxPath)) {
+    const idxPath = join9(wikiDir, "index.md");
+    if (existsSync12(idxPath)) {
       try {
-        const raw = readFileSync9(idxPath, "utf8");
+        const raw = readFileSync10(idxPath, "utf8");
         const fm = parseFrontmatter(raw);
         pages.push(applyDetailLevel({ ...fm, slug: "index", type: "index", content: raw }, detailLevel));
       } catch {}
     }
   }
   if (options.type === undefined || options.type === "log") {
-    const logPath = join8(wikiDir, "log.md");
-    if (existsSync11(logPath)) {
+    const logPath = join9(wikiDir, "log.md");
+    if (existsSync12(logPath)) {
       try {
-        const raw = readFileSync9(logPath, "utf8");
+        const raw = readFileSync10(logPath, "utf8");
         const fm = parseFrontmatter(raw);
         pages.push(applyDetailLevel({ ...fm, slug: "log", type: "log", content: raw }, detailLevel));
       } catch {}
@@ -6379,37 +6596,37 @@ function listWikiPages(memoryDir, options = {}) {
   return pages;
 }
 function getWikiPage(memoryDir, slug, type2, detailLevel = "full") {
-  const wikiDir = join8(memoryDir, "wiki");
+  const wikiDir = join9(memoryDir, "wiki");
   if (slug === "index") {
-    const p = join8(wikiDir, "index.md");
-    if (existsSync11(p)) {
-      const raw = readFileSync9(p, "utf8");
+    const p = join9(wikiDir, "index.md");
+    if (existsSync12(p)) {
+      const raw = readFileSync10(p, "utf8");
       const fm = parseFrontmatter(raw);
       return applyDetailLevel({ ...fm, slug: "index", type: "index", content: raw }, detailLevel);
     }
     return null;
   }
   if (slug === "log") {
-    const p = join8(wikiDir, "log.md");
-    if (existsSync11(p)) {
-      const raw = readFileSync9(p, "utf8");
+    const p = join9(wikiDir, "log.md");
+    if (existsSync12(p)) {
+      const raw = readFileSync10(p, "utf8");
       const fm = parseFrontmatter(raw);
       return applyDetailLevel({ ...fm, slug: "log", type: "log", content: raw }, detailLevel);
     }
     return null;
   }
   if (!type2 || type2 === "concept") {
-    const p = join8(wikiDir, "concepts", `${slug}.md`);
-    if (existsSync11(p)) {
-      const raw = readFileSync9(p, "utf8");
+    const p = join9(wikiDir, "concepts", `${slug}.md`);
+    if (existsSync12(p)) {
+      const raw = readFileSync10(p, "utf8");
       const fm = parseFrontmatter(raw);
       return applyDetailLevel({ ...fm, slug, type: "concept", content: raw }, detailLevel);
     }
   }
   if (!type2 || type2 === "entity") {
-    const p = join8(wikiDir, "entities", `${slug}.md`);
-    if (existsSync11(p)) {
-      const raw = readFileSync9(p, "utf8");
+    const p = join9(wikiDir, "entities", `${slug}.md`);
+    if (existsSync12(p)) {
+      const raw = readFileSync10(p, "utf8");
       const fm = parseFrontmatter(raw);
       return applyDetailLevel({ ...fm, slug, type: "entity", content: raw }, detailLevel);
     }
@@ -6417,15 +6634,15 @@ function getWikiPage(memoryDir, slug, type2, detailLevel = "full") {
   return null;
 }
 function ensureWikiStructure(memoryDir) {
-  const wikiDir = join8(memoryDir, "wiki");
-  const conceptsDir = join8(wikiDir, "concepts");
-  const entitiesDir = join8(wikiDir, "entities");
-  if (!existsSync11(conceptsDir))
-    mkdirSync8(conceptsDir, { recursive: true });
-  if (!existsSync11(entitiesDir))
-    mkdirSync8(entitiesDir, { recursive: true });
-  const indexPath = join8(wikiDir, "index.md");
-  if (!existsSync11(indexPath)) {
+  const wikiDir = join9(memoryDir, "wiki");
+  const conceptsDir = join9(wikiDir, "concepts");
+  const entitiesDir = join9(wikiDir, "entities");
+  if (!existsSync12(conceptsDir))
+    mkdirSync9(conceptsDir, { recursive: true });
+  if (!existsSync12(entitiesDir))
+    mkdirSync9(entitiesDir, { recursive: true });
+  const indexPath = join9(wikiDir, "index.md");
+  if (!existsSync12(indexPath)) {
     const defaultIndex = `# Knowledge Wiki Index
 
 > Compiled Obsidian-compatible concept and entity knowledge base.
@@ -6436,16 +6653,16 @@ function ensureWikiStructure(memoryDir) {
 ## Entities
 *(No named entities extracted yet)*
 `;
-    writeFileSync6(indexPath, defaultIndex, "utf8");
+    writeFileSync7(indexPath, defaultIndex, "utf8");
   }
-  const logPath = join8(wikiDir, "log.md");
-  if (!existsSync11(logPath)) {
+  const logPath = join9(wikiDir, "log.md");
+  if (!existsSync12(logPath)) {
     const defaultLog = `# Wiki Compilation Log
 
 | Timestamp | Action | Page | Memories | Details |
 |---|---|---|---|---|
 `;
-    writeFileSync6(logPath, defaultLog, "utf8");
+    writeFileSync7(logPath, defaultLog, "utf8");
   }
 }
 function autoCompileWiki(store, memoryDir, options = {}) {
@@ -6465,8 +6682,8 @@ var init_wiki = __esm(() => {
 });
 
 // src/root.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync9, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname3, join as join9 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync10, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname3, join as join10 } from "node:path";
 import { homedir } from "node:os";
 function isMemoryDirPath(path) {
   return MEMORY_DIR_NAMES.some((n) => path.endsWith(n));
@@ -6479,20 +6696,20 @@ function getGlobalMemoryDir() {
   if (custom)
     return custom;
   const home = process.env.HOME || process.env.USERPROFILE || homedir();
-  return join9(home, ".memory");
+  return join10(home, ".memory");
 }
 function ensureMemoryDirectory(memoryDir) {
-  const memoriesDir = join9(memoryDir, "memories");
-  if (!existsSync12(memoriesDir)) {
-    mkdirSync9(memoriesDir, { recursive: true });
+  const memoriesDir = join10(memoryDir, "memories");
+  if (!existsSync13(memoriesDir)) {
+    mkdirSync10(memoriesDir, { recursive: true });
   }
-  const currentPath = join9(memoryDir, "CURRENT.md");
-  if (!existsSync12(currentPath)) {
-    writeFileSync7(currentPath, `# Active Project Constraints
+  const currentPath = join10(memoryDir, "CURRENT.md");
+  if (!existsSync13(currentPath)) {
+    writeFileSync8(currentPath, `# Active Project Constraints
 `, "utf8");
   }
   const uPath = userFilePath(memoryDir);
-  if (!existsSync12(uPath)) {
+  if (!existsSync13(uPath)) {
     const isGlobal = memoryDir === getGlobalMemoryDir();
     initUserProfile(memoryDir, "developer", false, !isGlobal);
   }
@@ -6509,19 +6726,19 @@ function findProjectRoot(startDir, options = {}) {
   }
   const ancestors = ancestorChain(startDir);
   for (const dir of ancestors) {
-    if (existsSync12(join9(dir, ".memory")))
+    if (existsSync13(join10(dir, ".memory")))
       return { root: dir, marker: "memory", memoryDirName: ".memory" };
-    if (existsSync12(join9(dir, ".musememory")))
+    if (existsSync13(join10(dir, ".musememory")))
       return { root: dir, marker: "memory", memoryDirName: ".musememory" };
-    if (existsSync12(join9(dir, ".muse-memory")))
+    if (existsSync13(join10(dir, ".muse-memory")))
       return { root: dir, marker: "memory", memoryDirName: ".muse-memory" };
   }
   for (const dir of ancestors) {
-    if (existsSync12(join9(dir, ".git"))) {
+    if (existsSync13(join10(dir, ".git"))) {
       let dirName = ".memory";
-      if (existsSync12(join9(dir, ".musememory")))
+      if (existsSync13(join10(dir, ".musememory")))
         dirName = ".musememory";
-      else if (existsSync12(join9(dir, ".muse-memory")))
+      else if (existsSync13(join10(dir, ".muse-memory")))
         dirName = ".muse-memory";
       return { root: dir, marker: "git", memoryDirName: dirName };
     }
@@ -6541,8 +6758,8 @@ function findOrCreateProjectRoot(startDir, options = {}) {
     return { root: memoryDir2, memoryDir: memoryDir2, marker: res.marker };
   }
   const root = res.root ?? startDir;
-  const memoryDirName = res.memoryDirName ?? MEMORY_DIR_NAMES.find((n) => existsSync12(join9(root, n))) ?? ".memory";
-  const memoryDir = join9(root, memoryDirName);
+  const memoryDirName = res.memoryDirName ?? MEMORY_DIR_NAMES.find((n) => existsSync13(join10(root, n))) ?? ".memory";
+  const memoryDir = join10(root, memoryDirName);
   const marker = res.marker ?? "auto";
   ensureMemoryDirectory(memoryDir);
   return { root, memoryDir, marker };
@@ -6552,7 +6769,7 @@ function ancestorChain(startDir) {
   let dir = startDir;
   for (;; ) {
     chain.push(dir);
-    const parent = join9(dir, "..");
+    const parent = join10(dir, "..");
     if (parent === dir)
       break;
     dir = parent;
@@ -6657,12 +6874,12 @@ function normalizeMemoryType(raw) {
 }
 
 // src/migrator/detect.ts
-import { existsSync as existsSync13 } from "node:fs";
-import { join as join10, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync14 } from "node:fs";
+import { join as join11, resolve as resolve2 } from "node:path";
 import { homedir as homedir2 } from "node:os";
 function expandPath(p, baseDir) {
   if (p.startsWith("~/") || p === "~") {
-    return join10(homedir2(), p.slice(1));
+    return join11(homedir2(), p.slice(1));
   }
   if (p.startsWith("/")) {
     return p;
@@ -6673,7 +6890,7 @@ function detectProviders(baseDir = process.cwd()) {
   return PROVIDER_DEFINITIONS.map((def) => {
     const resolved = def.paths.map((p) => expandPath(p, baseDir)).filter((p) => {
       try {
-        return existsSync13(p);
+        return existsSync14(p);
       } catch {
         return false;
       }
@@ -6964,8 +7181,8 @@ var init_detect = __esm(() => {
 });
 
 // src/migrator/adapters/agentmemory.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10, statSync } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync11, statSync } from "node:fs";
+import { join as join12 } from "node:path";
 var AgentMemoryAdapter;
 var init_agentmemory = __esm(() => {
   AgentMemoryAdapter = {
@@ -6973,23 +7190,23 @@ var init_agentmemory = __esm(() => {
     extract(sourcePath, options = {}) {
       const results = [];
       let jsonPath = sourcePath;
-      if (existsSync14(sourcePath) && statSync(sourcePath).isDirectory()) {
+      if (existsSync15(sourcePath) && statSync(sourcePath).isDirectory()) {
         const candidates = [
-          join11(sourcePath, "standalone.json"),
-          join11(sourcePath, "engine-state.json")
+          join12(sourcePath, "standalone.json"),
+          join12(sourcePath, "engine-state.json")
         ];
         for (const cand of candidates) {
-          if (existsSync14(cand)) {
+          if (existsSync15(cand)) {
             jsonPath = cand;
             break;
           }
         }
       }
-      if (!existsSync14(jsonPath) || statSync(jsonPath).isDirectory()) {
+      if (!existsSync15(jsonPath) || statSync(jsonPath).isDirectory()) {
         return results;
       }
       try {
-        const raw = readFileSync10(jsonPath, "utf8");
+        const raw = readFileSync11(jsonPath, "utf8");
         const parsed = JSON.parse(raw);
         const memObj = parsed["mem:memories"] || parsed["memories"] || parsed;
         const items = Array.isArray(memObj) ? memObj : Object.values(memObj);
@@ -7026,25 +7243,25 @@ var init_agentmemory = __esm(() => {
 });
 
 // src/migrator/adapters/beads.ts
-import { existsSync as existsSync15, readFileSync as readFileSync11, readdirSync as readdirSync3, statSync as statSync2 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync12, readdirSync as readdirSync4, statSync as statSync2 } from "node:fs";
+import { join as join13 } from "node:path";
 var BeadsAdapter;
 var init_beads = __esm(() => {
   BeadsAdapter = {
     id: "beads",
     extract(sourcePath, options = {}) {
       const results = [];
-      if (!existsSync15(sourcePath))
+      if (!existsSync16(sourcePath))
         return results;
       let jsonPath = sourcePath;
       if (statSync2(sourcePath).isDirectory()) {
-        const p = join12(sourcePath, "beads.json");
-        if (existsSync15(p))
+        const p = join13(sourcePath, "beads.json");
+        if (existsSync16(p))
           jsonPath = p;
       }
-      if (existsSync15(jsonPath) && !statSync2(jsonPath).isDirectory()) {
+      if (existsSync16(jsonPath) && !statSync2(jsonPath).isDirectory()) {
         try {
-          const raw = readFileSync11(jsonPath, "utf8");
+          const raw = readFileSync12(jsonPath, "utf8");
           const parsed = JSON.parse(raw);
           const beads = Array.isArray(parsed) ? parsed : parsed.beads || Object.values(parsed);
           for (const b of beads) {
@@ -7075,12 +7292,12 @@ var init_beads = __esm(() => {
       }
       if (statSync2(sourcePath).isDirectory()) {
         try {
-          const files = readdirSync3(sourcePath);
+          const files = readdirSync4(sourcePath);
           for (const file of files) {
             if (!file.endsWith(".md") && !file.endsWith(".markdown"))
               continue;
-            const fullPath = join12(sourcePath, file);
-            const content = readFileSync11(fullPath, "utf8");
+            const fullPath = join13(sourcePath, file);
+            const content = readFileSync12(fullPath, "utf8");
             const title = file.replace(/\.md$/, "").replace(/[-_]/g, " ");
             results.push({
               title,
@@ -7100,15 +7317,15 @@ var init_beads = __esm(() => {
 });
 
 // src/migrator/adapters/letta.ts
-import { existsSync as existsSync16, readFileSync as readFileSync12, readdirSync as readdirSync4, statSync as statSync3 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync13, readdirSync as readdirSync5, statSync as statSync3 } from "node:fs";
+import { join as join14 } from "node:path";
 var LettaAdapter;
 var init_letta = __esm(() => {
   LettaAdapter = {
     id: "letta",
     extract(sourcePath, options = {}) {
       const results = [];
-      if (!existsSync16(sourcePath))
+      if (!existsSync17(sourcePath))
         return results;
       const processJson = (raw, filename) => {
         try {
@@ -7161,16 +7378,16 @@ var init_letta = __esm(() => {
       };
       if (statSync3(sourcePath).isDirectory()) {
         try {
-          const entries = readdirSync4(sourcePath);
+          const entries = readdirSync5(sourcePath);
           for (const file of entries) {
             if (file.endsWith(".json")) {
-              const raw = readFileSync12(join13(sourcePath, file), "utf8");
+              const raw = readFileSync13(join14(sourcePath, file), "utf8");
               processJson(raw, file);
             }
           }
         } catch {}
       } else {
-        processJson(readFileSync12(sourcePath, "utf8"), "letta.json");
+        processJson(readFileSync13(sourcePath, "utf8"), "letta.json");
       }
       return results;
     }
@@ -7178,8 +7395,8 @@ var init_letta = __esm(() => {
 });
 
 // src/migrator/adapters/generic.ts
-import { existsSync as existsSync17, readFileSync as readFileSync13, readdirSync as readdirSync5, statSync as statSync4 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync14, readdirSync as readdirSync6, statSync as statSync4 } from "node:fs";
+import { join as join15 } from "node:path";
 var GenericAdapter;
 var init_generic = __esm(() => {
   init_js_yaml();
@@ -7187,11 +7404,11 @@ var init_generic = __esm(() => {
     id: "generic",
     extract(sourcePath, options = {}) {
       const results = [];
-      if (!existsSync17(sourcePath))
+      if (!existsSync18(sourcePath))
         return results;
       const processFile = (filePath, filename) => {
         try {
-          const raw = readFileSync13(filePath, "utf8");
+          const raw = readFileSync14(filePath, "utf8");
           if (filename.endsWith(".json") || filename.endsWith(".jsonl")) {
             try {
               const parsed = JSON.parse(raw);
@@ -7262,9 +7479,9 @@ var init_generic = __esm(() => {
       };
       if (statSync4(sourcePath).isDirectory()) {
         try {
-          const files = readdirSync5(sourcePath);
+          const files = readdirSync6(sourcePath);
           for (const file of files) {
-            processFile(join14(sourcePath, file), file);
+            processFile(join15(sourcePath, file), file);
           }
         } catch {}
       } else {
@@ -7432,50 +7649,6 @@ var init_migrator = __esm(() => {
   init_engine();
 });
 
-// src/graph.ts
-import { existsSync as existsSync18, readdirSync as readdirSync6, readFileSync as readFileSync14 } from "node:fs";
-import { join as join15 } from "node:path";
-function detectProvider(projectRoot) {
-  if (!projectRoot || !existsSync18(projectRoot))
-    return "none";
-  if (existsSync18(join15(projectRoot, ".codegraph"))) {
-    return "codegraph";
-  }
-  return "none";
-}
-function getGraphStatus(projectRoot) {
-  const provider = detectProvider(projectRoot);
-  if (provider === "codegraph") {
-    const codegraphDir = join15(projectRoot, ".codegraph");
-    let symbolCount;
-    let graphRevision;
-    try {
-      if (existsSync18(codegraphDir)) {
-        const files = readdirSync6(codegraphDir);
-        symbolCount = files.length;
-        const metaPath = join15(codegraphDir, "meta.json");
-        if (existsSync18(metaPath)) {
-          const meta = JSON.parse(readFileSync14(metaPath, "utf8"));
-          graphRevision = meta.revision ?? meta.commit ?? meta.version;
-        }
-      }
-    } catch {}
-    return {
-      provider: "codegraph",
-      available: true,
-      root: codegraphDir,
-      graphRevision,
-      symbolCount
-    };
-  }
-  return {
-    provider: "none",
-    available: false,
-    root: projectRoot
-  };
-}
-var init_graph = () => {};
-
 // src/prompt.ts
 var exports_prompt = {};
 __export(exports_prompt, {
@@ -8239,7 +8412,7 @@ __export(exports_connect, {
   disconnectAllAgents: () => disconnectAllAgents,
   disconnectSingleAgent: () => disconnectSingleAgent
 });
-import { existsSync as existsSync20, readFileSync as readFileSync16, writeFileSync as writeFileSync8, mkdirSync as mkdirSync10, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync16, writeFileSync as writeFileSync9, mkdirSync as mkdirSync11, statSync as statSync6 } from "node:fs";
 import { join as join17, dirname as dirname4 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 function safeReadJson(path) {
@@ -8257,8 +8430,8 @@ function safeWriteJson(path, data, dryRun = false) {
     return;
   const dir = dirname4(path);
   if (!existsSync20(dir))
-    mkdirSync10(dir, { recursive: true });
-  writeFileSync8(path, JSON.stringify(data, null, 2) + `
+    mkdirSync11(dir, { recursive: true });
+  writeFileSync9(path, JSON.stringify(data, null, 2) + `
 `, "utf8");
 }
 function safeReadYaml(path) {
@@ -8277,9 +8450,9 @@ function safeWriteYaml(path, data, dryRun = false) {
     return;
   const dir = dirname4(path);
   if (!existsSync20(dir))
-    mkdirSync10(dir, { recursive: true });
+    mkdirSync11(dir, { recursive: true });
   const dumped = yaml.dump(data, { indent: 2, lineWidth: -1 });
-  writeFileSync8(path, dumped, "utf8");
+  writeFileSync9(path, dumped, "utf8");
 }
 function resolveAgentConfigFile(agent, home, foundConfig) {
   if (foundConfig && existsSync20(foundConfig)) {
@@ -8669,8 +8842,8 @@ __export(exports_hook, {
 import {
   existsSync as existsSync21,
   readFileSync as readFileSync17,
-  writeFileSync as writeFileSync9,
-  mkdirSync as mkdirSync11,
+  writeFileSync as writeFileSync10,
+  mkdirSync as mkdirSync12,
   readdirSync as readdirSync7,
   statSync as statSync7,
   renameSync as renameSync2,
@@ -8687,8 +8860,8 @@ function installGitHook(workspaceRoot) {
   if (existsSync21(hookPath)) {
     return { installed: false, path: hookPath, message: `pre-commit hook already exists at ${hookPath} — leaving it untouched` };
   }
-  mkdirSync11(hooksDir, { recursive: true });
-  writeFileSync9(hookPath, HOOK_SCRIPT, "utf8");
+  mkdirSync12(hooksDir, { recursive: true });
+  writeFileSync10(hookPath, HOOK_SCRIPT, "utf8");
   chmodSync(hookPath, 493);
   return { installed: true, path: hookPath, message: `installed pre-commit hook at ${hookPath}` };
 }
@@ -8750,7 +8923,7 @@ function harvestAuto(store, workspaceRoot, memoryDir, options = {}) {
         confirmed: false,
         source: "harvest_auto"
       });
-      mkdirSync11(processedDir, { recursive: true });
+      mkdirSync12(processedDir, { recursive: true });
       const base = file.split("/").pop() ?? "transcript.jsonl";
       let dest = join18(processedDir, base);
       if (existsSync21(dest)) {
@@ -15402,7 +15575,7 @@ var init_doctor = __esm(() => {
 });
 
 // src/retrieval/tree-index.ts
-import { existsSync as existsSync24, readFileSync as readFileSync20, writeFileSync as writeFileSync10, mkdirSync as mkdirSync12, rmSync } from "node:fs";
+import { existsSync as existsSync24, readFileSync as readFileSync20, writeFileSync as writeFileSync11, mkdirSync as mkdirSync13, rmSync } from "node:fs";
 import { join as join21 } from "node:path";
 function tokenize2(text) {
   if (!text || typeof text !== "string")
@@ -15512,7 +15685,7 @@ function countNodes(node) {
 function buildTreeIndex(store, memoryDir, config = {}) {
   const cfg = { ...DEFAULT_CONFIG, ...config };
   const allMemories = list(store).filter((e) => e.status === "confirmed");
-  mkdirSync12(indexDir(memoryDir), { recursive: true });
+  mkdirSync13(indexDir(memoryDir), { recursive: true });
   if (allMemories.length === 0) {
     const emptyIndex = {
       version: 1,
@@ -15521,7 +15694,7 @@ function buildTreeIndex(store, memoryDir, config = {}) {
       totalMemories: 0,
       builtAt: nowIso3()
     };
-    writeFileSync10(globalIndexFilePath(indexDir(memoryDir)), JSON.stringify(emptyIndex, null, 2), "utf8");
+    writeFileSync11(globalIndexFilePath(indexDir(memoryDir)), JSON.stringify(emptyIndex, null, 2), "utf8");
     return emptyIndex;
   }
   const groups = new Map;
@@ -15539,7 +15712,7 @@ function buildTreeIndex(store, memoryDir, config = {}) {
   for (const [key, memories] of groups) {
     const [project, type2] = key.split("|");
     const pDir = partitionDir(indexDir(memoryDir), project, type2);
-    mkdirSync12(pDir, { recursive: true });
+    mkdirSync13(pDir, { recursive: true });
     const maxShardSize = cfg.shardThreshold || 1e4;
     const finalShards = [];
     const memoryChunks = [];
@@ -15600,9 +15773,9 @@ function buildTreeIndex(store, memoryDir, config = {}) {
     partitions[`${project}|${type2}`] = partition;
     totalIndexNodes += partitionNodes;
     totalIndexMemories += partitionMemories;
-    writeFileSync10(partitionIndexFilePath(pDir), JSON.stringify(partition, null, 2), "utf8");
+    writeFileSync11(partitionIndexFilePath(pDir), JSON.stringify(partition, null, 2), "utf8");
     for (const shard of finalShards) {
-      writeFileSync10(shardFilePath(pDir, shard.id), JSON.stringify(shard, null, 2), "utf8");
+      writeFileSync11(shardFilePath(pDir, shard.id), JSON.stringify(shard, null, 2), "utf8");
     }
   }
   const index = {
@@ -15612,7 +15785,7 @@ function buildTreeIndex(store, memoryDir, config = {}) {
     totalMemories: totalIndexMemories,
     builtAt: nowIso3()
   };
-  writeFileSync10(globalIndexFilePath(indexDir(memoryDir)), JSON.stringify(index, null, 2), "utf8");
+  writeFileSync11(globalIndexFilePath(indexDir(memoryDir)), JSON.stringify(index, null, 2), "utf8");
   return index;
 }
 function loadTreeIndex(memoryDir) {
@@ -15765,7 +15938,7 @@ __export(exports_vector, {
   saveIndex: () => saveIndex,
   termFrequencies: () => termFrequencies
 });
-import { existsSync as existsSync25, readFileSync as readFileSync21, writeFileSync as writeFileSync11, mkdirSync as mkdirSync13 } from "node:fs";
+import { existsSync as existsSync25, readFileSync as readFileSync21, writeFileSync as writeFileSync12, mkdirSync as mkdirSync14 } from "node:fs";
 import { join as join22 } from "node:path";
 function indexFilePath(memoryDir) {
   return join22(memoryDir, "index.json");
@@ -15816,8 +15989,8 @@ function rebuildIndex(store) {
 }
 function saveIndex(index, memoryDir) {
   if (!existsSync25(memoryDir))
-    mkdirSync13(memoryDir, { recursive: true });
-  writeFileSync11(indexFilePath(memoryDir), JSON.stringify(index), "utf8");
+    mkdirSync14(memoryDir, { recursive: true });
+  writeFileSync12(indexFilePath(memoryDir), JSON.stringify(index), "utf8");
 }
 function loadIndex(memoryDir) {
   const p = indexFilePath(memoryDir);
@@ -15896,7 +16069,7 @@ var init_vector = __esm(() => {
 });
 
 // src/pageindex/engine.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync14, readFileSync as readFileSync22, writeFileSync as writeFileSync12, rmSync as rmSync2, readdirSync as readdirSync9 } from "node:fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync15, readFileSync as readFileSync22, writeFileSync as writeFileSync13, rmSync as rmSync2, readdirSync as readdirSync9 } from "node:fs";
 import { join as join23 } from "node:path";
 function slugify2(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
@@ -15975,8 +16148,8 @@ function buildPageIndex(content, options) {
   };
   if (options.memoryDir && !options.dryRun) {
     const dir = join23(options.memoryDir, "pageindex", project);
-    mkdirSync14(dir, { recursive: true });
-    writeFileSync12(join23(dir, `${indexId}.json`), JSON.stringify(doc, null, 2), "utf8");
+    mkdirSync15(dir, { recursive: true });
+    writeFileSync13(join23(dir, `${indexId}.json`), JSON.stringify(doc, null, 2), "utf8");
   }
   return doc;
 }
@@ -25867,7 +26040,7 @@ var init_loops = __esm(() => {
 });
 
 // src/distill.ts
-import { existsSync as existsSync28, mkdirSync as mkdirSync15, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync16, writeFileSync as writeFileSync14 } from "node:fs";
 import { join as join25 } from "node:path";
 function fixTokens(e) {
   const bag = tokenBag(e.title, 2);
@@ -25899,8 +26072,8 @@ function distillSkills(store, workspaceRoot, options = {}) {
       throw new Error(`Secret detected in generated SKILL.md for '${slug}': ${secrets.join(", ")}`);
     }
     if (!options.dryRun) {
-      mkdirSync15(dir, { recursive: true });
-      writeFileSync13(join25(dir, "SKILL.md"), md, "utf8");
+      mkdirSync16(dir, { recursive: true });
+      writeFileSync14(join25(dir, "SKILL.md"), md, "utf8");
     }
     report.created.push({ slug, path: join25(dir, "SKILL.md"), members: memberIds });
   }
@@ -26240,7 +26413,7 @@ var init_schema2 = __esm(() => {
 });
 
 // src/settings/loader.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync16, readFileSync as readFileSync23, writeFileSync as writeFileSync14 } from "node:fs";
+import { existsSync as existsSync29, mkdirSync as mkdirSync17, readFileSync as readFileSync23, writeFileSync as writeFileSync15 } from "node:fs";
 import { join as join26 } from "node:path";
 function getSettingsFilePath(memoryDir) {
   return join26(memoryDir, "settings.json");
@@ -26271,9 +26444,9 @@ function loadSettings(memoryDir) {
   }
 }
 function saveSettings(store, memoryDir) {
-  mkdirSync16(memoryDir, { recursive: true });
+  mkdirSync17(memoryDir, { recursive: true });
   const filePath = getSettingsFilePath(memoryDir);
-  writeFileSync14(filePath, JSON.stringify(store, null, 2), "utf8");
+  writeFileSync15(filePath, JSON.stringify(store, null, 2), "utf8");
 }
 function getSettings(memoryDir) {
   return loadSettings(memoryDir).global;
@@ -26832,6 +27005,14 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
           properties: {}
         }
       },
+      {
+        name: "graph_index",
+        description: "Index AST symbols from the project's CodeGraph/Graphify provider and cache in .memory/",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
       {
         name: "memory_tree_search",
         description: "Hierarchical tree-indexed reasoning search across partitioned memory shards",
@@ -27267,6 +27448,10 @@ Resolution: ${String(a.resolution)}`;
           const status = getGraphStatus(activeRoot);
           return toolResult(status);
         }
+        case "graph_index": {
+          const index = indexGraph(activeRoot, activeMemoryDir);
+          return toolResult(index);
+        }
         case "memory_detect_providers": {
           const detected = detectProviders(activeRoot);
           return toolResult(detected);
@@ -27628,7 +27813,7 @@ var init_daemon = () => {};
 
 // src/cli/ecosystem.ts
 import { join as join28 } from "node:path";
-import { existsSync as existsSync31, mkdirSync as mkdirSync17, writeFileSync as writeFileSync15, readFileSync as readFileSync24 } from "node:fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync18, writeFileSync as writeFileSync16, readFileSync as readFileSync24 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 function ensureProjectAgentInstructions(targetDir) {
   const agentsMdPath = join28(targetDir, "AGENTS.md");
@@ -27637,9 +27822,9 @@ function ensureProjectAgentInstructions(targetDir) {
       const existing = readFileSync24(agentsMdPath, "utf8");
       if (existing.includes("<!-- agentmemory:start -->")) {
         const updated = existing.replace(/<!-- agentmemory:start -->[\s\S]*?<!-- agentmemory:end -->/, MUSE_MEMORY_DIRECTIVE);
-        writeFileSync15(agentsMdPath, updated, "utf8");
+        writeFileSync16(agentsMdPath, updated, "utf8");
       } else if (!existing.includes("<!-- musememory:start -->") && !existing.includes("Muse Memory")) {
-        writeFileSync15(agentsMdPath, `${existing.trim()}
+        writeFileSync16(agentsMdPath, `${existing.trim()}
 
 ${MUSE_MEMORY_DIRECTIVE}
 `, "utf8");
@@ -27650,7 +27835,7 @@ ${MUSE_MEMORY_DIRECTIVE}
 
 ${MUSE_MEMORY_DIRECTIVE}
 `;
-    writeFileSync15(agentsMdPath, initialContent, "utf8");
+    writeFileSync16(agentsMdPath, initialContent, "utf8");
   }
 }
 async function handleInstallCommand({ positional, flags }) {
@@ -27658,11 +27843,11 @@ async function handleInstallCommand({ positional, flags }) {
   const targetDir = positional[0] ? join28(process.cwd(), positional[0]) : process.cwd();
   const memoryDir = isGlobal ? getGlobalMemoryDir() : join28(targetDir, ".memory");
   const globalDir = getGlobalMemoryDir();
-  mkdirSync17(join28(memoryDir, "memories"), { recursive: true });
-  mkdirSync17(join28(globalDir, "memories"), { recursive: true });
+  mkdirSync18(join28(memoryDir, "memories"), { recursive: true });
+  mkdirSync18(join28(globalDir, "memories"), { recursive: true });
   const currentPath = join28(memoryDir, "CURRENT.md");
   if (!existsSync31(currentPath)) {
-    writeFileSync15(currentPath, `# Active Project Constraints
+    writeFileSync16(currentPath, `# Active Project Constraints
 `, "utf8");
   }
   const globalUserPath = userFilePath(globalDir);
@@ -27688,7 +27873,7 @@ async function handleInstallCommand({ positional, flags }) {
       const existing = readFileSync24(globalAgentsMd, "utf8");
       if (existing.includes("<!-- agentmemory:start -->")) {
         const updated = existing.replace(/<!-- agentmemory:start -->[\s\S]*?<!-- agentmemory:end -->/, MUSE_MEMORY_DIRECTIVE);
-        writeFileSync15(globalAgentsMd, updated, "utf8");
+        writeFileSync16(globalAgentsMd, updated, "utf8");
       }
     } catch {}
   }
@@ -27780,10 +27965,10 @@ async function handleInitCommand({ positional, flags }) {
   const targetDir = positional[0] ? join28(process.cwd(), positional[0]) : process.cwd();
   const memoryDirName = flags["legacy"] === "true" ? ".musememory" : ".memory";
   const memoryDir = isGlobal ? getGlobalMemoryDir() : join28(targetDir, memoryDirName);
-  mkdirSync17(join28(memoryDir, "memories"), { recursive: true });
+  mkdirSync18(join28(memoryDir, "memories"), { recursive: true });
   const currentPath = join28(memoryDir, "CURRENT.md");
   if (!existsSync31(currentPath)) {
-    writeFileSync15(currentPath, `# Active Project Constraints
+    writeFileSync16(currentPath, `# Active Project Constraints
 `, "utf8");
   }
   if (!isGlobal) {
@@ -27974,7 +28159,7 @@ async function handleGraphCommand({ positional, flags }) {
   const ctx = requireRoot(flags);
   if (!ctx)
     return 1;
-  const sub = positional[0];
+  const sub = positional[0] ?? "status";
   if (sub === "status") {
     const status = getGraphStatus(ctx.root);
     console.log(`graph provider: ${status.provider}`);
@@ -27986,7 +28171,13 @@ async function handleGraphCommand({ positional, flags }) {
       console.log(`symbols: ${status.symbolCount}`);
     return 0;
   }
-  return usageError("graph requires status");
+  if (sub === "index") {
+    const index = indexGraph(ctx.root, ctx.memoryDir);
+    console.log(`[AST Graph] Indexed ${index.symbolCount} symbols from provider "${index.provider}"`);
+    console.log(`Cached symbol index at: ${ctx.memoryDir}/graph-symbols.json`);
+    return 0;
+  }
+  return usageError("graph requires 'status' or 'index'");
 }
 async function handleMcpCommand() {
   const { runMcpServer: runMcpServer2 } = await Promise.resolve().then(() => (init_mcp(), exports_mcp));
@@ -28670,7 +28861,7 @@ var init_entities2 = __esm(() => {
 });
 
 // src/cli/settings.ts
-import { writeFileSync as writeFileSync16, readFileSync as readFileSync26 } from "node:fs";
+import { writeFileSync as writeFileSync17, readFileSync as readFileSync26 } from "node:fs";
 function handleSettingsCommand(parsed) {
   const ctx = requireRoot(parsed.flags);
   if (!ctx)
@@ -28752,7 +28943,7 @@ function handleSettingsCommand(parsed) {
     const out = parsed.flags.out;
     const json2 = exportSettings(memoryDir);
     if (out) {
-      writeFileSync16(out, json2, "utf8");
+      writeFileSync17(out, json2, "utf8");
       console.log(`Exported settings to ${out}`);
     } else {
       console.log(json2);
@@ -28836,7 +29027,7 @@ var init_routines = __esm(() => {
 });
 
 // src/cli/lifecycle.ts
-import { writeFileSync as writeFileSync17, readFileSync as readFileSync28, existsSync as existsSync35 } from "node:fs";
+import { writeFileSync as writeFileSync18, readFileSync as readFileSync28, existsSync as existsSync35 } from "node:fs";
 async function handleProposeCommand({ positional, flags }) {
   const ctx = requireRoot(flags);
   if (!ctx)
@@ -28985,7 +29176,7 @@ async function handleExportCommand({ flags }) {
   const snapshot = exportSnapshot(ctx.store);
   const outPath = flags["out"];
   if (outPath) {
-    writeFileSync17(outPath, JSON.stringify(snapshot, null, 2), "utf8");
+    writeFileSync18(outPath, JSON.stringify(snapshot, null, 2), "utf8");
     console.log(`exported ${snapshot.total} memories to ${outPath}`);
   } else {
     console.log(JSON.stringify(snapshot, null, 2));
@@ -29540,7 +29731,7 @@ Ecosystem, Migration & Connectivity:
   export [--out file.json]      Export portable JSON memory snapshot
   import <file.json>            Import portable JSON memory snapshot
   validate [--dry-run]          Validate YAML schemas and referential integrity
-  graph status                  Inspect CodeGraph AST provider status
+  graph [status|index]          Inspect or index CodeGraph/Graphify AST provider symbols
   ui / dashboard [--port 2222]  Launch embedded visual knowledge graph UI
   daemon [--port N]             Real-time agency hub (SSE event stream + publish API, default port 7878)
   mcp                           Run stdio MCP server for agent platforms