musememory 1.6.0 → 1.7.0

package/dist/index.js

@@ -4,7 +4,6 @@ var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 function __accessProp(key) {
   return this[key];
@@ -33,23 +32,6 @@ var __toESM = (mod, isNodeMode, target) => {
     cache.set(mod, to);
   return to;
 };
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -110,7 +92,7 @@ var init_secrets = __esm(() => {
     },
     {
       name: "Private Key Block",
-      pattern: /-----BEGIN (?:RSA|DSA|EC|OPENSSH|PGP|ENCRYPTED|PRIVATE)? ?KEY|PRIVATE KEY/i
+      pattern: /-----BEGIN (?:RSA|DSA|EC|OPENSSH|PGP|ENCRYPTED|PRIVATE)? ?(?:PRIVATE )?KEY/i
     },
     {
       name: "Slack Token",
@@ -3532,7 +3514,14 @@ var init_types = __esm(() => {
 // src/retrieval.ts
 import { existsSync as existsSync4 } from "node:fs";
 import { join as join4 } from "node:path";
+function tokenize(text) {
+  if (!text || typeof text !== "string")
+    return [];
+  return text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+}
 function stalePolicyDays(type2) {
+  if (!type2)
+    return DEFAULT_STALE_DAYS;
   switch (type2) {
     case "fix":
       return 90;
@@ -3548,11 +3537,6 @@ function stalePolicyDays(type2) {
       return DEFAULT_STALE_DAYS;
   }
 }
-function tokenize(text) {
-  if (!text || typeof text !== "string")
-    return [];
-  return text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
-}
 function estimateEntryTokens(entry) {
   const text = `${entry.id} ${entry.status} ${entry.project} ${entry.title}
 ${entry.content}
@@ -3593,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;
@@ -3602,18 +3596,23 @@ 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) => {
     if (b.score !== a.score)
       return b.score - a.score;
-    const u = Date.parse(b.entry.updated_at) - Date.parse(a.entry.updated_at);
+    const bU = Date.parse(b.entry.updated_at);
+    const aU = Date.parse(a.entry.updated_at);
+    const u = (Number.isNaN(bU) ? 0 : bU) - (Number.isNaN(aU) ? 0 : aU);
     if (u !== 0)
       return u;
-    return Date.parse(b.entry.created_at) - Date.parse(a.entry.created_at);
+    const bC = Date.parse(b.entry.created_at);
+    const aC = Date.parse(a.entry.created_at);
+    return (Number.isNaN(bC) ? 0 : bC) - (Number.isNaN(aC) ? 0 : aC);
   });
 }
 function queryContext(store, query = "", options = {}) {
@@ -3648,14 +3647,16 @@ function queryContext(store, query = "", options = {}) {
   const limit = options.limit ?? 10;
   const results = [];
   let totalTokensUsed = 0;
-  if (options.tokenBudget && options.tokenBudget > 0) {
-    for (const item of scored) {
-      if (results.length >= limit)
-        break;
-      const tokens = estimateEntryTokens(item.entry);
-      if (totalTokensUsed + tokens <= options.tokenBudget) {
-        results.push(item);
-        totalTokensUsed += tokens;
+  if (options.tokenBudget !== undefined) {
+    if (options.tokenBudget > 0) {
+      for (const item of scored) {
+        if (results.length >= limit)
+          break;
+        const tokens = estimateEntryTokens(item.entry);
+        if (totalTokensUsed + tokens <= options.tokenBudget) {
+          results.push(item);
+          totalTokensUsed += tokens;
+        }
       }
     }
   } else {
@@ -3694,7 +3695,6 @@ function formatPromptContext(store, memoryDir, query = "", options = {}) {
     }
     parts.push("");
   }
-  const { getSessionHandoff } = (init_current(), __toCommonJS(exports_current));
   const handoff = memoryDir ? getSessionHandoff(memoryDir) : null;
   if (handoff && (handoff.status === "IN-PROGRESS" || handoff.task || handoff.lastQuery)) {
     parts.push("### Active In-Flight Context & Session Handoff (CURRENT.md)");
@@ -3721,7 +3721,6 @@ function formatPromptContext(store, memoryDir, query = "", options = {}) {
   }
   if (memoryDir && existsSync4(join4(memoryDir, "wiki"))) {
     try {
-      const { listWikiPages } = (init_wiki(), __toCommonJS(exports_wiki));
       const wikiPages = listWikiPages(memoryDir, { detailLevel: "l1", project: options.project });
       if (wikiPages.length > 0) {
         const queryTokens = tokenize(query);
@@ -3729,7 +3728,8 @@ function formatPromptContext(store, memoryDir, query = "", options = {}) {
         if (relevantWiki.length > 0) {
           parts.push("### Compiled Knowledge & Concepts (Wiki L1)");
           for (const wp of relevantWiki) {
-            parts.push(`- [[${wp.slug}]]: ${wp.title}${wp.summary ? ` — ${wp.summary}` : ""}`);
+            const sum = wp.summary;
+            parts.push(`- [[${wp.slug}]]: ${wp.title}${sum ? ` — ${sum}` : ""}`);
           }
           parts.push("");
         }
@@ -3792,12 +3792,190 @@ function formatPromptContext(store, memoryDir, query = "", options = {}) {
     userProfile
   };
 }
+var STOPWORDS;
 var init_retrieval = __esm(() => {
   init_store();
-  init_current();
+  init_governor();
+  init_compiler();
   init_user();
   init_core();
   init_types();
+  STOPWORDS = new Set([
+    "a",
+    "about",
+    "above",
+    "after",
+    "again",
+    "against",
+    "all",
+    "am",
+    "an",
+    "and",
+    "any",
+    "are",
+    "aren't",
+    "as",
+    "at",
+    "be",
+    "because",
+    "been",
+    "before",
+    "being",
+    "below",
+    "between",
+    "both",
+    "but",
+    "by",
+    "can't",
+    "cannot",
+    "could",
+    "couldn't",
+    "did",
+    "didn't",
+    "do",
+    "does",
+    "doesn't",
+    "doing",
+    "don't",
+    "down",
+    "during",
+    "each",
+    "few",
+    "for",
+    "from",
+    "further",
+    "had",
+    "hadn't",
+    "has",
+    "hasn't",
+    "have",
+    "haven't",
+    "having",
+    "he",
+    "he'd",
+    "he'll",
+    "he's",
+    "her",
+    "here",
+    "here's",
+    "hers",
+    "herself",
+    "him",
+    "himself",
+    "his",
+    "how",
+    "how's",
+    "i",
+    "i'd",
+    "i'll",
+    "i'm",
+    "i've",
+    "if",
+    "in",
+    "into",
+    "is",
+    "isn't",
+    "it",
+    "it's",
+    "its",
+    "itself",
+    "let's",
+    "me",
+    "more",
+    "most",
+    "mustn't",
+    "my",
+    "myself",
+    "no",
+    "nor",
+    "not",
+    "of",
+    "off",
+    "on",
+    "once",
+    "only",
+    "or",
+    "other",
+    "ought",
+    "our",
+    "ours",
+    "ourselves",
+    "out",
+    "over",
+    "own",
+    "same",
+    "shan't",
+    "she",
+    "she'd",
+    "she'll",
+    "she's",
+    "should",
+    "shouldn't",
+    "so",
+    "some",
+    "such",
+    "than",
+    "that",
+    "that's",
+    "the",
+    "their",
+    "theirs",
+    "them",
+    "themselves",
+    "then",
+    "there",
+    "there's",
+    "these",
+    "they",
+    "they'd",
+    "they'll",
+    "they're",
+    "they've",
+    "this",
+    "those",
+    "through",
+    "to",
+    "too",
+    "under",
+    "until",
+    "up",
+    "very",
+    "was",
+    "wasn't",
+    "we",
+    "we'd",
+    "we'll",
+    "we're",
+    "we've",
+    "were",
+    "weren't",
+    "what",
+    "what's",
+    "when",
+    "when's",
+    "where",
+    "where's",
+    "which",
+    "while",
+    "who",
+    "who's",
+    "whom",
+    "why",
+    "why's",
+    "with",
+    "won't",
+    "would",
+    "wouldn't",
+    "you",
+    "you'd",
+    "you'll",
+    "you're",
+    "you've",
+    "your",
+    "yours",
+    "yourself",
+    "yourselves"
+  ]);
 });
 
 // src/governor.ts
@@ -4062,22 +4240,6 @@ function recordSessionEnd(store, sessionId, project, summary) {
   save(store, entry);
   return entry;
 }
-function getSessionMemories(store, sessionId) {
-  return list(store).filter((e) => e.session_id === sessionId && e.type !== "session");
-}
-function linkMemoriesToSession(store, sessionId, memoryIds) {
-  const updated = [];
-  const entries = list(store);
-  for (const id of memoryIds) {
-    const entry = entries.find((e) => e.id === id);
-    if (entry) {
-      entry.session_id = sessionId;
-      save(store, entry);
-      updated.push(entry);
-    }
-  }
-  return updated;
-}
 function probeGit(workspaceRoot) {
   const items = [];
   try {
@@ -4255,374 +4417,120 @@ var init_governor = __esm(() => {
 });
 
 // src/current.ts
-var exports_current = {};
-__export(exports_current, {
-  WorkspaceGovernor: () => WorkspaceGovernor,
-  collectLoops: () => collectLoops,
-  collectNudges: () => collectNudges,
-  currentFilePath: () => currentFilePath,
-  dueEntries: () => dueEntries,
-  findSession: () => findSession,
-  getCurrent: () => getCurrent2,
-  getSessionHandoff: () => getSessionHandoff,
-  getSessionMemories: () => getSessionMemories,
-  linkMemoriesToSession: () => linkMemoriesToSession,
-  markSessionCompleted: () => markSessionCompleted,
-  parseCurrentFile: () => parseCurrentFile,
-  recordSessionEnd: () => recordSessionEnd,
-  recordSessionStart: () => recordSessionStart,
-  renderLoops: () => renderLoops,
-  renderNudges: () => renderNudges,
-  setCurrent: () => setCurrent,
-  syncConstraints: () => syncConstraints,
-  updateSessionHandoff: () => updateSessionHandoff,
-  writeCurrentFile: () => writeCurrentFile
-});
 var init_current = __esm(() => {
   init_governor();
 });
 
-// src/sqlite.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync5 } from "node:fs";
-import { dirname } from "node:path";
-function getDriver() {
-  if (sqliteDriver !== "none")
-    return sqliteDriver;
-  try {
-    if (typeof globalThis.Bun !== "undefined") {
-      sqliteDriver = "bun";
-      return "bun";
+// src/transcript.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
+function parseJsonlTranscript(jsonlText) {
+  if (!jsonlText)
+    return [];
+  const lines = jsonlText.split(`
+`).map((l) => l.trim()).filter(Boolean);
+  const blocks = [];
+  for (const line of lines) {
+    try {
+      const obj = JSON.parse(line);
+      const prevLen = blocks.length;
+      if (typeof obj.content === "string") {
+        blocks.push(obj.content);
+      } else if (Array.isArray(obj.content)) {
+        for (const item of obj.content) {
+          if (typeof item === "string")
+            blocks.push(item);
+          else if (item && typeof item.text === "string")
+            blocks.push(item.text);
+        }
+      }
+      if (typeof obj.thinking === "string") {
+        blocks.push(obj.thinking);
+      }
+      if (typeof obj.message === "string") {
+        blocks.push(obj.message);
+      }
+      if (typeof obj.text === "string") {
+        blocks.push(obj.text);
+      }
+      if (typeof obj.path === "string") {
+        blocks.push(obj.path);
+      }
+      if (obj.tool_calls && Array.isArray(obj.tool_calls)) {
+        for (const tc of obj.tool_calls) {
+          if (tc.arguments && typeof tc.arguments === "string")
+            blocks.push(tc.arguments);
+        }
+      }
+      if (blocks.length === prevLen) {
+        const textParts = Object.values(obj).filter((v) => typeof v === "string").join(" ");
+        blocks.push(textParts.length > 0 ? textParts : line);
+      }
+    } catch {
+      blocks.push(line);
     }
-  } catch {}
-  try {
-    __require("node:sqlite");
-    sqliteDriver = "node";
-    return "node";
-  } catch {}
-  sqliteDriver = "bun";
-  return "bun";
+  }
+  return blocks;
 }
-function openDatabase(dbPath) {
-  const dir = dirname(dbPath);
-  if (!existsSync6(dir)) {
-    mkdirSync5(dir, { recursive: true });
+function searchTranscriptWithBookends(transcriptPathOrContent, query, options = {}) {
+  let content = transcriptPathOrContent;
+  if (existsSync6(transcriptPathOrContent)) {
+    content = readFileSync5(transcriptPathOrContent, "utf8");
   }
-  const driver = getDriver();
-  let rawDb;
-  if (driver === "bun") {
-    const { Database } = __require("bun:sqlite");
-    rawDb = new Database(dbPath, { create: true });
-    rawDb.run("PRAGMA journal_mode = WAL;");
-    rawDb.run("PRAGMA synchronous = NORMAL;");
-    const db = {
-      exec(sql) {
-        rawDb.exec(sql);
-      },
-      run(sql, params) {
-        if (params && Array.isArray(params)) {
-          rawDb.run(sql, params);
-        } else if (params && typeof params === "object") {
-          rawDb.run(sql, params);
-        } else {
-          rawDb.run(sql);
-        }
-      },
-      query(sql) {
-        const stmt = rawDb.query(sql);
-        return {
-          all(params) {
-            return params ? stmt.all(params) : stmt.all();
-          },
-          get(params) {
-            return params ? stmt.get(params) : stmt.get();
-          }
-        };
-      },
-      close() {
-        rawDb.close();
-      }
+  const turns = parseJsonlTranscript(content);
+  if (turns.length === 0) {
+    return {
+      totalTurns: 0,
+      bookendStart: "",
+      bookendEnd: "",
+      matches: [],
+      formattedSummary: "No turns found in transcript."
     };
-    initSchema(db);
-    return db;
+  }
+  const windowSize = options.windowSize ?? 2;
+  const maxMatches = options.maxMatches ?? 5;
+  const bookendStart = turns[0] ?? "";
+  const bookendEnd = turns[turns.length - 1] ?? "";
+  const queryTerms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  const matches = [];
+  for (let i = 0;i < turns.length; i++) {
+    if (matches.length >= maxMatches)
+      break;
+    const turnLower = turns[i].toLowerCase();
+    const isMatch = queryTerms.length > 0 && queryTerms.every((term) => turnLower.includes(term));
+    if (isMatch) {
+      const before = turns.slice(Math.max(0, i - windowSize), i);
+      const after = turns.slice(i + 1, Math.min(turns.length, i + 1 + windowSize));
+      matches.push({
+        index: i,
+        matchedTurn: turns[i],
+        before,
+        after
+      });
+    }
+  }
+  const lines = [];
+  lines.push(`### Conversation Overview (${turns.length} total turns)`);
+  lines.push(`**[Start Bookend]**: ${bookendStart.slice(0, 200).replace(/\n+/g, " ")}`);
+  lines.push(`**[End Bookend]**: ${bookendEnd.slice(0, 200).replace(/\n+/g, " ")}`);
+  lines.push("");
+  if (matches.length === 0) {
+    lines.push(`*No matches found for query "${query}".*`);
   } else {
-    const { DatabaseSync } = __require("node:sqlite");
-    rawDb = new DatabaseSync(dbPath);
-    rawDb.exec("PRAGMA journal_mode = WAL;");
-    rawDb.exec("PRAGMA synchronous = NORMAL;");
-    const db = {
-      exec(sql) {
-        rawDb.exec(sql);
-      },
-      run(sql, params) {
-        const stmt = rawDb.prepare(sql);
-        if (params && Array.isArray(params)) {
-          stmt.run(...params);
-        } else if (params && typeof params === "object") {
-          stmt.run(params);
-        } else {
-          stmt.run();
-        }
-      },
-      query(sql) {
-        const stmt = rawDb.prepare(sql);
-        return {
-          all(params) {
-            if (params && Array.isArray(params))
-              return stmt.all(...params);
-            if (params && typeof params === "object")
-              return stmt.all(params);
-            return stmt.all();
-          },
-          get(params) {
-            if (params && Array.isArray(params))
-              return stmt.get(...params);
-            if (params && typeof params === "object")
-              return stmt.get(params);
-            return stmt.get();
-          }
-        };
-      },
-      close() {
-        rawDb.close();
+    lines.push(`### Matches for "${query}" (${matches.length} found):`);
+    matches.forEach((m, idx) => {
+      lines.push(`
+#### Match ${idx + 1} (Turn ${m.index + 1})`);
+      if (m.before.length > 0) {
+        lines.push(`*Context Before:*`);
+        m.before.forEach((b) => lines.push(`> ${b.slice(0, 150).replace(/\n+/g, " ")}`));
       }
-    };
-    initSchema(db);
-    return db;
-  }
-}
-function initSchema(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS memories (
-      id TEXT PRIMARY KEY,
-      title TEXT NOT NULL,
-      content TEXT NOT NULL,
-      project TEXT NOT NULL,
-      type TEXT NOT NULL,
-      status TEXT NOT NULL,
-      salience REAL,
-      reinforcement INTEGER,
-      session_id TEXT,
-      due_at TEXT,
-      expires_at TEXT,
-      valid_from TEXT,
-      valid_to TEXT,
-      data TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project);
-    CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
-    CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status);
-    CREATE INDEX IF NOT EXISTS idx_memories_session_id ON memories(session_id);
-    CREATE INDEX IF NOT EXISTS idx_memories_due_at ON memories(due_at);
-    CREATE INDEX IF NOT EXISTS idx_memories_updated_at ON memories(updated_at);
-  `);
-}
-function rowToMemoryEntry(row) {
-  let parsedData = {};
-  try {
-    parsedData = JSON.parse(row.data);
-  } catch {}
-  return {
-    ...parsedData,
-    id: row.id,
-    title: row.title,
-    content: row.content,
-    project: row.project,
-    type: row.type,
-    status: row.status,
-    salience: row.salience !== null ? row.salience : parsedData.salience,
-    reinforcement: row.reinforcement !== null ? row.reinforcement : parsedData.reinforcement,
-    session_id: row.session_id !== null ? row.session_id : parsedData.session_id,
-    due_at: row.due_at !== null ? row.due_at : parsedData.due_at,
-    expires_at: row.expires_at !== null ? row.expires_at : parsedData.expires_at,
-    valid_from: row.valid_from !== null ? row.valid_from : parsedData.valid_from,
-    valid_to: row.valid_to !== null ? row.valid_to : parsedData.valid_to,
-    created_at: row.created_at || parsedData.created_at || new Date().toISOString(),
-    updated_at: row.updated_at || parsedData.updated_at || new Date().toISOString()
-  };
-}
-function insertOrReplaceMemory(db, entry) {
-  const sql = `
-    INSERT OR REPLACE INTO memories (
-      id, title, content, project, type, status, salience, reinforcement,
-      session_id, due_at, expires_at, valid_from, valid_to, data,
-      created_at, updated_at
-    ) VALUES (
-      ?, ?, ?, ?, ?, ?, ?, ?,
-      ?, ?, ?, ?, ?, ?,
-      ?, ?
-    )
-  `;
-  db.run(sql, [
-    entry.id,
-    entry.title,
-    entry.content,
-    entry.project,
-    entry.type || "discovery",
-    entry.status,
-    typeof entry.salience === "number" ? entry.salience : null,
-    typeof entry.reinforcement === "number" ? entry.reinforcement : null,
-    entry.session_id ?? null,
-    entry.due_at ?? null,
-    entry.expires_at ?? null,
-    entry.valid_from ?? null,
-    entry.valid_to ?? null,
-    JSON.stringify(entry),
-    entry.created_at,
-    entry.updated_at
-  ]);
-}
-function getMemoryById(db, id) {
-  const row = db.query(`SELECT * FROM memories WHERE id = ? LIMIT 1`).get([id]);
-  if (!row)
-    return null;
-  return rowToMemoryEntry(row);
-}
-function listMemories(db, filters) {
-  let sql = `SELECT * FROM memories`;
-  const conditions = [];
-  const params = [];
-  if (filters?.project) {
-    conditions.push(`project = ?`);
-    params.push(filters.project);
-  }
-  if (filters?.type) {
-    conditions.push(`type = ?`);
-    params.push(filters.type);
-  }
-  if (filters?.status) {
-    conditions.push(`status = ?`);
-    params.push(filters.status);
-  }
-  if (conditions.length > 0) {
-    sql += ` WHERE ` + conditions.join(` AND `);
-  }
-  sql += ` ORDER BY updated_at DESC`;
-  const rows = db.query(sql).all(params.length > 0 ? params : undefined);
-  return rows.map(rowToMemoryEntry);
-}
-function deleteMemoryById(db, id) {
-  const existing = getMemoryById(db, id);
-  if (!existing)
-    return false;
-  db.run(`DELETE FROM memories WHERE id = ?`, [id]);
-  return true;
-}
-var sqliteDriver = "none";
-var init_sqlite = () => {};
-
-// src/transcript.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
-function parseJsonlTranscript(jsonlText) {
-  if (!jsonlText)
-    return [];
-  const lines = jsonlText.split(`
-`).map((l) => l.trim()).filter(Boolean);
-  const blocks = [];
-  for (const line of lines) {
-    try {
-      const obj = JSON.parse(line);
-      const prevLen = blocks.length;
-      if (typeof obj.content === "string") {
-        blocks.push(obj.content);
-      } else if (Array.isArray(obj.content)) {
-        for (const item of obj.content) {
-          if (typeof item === "string")
-            blocks.push(item);
-          else if (item && typeof item.text === "string")
-            blocks.push(item.text);
-        }
-      }
-      if (typeof obj.thinking === "string") {
-        blocks.push(obj.thinking);
-      }
-      if (typeof obj.message === "string") {
-        blocks.push(obj.message);
-      }
-      if (typeof obj.text === "string") {
-        blocks.push(obj.text);
-      }
-      if (typeof obj.path === "string") {
-        blocks.push(obj.path);
-      }
-      if (obj.tool_calls && Array.isArray(obj.tool_calls)) {
-        for (const tc of obj.tool_calls) {
-          if (tc.arguments && typeof tc.arguments === "string")
-            blocks.push(tc.arguments);
-        }
-      }
-      if (blocks.length === prevLen) {
-        const textParts = Object.values(obj).filter((v) => typeof v === "string").join(" ");
-        blocks.push(textParts.length > 0 ? textParts : line);
-      }
-    } catch {
-      blocks.push(line);
-    }
-  }
-  return blocks;
-}
-function searchTranscriptWithBookends(transcriptPathOrContent, query, options = {}) {
-  let content = transcriptPathOrContent;
-  if (existsSync7(transcriptPathOrContent)) {
-    content = readFileSync5(transcriptPathOrContent, "utf8");
-  }
-  const turns = parseJsonlTranscript(content);
-  if (turns.length === 0) {
-    return {
-      totalTurns: 0,
-      bookendStart: "",
-      bookendEnd: "",
-      matches: [],
-      formattedSummary: "No turns found in transcript."
-    };
-  }
-  const windowSize = options.windowSize ?? 2;
-  const maxMatches = options.maxMatches ?? 5;
-  const bookendStart = turns[0] ?? "";
-  const bookendEnd = turns[turns.length - 1] ?? "";
-  const queryTerms = query.toLowerCase().split(/\s+/).filter(Boolean);
-  const matches = [];
-  for (let i = 0;i < turns.length; i++) {
-    if (matches.length >= maxMatches)
-      break;
-    const turnLower = turns[i].toLowerCase();
-    const isMatch = queryTerms.length > 0 && queryTerms.every((term) => turnLower.includes(term));
-    if (isMatch) {
-      const before = turns.slice(Math.max(0, i - windowSize), i);
-      const after = turns.slice(i + 1, Math.min(turns.length, i + 1 + windowSize));
-      matches.push({
-        index: i,
-        matchedTurn: turns[i],
-        before,
-        after
-      });
-    }
-  }
-  const lines = [];
-  lines.push(`### Conversation Overview (${turns.length} total turns)`);
-  lines.push(`**[Start Bookend]**: ${bookendStart.slice(0, 200).replace(/\n+/g, " ")}`);
-  lines.push(`**[End Bookend]**: ${bookendEnd.slice(0, 200).replace(/\n+/g, " ")}`);
-  lines.push("");
-  if (matches.length === 0) {
-    lines.push(`*No matches found for query "${query}".*`);
-  } else {
-    lines.push(`### Matches for "${query}" (${matches.length} found):`);
-    matches.forEach((m, idx) => {
-      lines.push(`
-#### Match ${idx + 1} (Turn ${m.index + 1})`);
-      if (m.before.length > 0) {
-        lines.push(`*Context Before:*`);
-        m.before.forEach((b) => lines.push(`> ${b.slice(0, 150).replace(/\n+/g, " ")}`));
-      }
-      lines.push(`**Matched Turn:**
-${m.matchedTurn}`);
-      if (m.after.length > 0) {
-        lines.push(`*Context After:*`);
-        m.after.forEach((a) => lines.push(`> ${a.slice(0, 150).replace(/\n+/g, " ")}`));
-      }
-    });
+      lines.push(`**Matched Turn:**
+${m.matchedTurn}`);
+      if (m.after.length > 0) {
+        lines.push(`*Context After:*`);
+        m.after.forEach((a) => lines.push(`> ${a.slice(0, 150).replace(/\n+/g, " ")}`));
+      }
+    });
   }
   return {
     totalTurns: turns.length,
@@ -4636,15 +4544,7 @@ ${m.matchedTurn}`);
 var init_transcript = () => {};
 
 // src/harvest.ts
-var exports_harvest = {};
-__export(exports_harvest, {
-  defaultSalienceForType: () => defaultSalienceForType,
-  extractCommitments: () => extractCommitments,
-  extractHarvestUnits: () => extractHarvestUnits,
-  importTranscript: () => importTranscript,
-  openLoopId: () => openLoopId
-});
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
 import { createHash } from "node:crypto";
 function extractHarvestUnits(text) {
   if (!text || typeof text !== "string")
@@ -4773,115 +4673,551 @@ function extractCommitments(text) {
   }
   return out;
 }
-function openLoopId(text) {
-  const h = createHash("sha256").update(text.toLowerCase().replace(/\s+/g, " ").trim()).digest("hex");
-  return `m_0_ol${h.slice(0, 12)}`;
+function openLoopId(text) {
+  const h = createHash("sha256").update(text.toLowerCase().replace(/\s+/g, " ").trim()).digest("hex");
+  return `m_0_ol${h.slice(0, 12)}`;
+}
+function importTranscript(store, transcriptPathOrContent, options = {}) {
+  let content = transcriptPathOrContent;
+  if (existsSync7(transcriptPathOrContent)) {
+    content = readFileSync6(transcriptPathOrContent, "utf8");
+  }
+  const blocks = parseJsonlTranscript(content);
+  const fullText = blocks.join(`
+
+`);
+  const units = extractHarvestUnits(fullText);
+  const project = options.project ?? "default";
+  const entries = [];
+  const errors = [];
+  for (const unit of units) {
+    try {
+      const entry = propose(store, {
+        project,
+        title: unit.title,
+        content: unit.content,
+        type: unit.type,
+        tags: unit.tags,
+        source: options.source ?? "transcript_import",
+        confirmed: options.confirmed ?? false
+      });
+      if (options.sessionId) {
+        entry.session_id = options.sessionId;
+        save(store, entry);
+      }
+      entries.push(entry);
+    } catch (err) {
+      errors.push(`Failed to import unit "${unit.title}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const openLoops = [];
+  if (options.openLoops !== false) {
+    const existing = new Set(list(store).map((e) => e.id));
+    for (const commitment of extractCommitments(fullText)) {
+      const id = openLoopId(commitment);
+      if (existing.has(id))
+        continue;
+      try {
+        const entry = propose(store, {
+          id,
+          project,
+          title: commitment.slice(0, 80),
+          content: commitment,
+          type: "operation",
+          tags: ["open-loop", "harvested"],
+          source: options.source ?? "transcript_import"
+        });
+        if (options.sessionId) {
+          entry.session_id = options.sessionId;
+          save(store, entry);
+        }
+        existing.add(id);
+        openLoops.push(entry);
+      } catch (err) {
+        errors.push(`Failed to record open loop "${commitment}": ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  return {
+    imported: entries.length,
+    entries,
+    errors,
+    openLoops
+  };
+}
+var COMMITMENT_PATTERNS;
+var init_harvest = __esm(() => {
+  init_store();
+  init_transcript();
+  COMMITMENT_PATTERNS = [
+    /\btodo\b\s*[:\-]\s*(.{4,})/i,
+    /\b(?:i'll|i will|i am going to)\s+(.{4,})/i,
+    /\bneed to\s+(.{4,})/i,
+    /\bfollow up (?:on|with)\s+(.{4,})/i,
+    /\bremind me to\s+(.{4,})/i
+  ];
+});
+
+// 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 existsSync9, mkdirSync as mkdirSync6 } from "node:fs";
+import { dirname } from "node:path";
+function getDriver() {
+  if (sqliteDriver !== "none")
+    return sqliteDriver;
+  try {
+    if (typeof globalThis.Bun !== "undefined") {
+      sqliteDriver = "bun";
+      return "bun";
+    }
+  } catch {}
+  try {
+    __require("node:sqlite");
+    sqliteDriver = "node";
+    return "node";
+  } catch {}
+  sqliteDriver = "bun";
+  return "bun";
+}
+function openDatabase(dbPath) {
+  const dir = dirname(dbPath);
+  if (!existsSync9(dir)) {
+    mkdirSync6(dir, { recursive: true });
+  }
+  const driver = getDriver();
+  let rawDb;
+  if (driver === "bun") {
+    const { Database } = __require("bun:sqlite");
+    rawDb = new Database(dbPath, { create: true });
+    rawDb.run("PRAGMA journal_mode = WAL;");
+    rawDb.run("PRAGMA synchronous = NORMAL;");
+    const db = {
+      exec(sql) {
+        rawDb.exec(sql);
+      },
+      run(sql, params) {
+        if (params && Array.isArray(params)) {
+          rawDb.run(sql, params);
+        } else if (params && typeof params === "object") {
+          rawDb.run(sql, params);
+        } else {
+          rawDb.run(sql);
+        }
+      },
+      query(sql) {
+        const stmt = rawDb.query(sql);
+        return {
+          all(params) {
+            return params ? stmt.all(params) : stmt.all();
+          },
+          get(params) {
+            return params ? stmt.get(params) : stmt.get();
+          }
+        };
+      },
+      close() {
+        rawDb.close();
+      }
+    };
+    initSchema(db);
+    return db;
+  } else {
+    const { DatabaseSync } = __require("node:sqlite");
+    rawDb = new DatabaseSync(dbPath);
+    rawDb.exec("PRAGMA journal_mode = WAL;");
+    rawDb.exec("PRAGMA synchronous = NORMAL;");
+    const db = {
+      exec(sql) {
+        rawDb.exec(sql);
+      },
+      run(sql, params) {
+        const stmt = rawDb.prepare(sql);
+        if (params && Array.isArray(params)) {
+          stmt.run(...params);
+        } else if (params && typeof params === "object") {
+          stmt.run(params);
+        } else {
+          stmt.run();
+        }
+      },
+      query(sql) {
+        const stmt = rawDb.prepare(sql);
+        return {
+          all(params) {
+            if (params && Array.isArray(params))
+              return stmt.all(...params);
+            if (params && typeof params === "object")
+              return stmt.all(params);
+            return stmt.all();
+          },
+          get(params) {
+            if (params && Array.isArray(params))
+              return stmt.get(...params);
+            if (params && typeof params === "object")
+              return stmt.get(params);
+            return stmt.get();
+          }
+        };
+      },
+      close() {
+        rawDb.close();
+      }
+    };
+    initSchema(db);
+    return db;
+  }
+}
+function initSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memories (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      project TEXT NOT NULL,
+      type TEXT NOT NULL,
+      status TEXT NOT NULL,
+      salience REAL,
+      reinforcement INTEGER,
+      session_id TEXT,
+      due_at TEXT,
+      expires_at TEXT,
+      valid_from TEXT,
+      valid_to TEXT,
+      data TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project);
+    CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
+    CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status);
+    CREATE INDEX IF NOT EXISTS idx_memories_session_id ON memories(session_id);
+    CREATE INDEX IF NOT EXISTS idx_memories_due_at ON memories(due_at);
+    CREATE INDEX IF NOT EXISTS idx_memories_updated_at ON memories(updated_at);
+  `);
+}
+function rowToMemoryEntry(row) {
+  let parsedData = {};
+  try {
+    parsedData = JSON.parse(row.data);
+  } catch {}
+  return {
+    ...parsedData,
+    id: row.id,
+    title: row.title,
+    content: row.content,
+    project: row.project,
+    type: row.type,
+    status: row.status,
+    salience: row.salience !== null ? row.salience : parsedData.salience,
+    reinforcement: row.reinforcement !== null ? row.reinforcement : parsedData.reinforcement,
+    session_id: row.session_id !== null ? row.session_id : parsedData.session_id,
+    due_at: row.due_at !== null ? row.due_at : parsedData.due_at,
+    expires_at: row.expires_at !== null ? row.expires_at : parsedData.expires_at,
+    valid_from: row.valid_from !== null ? row.valid_from : parsedData.valid_from,
+    valid_to: row.valid_to !== null ? row.valid_to : parsedData.valid_to,
+    created_at: row.created_at || parsedData.created_at || new Date().toISOString(),
+    updated_at: row.updated_at || parsedData.updated_at || new Date().toISOString()
+  };
+}
+function insertOrReplaceMemory(db, entry) {
+  const sql = `
+    INSERT OR REPLACE INTO memories (
+      id, title, content, project, type, status, salience, reinforcement,
+      session_id, due_at, expires_at, valid_from, valid_to, data,
+      created_at, updated_at
+    ) VALUES (
+      ?, ?, ?, ?, ?, ?, ?, ?,
+      ?, ?, ?, ?, ?, ?,
+      ?, ?
+    )
+  `;
+  db.run(sql, [
+    entry.id,
+    entry.title,
+    entry.content,
+    entry.project,
+    entry.type || "discovery",
+    entry.status,
+    typeof entry.salience === "number" ? entry.salience : null,
+    typeof entry.reinforcement === "number" ? entry.reinforcement : null,
+    entry.session_id ?? null,
+    entry.due_at ?? null,
+    entry.expires_at ?? null,
+    entry.valid_from ?? null,
+    entry.valid_to ?? null,
+    JSON.stringify(entry),
+    entry.created_at,
+    entry.updated_at
+  ]);
 }
-function importTranscript(store, transcriptPathOrContent, options = {}) {
-  let content = transcriptPathOrContent;
-  if (existsSync8(transcriptPathOrContent)) {
-    content = readFileSync6(transcriptPathOrContent, "utf8");
+function getMemoryById(db, id) {
+  const row = db.query(`SELECT * FROM memories WHERE id = ? LIMIT 1`).get([id]);
+  if (!row)
+    return null;
+  return rowToMemoryEntry(row);
+}
+function listMemories(db, filters) {
+  let sql = `SELECT * FROM memories`;
+  const conditions = [];
+  const params = [];
+  if (filters?.project) {
+    conditions.push(`project = ?`);
+    params.push(filters.project);
   }
-  const blocks = parseJsonlTranscript(content);
-  const fullText = blocks.join(`
-
-`);
-  const units = extractHarvestUnits(fullText);
-  const project = options.project ?? "default";
-  const entries = [];
-  const errors = [];
-  for (const unit of units) {
-    try {
-      const entry = propose(store, {
-        project,
-        title: unit.title,
-        content: unit.content,
-        type: unit.type,
-        tags: unit.tags,
-        source: options.source ?? "transcript_import",
-        confirmed: options.confirmed ?? false
-      });
-      if (options.sessionId) {
-        entry.session_id = options.sessionId;
-        save(store, entry);
-      }
-      entries.push(entry);
-    } catch (err) {
-      errors.push(`Failed to import unit "${unit.title}": ${err instanceof Error ? err.message : String(err)}`);
-    }
+  if (filters?.type) {
+    conditions.push(`type = ?`);
+    params.push(filters.type);
   }
-  const openLoops = [];
-  if (options.openLoops !== false) {
-    const existing = new Set(list(store).map((e) => e.id));
-    for (const commitment of extractCommitments(fullText)) {
-      const id = openLoopId(commitment);
-      if (existing.has(id))
-        continue;
-      try {
-        const entry = propose(store, {
-          id,
-          project,
-          title: commitment.slice(0, 80),
-          content: commitment,
-          type: "operation",
-          tags: ["open-loop", "harvested"],
-          source: options.source ?? "transcript_import"
-        });
-        if (options.sessionId) {
-          entry.session_id = options.sessionId;
-          save(store, entry);
-        }
-        existing.add(id);
-        openLoops.push(entry);
-      } catch (err) {
-        errors.push(`Failed to record open loop "${commitment}": ${err instanceof Error ? err.message : String(err)}`);
-      }
-    }
+  if (filters?.status) {
+    conditions.push(`status = ?`);
+    params.push(filters.status);
   }
-  return {
-    imported: entries.length,
-    entries,
-    errors,
-    openLoops
-  };
+  if (conditions.length > 0) {
+    sql += ` WHERE ` + conditions.join(` AND `);
+  }
+  sql += ` ORDER BY updated_at DESC`;
+  const rows = db.query(sql).all(params.length > 0 ? params : undefined);
+  return rows.map(rowToMemoryEntry);
 }
-var COMMITMENT_PATTERNS;
-var init_harvest = __esm(() => {
-  init_store();
-  init_transcript();
-  COMMITMENT_PATTERNS = [
-    /\btodo\b\s*[:\-]\s*(.{4,})/i,
-    /\b(?:i'll|i will|i am going to)\s+(.{4,})/i,
-    /\bneed to\s+(.{4,})/i,
-    /\bfollow up (?:on|with)\s+(.{4,})/i,
-    /\bremind me to\s+(.{4,})/i
-  ];
-});
+function deleteMemoryById(db, id) {
+  const existing = getMemoryById(db, id);
+  if (!existing)
+    return false;
+  db.run(`DELETE FROM memories WHERE id = ?`, [id]);
+  return true;
+}
+var sqliteDriver = "none";
+var init_sqlite = () => {};
 
 // src/store.ts
-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 { resolve } 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) {
@@ -4898,7 +5234,6 @@ function openStore(memoryDir) {
     syncConstraints(memoryDir, store);
   } catch {}
   try {
-    const { autoCompileWiki } = (init_wiki(), __toCommonJS(exports_wiki));
     autoCompileWiki(store, memoryDir);
   } catch {}
   return store;
@@ -4919,7 +5254,13 @@ function slugifyId(id) {
   return slug.length > 0 ? slug : "entry";
 }
 function fileForId(store, id) {
-  return join6(store.dir, `${slugifyId(id)}.yaml`);
+  const safeFilename = `${slugifyId(id)}.yaml`;
+  const target = resolve(store.dir, safeFilename);
+  const base = resolve(store.dir);
+  if (!target.startsWith(base)) {
+    throw new Error(`Security Violation: Path traversal detected for id "${id}"`);
+  }
+  return target;
 }
 function listIds(store) {
   const ids = new Set;
@@ -4928,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));
       }
@@ -4939,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;
@@ -4953,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;
@@ -5003,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 {}
 }
@@ -5060,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;
@@ -5269,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;
   }
@@ -5290,8 +5632,7 @@ function deleteEntry(store, id, reason, actor) {
   return deleted;
 }
 function harvestMemories(store, params) {
-  const { extractHarvestUnits: extractHarvestUnits2 } = (init_harvest(), __toCommonJS(exports_harvest));
-  const units = extractHarvestUnits2(params.text);
+  const units = extractHarvestUnits(params.text);
   const created = [];
   for (const u of units) {
     try {
@@ -5313,6 +5654,9 @@ var init_store = __esm(() => {
   init_secrets();
   init_audit();
   init_current();
+  init_compiler();
+  init_harvest();
+  init_graph();
   init_root();
   init_sqlite();
 });
@@ -5412,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);
 }
@@ -5622,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 [];
   }
@@ -5640,7 +5984,15 @@ function loadEntities(memoryDir) {
 function findEntity(memoryDir, id) {
   const entities = loadEntities(memoryDir);
   const cleanId = slugify(id);
-  return entities.find((e) => e.id === cleanId || e.name.toLowerCase() === id.toLowerCase()) ?? null;
+  const alphanumericId = id.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return entities.find((e) => {
+    if (e.id === cleanId || e.name.toLowerCase() === id.toLowerCase())
+      return true;
+    if (slugify(e.name) === cleanId)
+      return true;
+    const alphaE = e.id.toLowerCase().replace(/[^a-z0-9]/g, "");
+    return alphaE.length > 0 && alphaE === alphanumericId;
+  }) ?? null;
 }
 function findRelatedEntities(memoryDir, id) {
   const entities = loadEntities(memoryDir);
@@ -5826,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;
@@ -5851,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);
@@ -6101,55 +6453,74 @@ function buildLogPage(logEntries) {
     entries: logEntries
   };
 }
+function stripFrontmatter(content) {
+  const match = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+  if (!match)
+    return content;
+  return content.slice(match[0].length);
+}
 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: content.slice(content.indexOf(`
----
-`) + 5) });
+      map2.set(slug, { ...frontmatter, slug, content: stripFrontmatter(content) });
     } catch {}
   }
   return map2;
 }
 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: content.slice(content.indexOf(`
----
-`) + 5) });
+      map2.set(slug, { ...frontmatter, slug, content: stripFrontmatter(content) });
     } catch {}
   }
   return map2;
 }
 function parseFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!match)
     return {};
-  const lines = match[1].split(`
-`);
+  const lines = match[1].split(/\r?\n/);
   const obj = {};
   for (const line of lines) {
     const idx = line.indexOf(":");
     if (idx > 0) {
       const key = line.slice(0, idx).trim();
-      const value = line.slice(idx + 1).trim();
-      obj[key] = value.replace(/^["']|["']$/g, "");
+      const rawVal = line.slice(idx + 1).trim();
+      if (rawVal.startsWith("[") && rawVal.endsWith("]")) {
+        try {
+          obj[key] = JSON.parse(rawVal);
+          continue;
+        } catch {}
+      }
+      if (rawVal === "true") {
+        obj[key] = true;
+        continue;
+      }
+      if (rawVal === "false") {
+        obj[key] = false;
+        continue;
+      }
+      if (!isNaN(Number(rawVal)) && rawVal !== "") {
+        obj[key] = Number(rawVal);
+        continue;
+      }
+      obj[key] = rawVal.replace(/^["']|["']$/g, "");
     }
   }
   return obj;
@@ -6157,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") {
@@ -6183,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));
@@ -6195,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));
@@ -6203,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 {}
@@ -6225,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);
     }
@@ -6263,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.
@@ -6282,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 = {}) {
@@ -6306,25 +6677,13 @@ var init_compiler = __esm(() => {
 });
 
 // src/wiki/index.ts
-var exports_wiki = {};
-__export(exports_wiki, {
-  autoCompileWiki: () => autoCompileWiki,
-  compileWiki: () => compileWiki,
-  ensureWikiStructure: () => ensureWikiStructure,
-  getWikiPage: () => getWikiPage,
-  listWikiPages: () => listWikiPages,
-  renderConceptPage: () => renderConceptPage,
-  renderEntityPage: () => renderEntityPage,
-  renderIndexPage: () => renderIndexPage,
-  renderLogPage: () => renderLogPage
-});
 var init_wiki = __esm(() => {
   init_compiler();
 });
 
 // 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));
@@ -6337,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);
   }
@@ -6367,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 };
     }
@@ -6399,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 };
@@ -6410,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;
@@ -6454,7 +6813,8 @@ function parseFlags(args) {
 }
 function requireRoot(flags = {}) {
   const isGlobal = flags["global"] === "true";
-  const { root, memoryDir } = findOrCreateProjectRoot(process.cwd(), { global: isGlobal });
+  const startDir = flags["dir"] || process.cwd();
+  const { root, memoryDir } = findOrCreateProjectRoot(startDir, { global: isGlobal });
   return { root, memoryDir, store: openStore(memoryDir) };
 }
 function usageError(msg) {
@@ -6514,23 +6874,23 @@ function normalizeMemoryType(raw) {
 }
 
 // src/migrator/detect.ts
-import { existsSync as existsSync13 } from "node:fs";
-import { join as join10, resolve } 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;
   }
-  return resolve(baseDir, p);
+  return resolve2(baseDir, p);
 }
 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;
       }
@@ -6821,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 = {
@@ -6830,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);
@@ -6883,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) {
@@ -6932,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,
@@ -6957,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 {
@@ -7018,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;
     }
@@ -7035,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();
@@ -7044,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);
@@ -7119,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 {
@@ -7289,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, {
@@ -7402,14 +7718,14 @@ ${title}`);
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     rl.question(`Enter selection (e.g. "1,3" or "all") [default: ${defaultAll ? "all" : "none"}]: `, (answer) => {
       rl.close();
       const result = parseSelectionInput(answer, options, defaultAll);
       if (answer.trim().toLowerCase().startsWith("q")) {
         console.log("Operation cancelled.");
       }
-      resolve2(result);
+      resolve3(result);
     });
   });
 }
@@ -7432,23 +7748,23 @@ ${title}`);
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     rl.question(`
 Select role archetype [1-${options.length}] (default: 1): `, (answer) => {
       rl.close();
       const trimmed = answer.trim();
       if (!trimmed) {
-        return resolve2(defaultId);
+        return resolve3(defaultId);
       }
       const num = parseInt(trimmed, 10);
       if (!isNaN(num) && num >= 1 && num <= options.length) {
-        return resolve2(options[num - 1].id);
+        return resolve3(options[num - 1].id);
       }
       const matched = options.find((o) => o.id.toLowerCase() === trimmed.toLowerCase() || o.label.toLowerCase().includes(trimmed.toLowerCase()));
       if (matched) {
-        return resolve2(matched.id);
+        return resolve3(matched.id);
       }
-      resolve2(defaultId);
+      resolve3(defaultId);
     });
   });
 }
@@ -8096,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) {
@@ -8114,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) {
@@ -8134,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)) {
@@ -8526,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,
@@ -8544,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}` };
 }
@@ -8607,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)) {
@@ -11524,7 +11840,7 @@ var require_compile = __commonJS(function(exports) {
     const schOrFunc = root.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve2.call(this, root, ref);
+    let _sch = resolve3.call(this, root, ref);
     if (_sch === undefined) {
       const schema2 = (_a = root.localRefs) === null || _a === undefined ? undefined : _a[ref];
       const { schemaId } = this.opts;
@@ -11551,7 +11867,7 @@ var require_compile = __commonJS(function(exports) {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve2(root, ref) {
+  function resolve3(root, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -12137,7 +12453,7 @@ var require_fast_uri = __commonJS(function(exports, module) {
     }
     return uri;
   }
-  function resolve2(baseURI, relativeURI, options) {
+  function resolve3(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
     const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
@@ -12422,7 +12738,7 @@ var require_fast_uri = __commonJS(function(exports, module) {
   var fastUri = {
     SCHEMES,
     normalize,
-    resolve: resolve2,
+    resolve: resolve3,
     resolveComponent,
     equal,
     serialize,
@@ -14939,7 +15255,7 @@ var require_ajv = __commonJS(function(exports, module) {
 });
 
 // src/schema.ts
-import { readFileSync as readFileSync18 } from "node:fs";
+import { existsSync as existsSync22, readFileSync as readFileSync18 } from "node:fs";
 import { join as join19 } from "node:path";
 function getValidator() {
   if (cachedValidate)
@@ -14950,8 +15266,22 @@ function getValidator() {
       return false;
     return !Number.isNaN(Date.parse(value));
   });
-  const schemaPath = join19(import.meta.dir, "..", "schema.json");
-  const schema2 = JSON.parse(readFileSync18(schemaPath, "utf8"));
+  const candidates = [
+    join19(import.meta.dir, "..", "schema.json"),
+    join19(import.meta.dir, "schema.json"),
+    join19(process.cwd(), "schema.json")
+  ];
+  let schemaContent = null;
+  for (const p of candidates) {
+    if (existsSync22(p)) {
+      schemaContent = readFileSync18(p, "utf8");
+      break;
+    }
+  }
+  if (!schemaContent) {
+    throw new Error(`Cannot locate schema.json in ${candidates.join(", ")}`);
+  }
+  const schema2 = JSON.parse(schemaContent);
   cachedValidate = ajv.compile(schema2);
   return cachedValidate;
 }
@@ -15057,13 +15387,13 @@ __export(exports_doctor, {
   printDoctorReport: () => printDoctorReport,
   runDoctor: () => runDoctor
 });
-import { existsSync as existsSync22, statSync as statSync8, readFileSync as readFileSync19 } from "node:fs";
+import { existsSync as existsSync23, statSync as statSync8, readFileSync as readFileSync19 } from "node:fs";
 import { join as join20 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 async function runDoctor(targetDir, options = {}) {
   const home = homedir5();
   const storagePath = options.global ? getGlobalMemoryDir() : findOrCreateProjectRoot(targetDir || process.cwd())?.memoryDir || join20(home, ".memory");
-  const isInitialized = existsSync22(storagePath);
+  const isInitialized = existsSync23(storagePath);
   let currentMdExists = false;
   let currentMdLines = 0;
   let totalEntries = 0;
@@ -15082,7 +15412,7 @@ async function runDoctor(targetDir, options = {}) {
   let brokenLinksCount = 0;
   if (isInitialized) {
     const currentPath = join20(storagePath, "CURRENT.md");
-    if (existsSync22(currentPath)) {
+    if (existsSync23(currentPath)) {
       currentMdExists = true;
       const content = readFileSync19(currentPath, "utf8");
       currentMdLines = content.split(`
@@ -15110,7 +15440,7 @@ async function runDoctor(targetDir, options = {}) {
   let auditCount = 0;
   let auditSize = 0;
   let lastEvent;
-  if (existsSync22(auditPath)) {
+  if (existsSync23(auditPath)) {
     auditExists = true;
     try {
       const stat = statSync8(auditPath);
@@ -15245,7 +15575,7 @@ var init_doctor = __esm(() => {
 });
 
 // src/retrieval/tree-index.ts
-import { existsSync as existsSync23, 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")
@@ -15355,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,
@@ -15364,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;
@@ -15382,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 = [];
@@ -15443,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 = {
@@ -15455,12 +15785,12 @@ 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) {
   const path = globalIndexFilePath(indexDir(memoryDir));
-  if (!existsSync23(path))
+  if (!existsSync24(path))
     return null;
   try {
     const data = JSON.parse(readFileSync20(path, "utf8"));
@@ -15569,7 +15899,7 @@ function searchTree(index, options) {
     }
   }
   results.sort((a, b) => b.score - a.score);
-  const paginated = paginateResults(results, options.page ?? 1, options.pageSize ?? 10);
+  const paginated = paginateResults(results, options.page ?? 1, options.pageSize ?? options.maxNodes ?? 10);
   return {
     nodes: paginated,
     memories: [],
@@ -15608,7 +15938,7 @@ __export(exports_vector, {
   saveIndex: () => saveIndex,
   termFrequencies: () => termFrequencies
 });
-import { existsSync as existsSync24, 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");
@@ -15658,13 +15988,13 @@ function rebuildIndex(store) {
   return index;
 }
 function saveIndex(index, memoryDir) {
-  if (!existsSync24(memoryDir))
-    mkdirSync13(memoryDir, { recursive: true });
-  writeFileSync11(indexFilePath(memoryDir), JSON.stringify(index), "utf8");
+  if (!existsSync25(memoryDir))
+    mkdirSync14(memoryDir, { recursive: true });
+  writeFileSync12(indexFilePath(memoryDir), JSON.stringify(index), "utf8");
 }
 function loadIndex(memoryDir) {
   const p = indexFilePath(memoryDir);
-  if (!existsSync24(p))
+  if (!existsSync25(p))
     return null;
   try {
     const parsed = JSON.parse(readFileSync21(p, "utf8"));
@@ -15739,7 +16069,7 @@ var init_vector = __esm(() => {
 });
 
 // src/pageindex/engine.ts
-import { existsSync as existsSync25, 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);
@@ -15818,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;
 }
@@ -15884,7 +16214,7 @@ function searchPageIndex(doc, options) {
 }
 function loadPageIndex(memoryDir, project, indexId) {
   const filePath = join23(memoryDir, "pageindex", project, `${indexId}.json`);
-  if (!existsSync25(filePath))
+  if (!existsSync26(filePath))
     return null;
   try {
     return JSON.parse(readFileSync22(filePath, "utf8"));
@@ -15894,13 +16224,13 @@ function loadPageIndex(memoryDir, project, indexId) {
 }
 function listPageIndexes(memoryDir, project) {
   const base = join23(memoryDir, "pageindex");
-  if (!existsSync25(base))
+  if (!existsSync26(base))
     return [];
   const results = [];
   const projects = project ? [project] : readdirSync9(base);
   for (const p of projects) {
     const pDir = join23(base, p);
-    if (!existsSync25(pDir))
+    if (!existsSync26(pDir))
       continue;
     for (const f of readdirSync9(pDir)) {
       if (f.endsWith(".json")) {
@@ -15914,7 +16244,7 @@ function listPageIndexes(memoryDir, project) {
 }
 function deletePageIndex(memoryDir, project, indexId) {
   const base = join23(memoryDir, "pageindex");
-  if (!existsSync25(base))
+  if (!existsSync26(base))
     return { deletedCount: 0 };
   let count = 0;
   if (!project && !indexId) {
@@ -15923,13 +16253,13 @@ function deletePageIndex(memoryDir, project, indexId) {
   }
   if (project && !indexId) {
     const pDir = join23(base, project);
-    if (existsSync25(pDir)) {
+    if (existsSync26(pDir)) {
       rmSync2(pDir, { recursive: true, force: true });
       count++;
     }
   } else if (project && indexId) {
     const file = join23(base, project, `${indexId}.json`);
-    if (existsSync25(file)) {
+    if (existsSync26(file)) {
       rmSync2(file, { force: true });
       count++;
     }
@@ -15942,13 +16272,13 @@ var init_engine2 = __esm(() => {
 });
 
 // src/retrieval/engine.ts
-import { existsSync as existsSync26 } from "node:fs";
+import { existsSync as existsSync27 } from "node:fs";
 import { join as join24 } from "node:path";
 
 class RetrievalEngine {
   static search(store, memoryDir, query, options = {}) {
     const mode = options.mode ?? "auto";
-    if (mode === "pageindex" || options.docPath && existsSync26(options.docPath)) {
+    if (mode === "pageindex" || options.docPath && existsSync27(options.docPath)) {
       try {
         const docs = listPageIndexes(memoryDir, options.project);
         if (docs.length > 0) {
@@ -15976,7 +16306,7 @@ class RetrievalEngine {
       } catch {}
     }
     const treeDir = join24(memoryDir, "tree");
-    const hasTree = existsSync26(treeDir);
+    const hasTree = existsSync27(treeDir);
     const allEntries = list(store);
     if (mode === "tree" || mode === "auto" && hasTree && allEntries.length >= 500) {
       try {
@@ -16014,7 +16344,7 @@ class RetrievalEngine {
       } catch {}
     }
     const vecPath = indexFilePath(memoryDir);
-    const hasVec = existsSync26(vecPath);
+    const hasVec = existsSync27(vecPath);
     if (mode === "hybrid" || mode === "auto" && hasVec && allEntries.length > 100) {
       try {
         const hybridResults = hybridSearch(store, memoryDir, query, {
@@ -16133,14 +16463,29 @@ __export(exports_ui, {
 });
 import { createServer } from "node:http";
 function startUiServer(opts) {
-  return new Promise((resolve2, reject2) => {
+  return new Promise((resolve3, reject2) => {
     let currentPort = opts.port ?? 2222;
     const server = createServer(async (req, res) => {
       const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
       const pathname = url.pathname;
-      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("X-Content-Type-Options", "nosniff");
+      res.setHeader("X-Frame-Options", "DENY");
+      res.setHeader("Referrer-Policy", "strict-origin-when-cross-origin");
+      res.setHeader("Content-Security-Policy", "default-src 'self' 'unsafe-inline' data: https://fonts.googleapis.com https://fonts.gstatic.com; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; font-src 'self' https://fonts.gstatic.com data:;");
+      const origin = req.headers.origin;
+      const isLocalOrigin = !origin || /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin) || origin === "null";
+      if (origin && isLocalOrigin) {
+        res.setHeader("Access-Control-Allow-Origin", origin);
+      } else if (!origin) {
+        res.setHeader("Access-Control-Allow-Origin", `http://localhost:${currentPort}`);
+      }
       res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
       res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      if (req.method === "POST" && !isLocalOrigin) {
+        res.writeHead(403, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Forbidden: Cross-Origin Request Blocked" }));
+        return;
+      }
       if (req.method === "OPTIONS") {
         res.writeHead(204);
         res.end();
@@ -16400,15 +16745,15 @@ function startUiServer(opts) {
     server.on("error", (err) => {
       if (err.code === "EADDRINUSE" && !opts.port) {
         currentPort++;
-        server.listen(currentPort);
+        server.listen(currentPort, "127.0.0.1");
       } else {
         reject2(err);
       }
     });
-    server.listen(currentPort, () => {
+    server.listen(currentPort, "127.0.0.1", () => {
       const addr = server.address();
       const actualPort = typeof addr === "object" && addr ? addr.port : currentPort;
-      resolve2({
+      resolve3({
         port: actualPort,
         close: () => server.close()
       });
@@ -16416,12 +16761,21 @@ function startUiServer(opts) {
   });
 }
 function parseJsonBody(req) {
-  return new Promise((resolve2, reject2) => {
+  return new Promise((resolve3, reject2) => {
     let data = "";
-    req.on("data", (chunk) => data += chunk);
+    let byteLength = 0;
+    req.on("data", (chunk) => {
+      byteLength += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
+      if (byteLength > MAX_BODY_SIZE) {
+        req.destroy();
+        reject2(new Error("Payload too large: request body exceeds 1MB limit"));
+        return;
+      }
+      data += chunk;
+    });
     req.on("end", () => {
       try {
-        resolve2(data ? JSON.parse(data) : {});
+        resolve3(data ? JSON.parse(data) : {});
       } catch (e) {
         reject2(e);
       }
@@ -16435,7 +16789,7 @@ function exportStandaloneHtml(store) {
   return EMBEDDED_HTML.replace("</head>", `${script}
 </head>`);
 }
-var EMBEDDED_HTML = `<!DOCTYPE html>
+var MAX_BODY_SIZE, EMBEDDED_HTML = `<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="UTF-8">
@@ -17434,6 +17788,7 @@ var init_ui = __esm(() => {
   init_retrieval2();
   init_schema();
   init_snapshot();
+  MAX_BODY_SIZE = 1024 * 1024;
 });
 
 // node_modules/zod/v4/core/core.js
@@ -24287,7 +24642,7 @@ class Protocol {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1000;
-        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+        await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -24299,7 +24654,7 @@ class Protocol {
   }
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve2, reject2) => {
+    return new Promise((resolve3, reject2) => {
       const earlyReject = (error2) => {
         reject2(error2);
       };
@@ -24377,7 +24732,7 @@ class Protocol {
           if (!parseResult.success) {
             reject2(parseResult.error);
           } else {
-            resolve2(parseResult.data);
+            resolve3(parseResult.data);
           }
         } catch (error2) {
           reject2(error2);
@@ -24568,12 +24923,12 @@ class Protocol {
         interval = task.pollInterval;
       }
     } catch {}
-    return new Promise((resolve2, reject2) => {
+    return new Promise((resolve3, reject2) => {
       if (signal.aborted) {
         reject2(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve2, interval);
+      const timeoutId = setTimeout(resolve3, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject2(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -25545,12 +25900,12 @@ class StdioServerTransport {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       const json2 = serializeMessage(message);
       if (this._stdout.write(json2)) {
-        resolve2();
+        resolve3();
       } else {
-        this._stdout.once("drain", resolve2);
+        this._stdout.once("drain", resolve3);
       }
     });
   }
@@ -25685,7 +26040,7 @@ var init_loops = __esm(() => {
 });
 
 // src/distill.ts
-import { existsSync as existsSync27, 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);
@@ -25707,7 +26062,7 @@ function distillSkills(store, workspaceRoot, options = {}) {
     const slug = slugifyId(topic.join("-") || "skill");
     const dir = join25(skillsDir, slug);
     const memberIds = cluster.map((e) => e.id);
-    if (existsSync27(dir)) {
+    if (existsSync28(dir)) {
       report.skippedExisting.push({ slug, members: memberIds });
       continue;
     }
@@ -25717,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 });
   }
@@ -25762,18 +26117,18 @@ var init_distill = __esm(() => {
 // src/verify.ts
 import { execFile } from "node:child_process";
 function runCommand(command, cwd, timeoutSec) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     execFile("/bin/sh", ["-c", command], { cwd, timeout: timeoutSec * 1000, killSignal: "SIGKILL", maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
       if (!err) {
-        resolve2({ ok: true, ran: true, exitCode: 0, stdout: String(stdout), stderr: String(stderr), message: "command exited 0" });
+        resolve3({ ok: true, ran: true, exitCode: 0, stdout: String(stdout), stderr: String(stderr), message: "command exited 0" });
         return;
       }
       const e = err;
       if (e.killed) {
-        resolve2({ ok: false, ran: true, timedOut: true, stdout: String(stdout), stderr: String(stderr), message: `timed out after ${timeoutSec}s` });
+        resolve3({ ok: false, ran: true, timedOut: true, stdout: String(stdout), stderr: String(stderr), message: `timed out after ${timeoutSec}s` });
         return;
       }
-      resolve2({
+      resolve3({
         ok: false,
         ran: true,
         exitCode: typeof e.code === "number" ? e.code : -1,
@@ -26058,14 +26413,14 @@ var init_schema2 = __esm(() => {
 });
 
 // src/settings/loader.ts
-import { existsSync as existsSync28, 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");
 }
 function loadSettings(memoryDir) {
   const filePath = getSettingsFilePath(memoryDir);
-  if (!existsSync28(filePath)) {
+  if (!existsSync29(filePath)) {
     return {
       version: 1,
       global: JSON.parse(JSON.stringify(DEFAULT_SETTINGS)),
@@ -26089,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;
@@ -26220,7 +26575,7 @@ async function runMcpServer() {
     }
     return { activeStore: store, activeMemoryDir: memoryDir, activeRoot: root };
   }
-  const server = new Server({ name: "musememory", version: "1.4.0" }, {
+  const server = new Server({ name: "musememory", version: "1.6.0" }, {
     capabilities: { tools: {}, logging: {} },
     instructions: `MUSE MEMORY PROTOCOL:
 You are equipped with Muse Memory, an autonomous persistent cognitive memory system.
@@ -26650,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",
@@ -26806,22 +27169,20 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const a = args ?? {};
+    const { activeStore, activeMemoryDir, activeRoot } = resolveStoreForRequest(a);
     try {
       switch (name) {
         case "memory_read": {
-          const { activeStore } = resolveStoreForRequest(a);
           const entry = get2(activeStore, String(a.id));
           if (!entry)
             return toolError(`no entry with id ${a.id}`);
           return toolResult(entry);
         }
         case "get_context": {
-          const { activeStore, activeMemoryDir } = resolveStoreForRequest(a);
           const queryStr = String(a.query ?? "");
           if (queryStr && activeMemoryDir) {
             try {
-              const { updateSessionHandoff: updateSessionHandoff2 } = (init_current(), __toCommonJS(exports_current));
-              updateSessionHandoff2(activeMemoryDir, {
+              updateSessionHandoff(activeMemoryDir, {
                 status: "IN-PROGRESS",
                 lastQuery: queryStr,
                 agent: a.agent ? String(a.agent) : process.env.AGENT_NAME || "AI Assistant",
@@ -26848,10 +27209,8 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
           });
         }
         case "memory_checkpoint": {
-          const { activeMemoryDir } = resolveStoreForRequest(a);
           try {
-            const { updateSessionHandoff: updateSessionHandoff2 } = (init_current(), __toCommonJS(exports_current));
-            const handoff = updateSessionHandoff2(activeMemoryDir, {
+            const handoff = updateSessionHandoff(activeMemoryDir, {
               status: a.status ? String(a.status).toUpperCase() : "IN-PROGRESS",
               task: a.task ? String(a.task) : undefined,
               agent: a.agent ? String(a.agent) : process.env.AGENT_NAME || "AI Agent",
@@ -26865,7 +27224,6 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
         case "memory_current":
         case "memory_get_constraints":
         case "memory_set_constraints": {
-          const { activeMemoryDir, activeRoot, activeStore } = resolveStoreForRequest(a);
           const action = a.action || (name === "memory_set_constraints" ? "append" : "get");
           if (action === "append" || a.constraint) {
             const text = String(a.constraint || a.text || "");
@@ -26881,7 +27239,6 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
         }
         case "memory_recall":
         case "search": {
-          const { activeStore, activeMemoryDir } = resolveStoreForRequest(a);
           const mode = a.hybrid === true ? "hybrid" : a.tree === true ? "tree" : "auto";
           const res = RetrievalEngine.search(activeStore, activeMemoryDir, String(a.query), {
             mode,
@@ -26902,7 +27259,6 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
         }
         case "propose":
         case "memory_capture": {
-          const { activeStore, activeRoot, activeMemoryDir } = resolveStoreForRequest(a);
           const projectName = a.project ? String(a.project) : basename(activeRoot) || "default";
           try {
             const entry = propose(activeStore, {
@@ -26920,8 +27276,7 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
             }
             if (activeMemoryDir) {
               try {
-                const { updateSessionHandoff: updateSessionHandoff2 } = (init_current(), __toCommonJS(exports_current));
-                updateSessionHandoff2(activeMemoryDir, {
+                updateSessionHandoff(activeMemoryDir, {
                   discoveries: [String(a.title || a.content || "")]
                 });
               } catch {}
@@ -26932,7 +27287,7 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
           }
         }
         case "memory_harvest": {
-          const created = harvestMemories(store, {
+          const created = harvestMemories(activeStore, {
             text: String(a.text),
             project: String(a.project),
             confirmed: a.confirmed === true
@@ -26943,11 +27298,11 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
           const transcript = String(a.transcript);
           const project = a.project ? String(a.project) : undefined;
           const isConfirmed = a.confirmed === true;
-          const res = importTranscript(store, transcript, { project, confirmed: isConfirmed });
+          const res = importTranscript(activeStore, transcript, { project, confirmed: isConfirmed });
           return toolResult(res);
         }
         case "memory_confirm": {
-          const entry = confirm(store, String(a.id));
+          const entry = confirm(activeStore, String(a.id));
           if (!entry)
             return toolError(`could not confirm ${a.id} (not found or invalid status transition)`);
           return toolResult(entry);
@@ -26957,26 +27312,26 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
           const newId = String(a.with ?? a.new_id ?? "");
           if (!newId)
             return toolError("memory_supersede requires 'with' or 'new_id' parameter");
-          const entry = supersede(store, oldId, newId);
+          const entry = supersede(activeStore, oldId, newId);
           if (!entry)
             return toolError(`could not supersede ${oldId} with ${newId} (missing entry or target not confirmed)`);
           return toolResult(entry);
         }
         case "memory_link": {
           const related = Array.isArray(a.related) ? a.related.map(String) : [];
-          const entry = link2(store, String(a.id), related);
+          const entry = link2(activeStore, String(a.id), related);
           if (!entry)
             return toolError(`could not link ${a.id} (missing id or related id)`);
           return toolResult(entry);
         }
         case "memory_mark_stale": {
-          const entry = markStale(store, String(a.id), a.reason ? String(a.reason) : undefined);
+          const entry = markStale(activeStore, String(a.id), a.reason ? String(a.reason) : undefined);
           if (!entry)
             return toolError(`no entry with id ${a.id}`);
           return toolResult(entry);
         }
         case "memory_reject": {
-          const entry = reject(store, String(a.id));
+          const entry = reject(activeStore, String(a.id));
           if (!entry)
             return toolError(`no entry with id ${a.id}`);
           return toolResult(entry);
@@ -26984,13 +27339,13 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
         case "memory_delete": {
           const id = String(a.id);
           const reason = a.reason ? String(a.reason) : undefined;
-          const ok = deleteEntry(store, id, reason, "mcp_agent");
+          const ok = deleteEntry(activeStore, id, reason, "mcp_agent");
           if (!ok)
             return toolError(`no entry found with id ${id}`);
           return toolResult({ success: true, deleted_id: id });
         }
         case "memory_audit": {
-          const trail = getAuditTrail(memoryDir, {
+          const trail = getAuditTrail(activeMemoryDir, {
             operation: a.operation ? String(a.operation) : undefined,
             entryId: a.entry_id ? String(a.entry_id) : undefined,
             limit: typeof a.limit === "number" ? a.limit : 50
@@ -26998,37 +27353,37 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
           return toolResult({ total: trail.length, entries: trail });
         }
         case "memory_export": {
-          const snapshot = exportSnapshot(store);
+          const snapshot = exportSnapshot(activeStore);
           return toolResult(snapshot);
         }
         case "memory_import": {
           const entries = a.entries ?? [];
-          const res = importSnapshot(store, { entries }, { overwrite: a.overwrite === true });
+          const res = importSnapshot(activeStore, { entries }, { overwrite: a.overwrite === true });
           return toolResult(res);
         }
         case "confirm_fix": {
-          const entry = get2(store, String(a.id));
+          const entry = get2(activeStore, String(a.id));
           if (!entry)
             return toolError(`no entry with id ${a.id}`);
           if (entry.status !== "disputed")
             return toolError(`entry ${a.id} is not disputed`);
-          const updated = confirm(store, entry.id);
+          const updated = confirm(activeStore, entry.id);
           if (!updated)
             return toolError(`no entry with id ${a.id}`);
           if (a.resolution) {
             updated.content = `${updated.content}
 
 Resolution: ${String(a.resolution)}`;
-            save(store, updated);
+            save(activeStore, updated);
           }
           return toolResult(updated);
         }
         case "record_session": {
-          const { entry, sessionId } = recordSessionStart(store, String(a.project), a.note ? String(a.note) : undefined);
+          const { entry, sessionId } = recordSessionStart(activeStore, String(a.project), a.note ? String(a.note) : undefined);
           return toolResult({ ...entry, sessionId });
         }
         case "memory_validate": {
-          const report = validateStore(store);
+          const report = validateStore(activeStore);
           return toolResult(report);
         }
         case "memory_core": {
@@ -27038,41 +27393,41 @@ Resolution: ${String(a.resolution)}`;
           }
           try {
             if (tier && a.set !== undefined) {
-              const tiers = setCore(memoryDir, tier, String(a.set));
+              const tiers = setCore(activeMemoryDir, tier, String(a.set));
               return toolResult({ tier, lines: tiers[tier] });
             }
             if (tier && a.remove === true) {
-              const tiers = removeCore(memoryDir, tier);
+              const tiers = removeCore(activeMemoryDir, tier);
               return toolResult({ tier, lines: tiers[tier] });
             }
             if (tier) {
-              return toolResult({ tier, lines: readCore(memoryDir)[tier] });
+              return toolResult({ tier, lines: readCore(activeMemoryDir)[tier] });
             }
-            return toolResult(readCore(memoryDir));
+            return toolResult(readCore(activeMemoryDir));
           } catch (err) {
             return toolError(err instanceof Error ? err.message : String(err));
           }
         }
         case "memory_consolidate": {
-          const report = consolidateScenes(store, {
+          const report = consolidateScenes(activeStore, {
             project: a.project ? String(a.project) : undefined,
             dryRun: a.dry_run === true
           });
           return toolResult(report);
         }
         case "memory_trace": {
-          const node = traceGraph(store, String(a.id), typeof a.depth === "number" ? a.depth : 5);
+          const node = traceGraph(activeStore, String(a.id), typeof a.depth === "number" ? a.depth : 5);
           if (!node)
             return toolError(`no entry with id ${a.id}`);
           return toolResult(node);
         }
         case "memory_loops": {
-          const report = collectLoops(store, root, memoryDir);
+          const report = collectLoops(activeStore, activeRoot, activeMemoryDir);
           return toolResult(report);
         }
         case "memory_distill": {
           try {
-            const report = distillSkills(store, root, {
+            const report = distillSkills(activeStore, activeRoot, {
               minCount: typeof a.min_count === "number" ? a.min_count : undefined,
               dryRun: a.dry_run === true
             });
@@ -27082,7 +27437,7 @@ Resolution: ${String(a.resolution)}`;
           }
         }
         case "memory_verify": {
-          const result = await verifyEntry(store, root, memoryDir, String(a.id), {
+          const result = await verifyEntry(activeStore, activeRoot, activeMemoryDir, String(a.id), {
             timeout: typeof a.timeout === "number" ? a.timeout : undefined
           });
           if (!result.ok)
@@ -27090,11 +27445,15 @@ Resolution: ${String(a.resolution)}`;
           return toolResult(result);
         }
         case "graph_status": {
-          const status = getGraphStatus(root);
+          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(root);
+          const detected = detectProviders(activeRoot);
           return toolResult(detected);
         }
         case "memory_detect_agents": {
@@ -27114,7 +27473,7 @@ Resolution: ${String(a.resolution)}`;
         }
         case "memory_migrate": {
           try {
-            const report = await runMigration(store, memoryDir, {
+            const report = await runMigration(activeStore, activeMemoryDir, {
               provider: a.provider ? String(a.provider) : undefined,
               all: Boolean(a.all),
               dryRun: Boolean(a.dry_run),
@@ -27128,7 +27487,7 @@ Resolution: ${String(a.resolution)}`;
         }
         case "memory_get_user_profile": {
           const isGlobal = a.global === true;
-          const dir = isGlobal ? getGlobalMemoryDir() : memoryDir;
+          const dir = isGlobal ? getGlobalMemoryDir() : activeMemoryDir;
           const query = a.query ? String(a.query) : undefined;
           const profile = getUserProfile(dir, { query });
           return toolResult({ profile: profile ?? "No USER.md profile configured.", exists: Boolean(profile) });
@@ -27136,7 +27495,7 @@ Resolution: ${String(a.resolution)}`;
         case "memory_set_user_profile": {
           try {
             const isGlobal = a.global === true;
-            const dir = isGlobal ? getGlobalMemoryDir() : memoryDir;
+            const dir = isGlobal ? getGlobalMemoryDir() : activeMemoryDir;
             setUserProfile(dir, String(a.content));
             return toolResult({ success: true, message: `Updated USER.md in ${dir}` });
           } catch (err) {
@@ -27155,9 +27514,9 @@ Resolution: ${String(a.resolution)}`;
           }
         }
         case "memory_tree_search": {
-          let index = loadTreeIndex(memoryDir);
+          let index = loadTreeIndex(activeMemoryDir);
           if (!index) {
-            index = buildTreeIndex(store, memoryDir);
+            index = buildTreeIndex(activeStore, activeMemoryDir);
           }
           const res = searchTree(index, {
             query: String(a.query),
@@ -27170,37 +27529,37 @@ Resolution: ${String(a.resolution)}`;
           return toolResult(res);
         }
         case "memory_wiki_get": {
-          const page = getWikiPage(memoryDir, String(a.slug), a.type ? String(a.type) : undefined);
+          const page = getWikiPage(activeMemoryDir, String(a.slug), a.type ? String(a.type) : undefined);
           if (!page)
             return toolError(`Wiki page '${a.slug}' not found.`);
           return toolResult(page);
         }
         case "memory_wiki_search": {
-          const pages = listWikiPages(memoryDir, {
+          const pages = listWikiPages(activeMemoryDir, {
             project: a.project ? String(a.project) : undefined,
             type: a.type ? String(a.type) : undefined
           });
           return toolResult({ pages, count: pages.length });
         }
         case "memory_wiki_compile": {
-          const res = compileWiki(store, memoryDir, {
+          const res = compileWiki(activeStore, activeMemoryDir, {
             project: a.project ? String(a.project) : undefined,
             dryRun: a.dry_run === true
           });
           return toolResult(res);
         }
         case "memory_entities_get": {
-          const ent = findEntity(memoryDir, String(a.id));
+          const ent = findEntity(activeMemoryDir, String(a.id));
           if (!ent)
             return toolError(`Entity '${a.id}' not found.`);
           if (a.include_related === true) {
-            const rel = findRelatedEntities(memoryDir, String(a.id));
+            const rel = findRelatedEntities(activeMemoryDir, String(a.id));
             return toolResult({ entity: ent, related: rel });
           }
           return toolResult(ent);
         }
         case "memory_entities_search": {
-          let entities = loadEntities(memoryDir);
+          let entities = loadEntities(activeMemoryDir);
           if (a.type)
             entities = entities.filter((e) => e.type === a.type);
           if (a.project)
@@ -27214,7 +27573,7 @@ Resolution: ${String(a.resolution)}`;
               title: a.title ? String(a.title) : undefined,
               maxDepth: typeof a.maxDepth === "number" ? a.maxDepth : undefined,
               dryRun: a.dryRun === true,
-              memoryDir
+              memoryDir: activeMemoryDir
             });
             return toolResult(doc2);
           } catch (err) {
@@ -27223,7 +27582,7 @@ Resolution: ${String(a.resolution)}`;
         }
         case "memory_pageindex_search": {
           const project = a.project ? String(a.project) : "default";
-          const doc2 = loadPageIndex(memoryDir, project, String(a.indexId));
+          const doc2 = loadPageIndex(activeMemoryDir, project, String(a.indexId));
           if (!doc2)
             return toolError(`PageIndex '${a.indexId}' not found for project '${project}'`);
           const res = searchPageIndex(doc2, {
@@ -27236,13 +27595,13 @@ Resolution: ${String(a.resolution)}`;
         }
         case "memory_pageindex_import": {
           const project = String(a.project);
-          const doc2 = loadPageIndex(memoryDir, project, String(a.indexId));
+          const doc2 = loadPageIndex(activeMemoryDir, project, String(a.indexId));
           if (!doc2)
             return toolError(`PageIndex '${a.indexId}' not found for project '${project}'`);
           const search = searchPageIndex(doc2, { query: String(a.query), maxNodes: 5 });
           const imported = [];
           for (const item of search.results) {
-            const entry = propose(store, {
+            const entry = propose(activeStore, {
               project,
               title: item.title,
               content: `${item.summary}
@@ -27256,20 +27615,20 @@ Path: ${item.path}`,
           return toolResult({ importedCount: imported.length, entries: imported });
         }
         case "memory_disconnect_pageindex": {
-          const res = deletePageIndex(memoryDir, a.project ? String(a.project) : undefined, a.indexId ? String(a.indexId) : undefined);
+          const res = deletePageIndex(activeMemoryDir, a.project ? String(a.project) : undefined, a.indexId ? String(a.indexId) : undefined);
           return toolResult({ success: true, deletedIndexes: res.deletedCount });
         }
         case "memory_settings_get": {
-          const settings2 = a.project ? getProjectSettings(memoryDir, String(a.project)) : getSettings(memoryDir);
+          const settings2 = a.project ? getProjectSettings(activeMemoryDir, String(a.project)) : getSettings(activeMemoryDir);
           return toolResult(settings2);
         }
         case "memory_settings_set": {
           try {
             if (a.project) {
-              const updated = setProjectSettings(memoryDir, String(a.project), a.settings);
+              const updated = setProjectSettings(activeMemoryDir, String(a.project), a.settings);
               return toolResult(updated);
             } else {
-              const updated = setSettings(memoryDir, a.settings);
+              const updated = setSettings(activeMemoryDir, a.settings);
               return toolResult(updated);
             }
           } catch (err) {
@@ -27286,9 +27645,9 @@ Path: ${item.path}`,
   const transport = new StdioServerTransport;
   await server.connect(transport);
   process.stdin.resume();
-  await new Promise((resolve2) => {
-    process.stdin.on("end", () => resolve2());
-    process.stdin.on("close", () => resolve2());
+  await new Promise((resolve3) => {
+    process.stdin.on("end", () => resolve3());
+    process.stdin.on("close", () => resolve3());
   });
 }
 function toolResult(content) {
@@ -27309,7 +27668,7 @@ var init_mcp = __esm(() => {
   init_root();
   init_store();
   init_retrieval();
-  init_current();
+  init_governor();
   init_consolidate();
   init_trace();
   init_loops();
@@ -27340,7 +27699,7 @@ __export(exports_daemon, {
   startHub: () => startHub
 });
 import { createServer as createServer2 } from "node:http";
-import { existsSync as existsSync29 } from "node:fs";
+import { existsSync as existsSync30 } from "node:fs";
 import { join as join27 } from "node:path";
 import { watch } from "node:fs";
 function startHub(port, memoryDir) {
@@ -27416,20 +27775,20 @@ data: ${JSON.stringify(event)}
       }, DEBOUNCE_MS);
     };
     try {
-      if (existsSync29(memoriesDir)) {
+      if (existsSync30(memoriesDir)) {
         watchers.push(watch(memoriesDir, () => armDebounced("memory.changed")));
       }
       const currentMd = join27(memoryDir, "CURRENT.md");
-      if (existsSync29(currentMd)) {
+      if (existsSync30(currentMd)) {
         watchers.push(watch(currentMd, () => armDebounced("constraints.changed")));
       }
     } catch {}
   }
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     server.listen(port, () => {
       const address = server.address();
       const actualPort = typeof address === "object" && address ? address.port : port;
-      resolve2({
+      resolve3({
         server,
         port: actualPort,
         url: `http://localhost:${actualPort}/events`,
@@ -27454,18 +27813,18 @@ var init_daemon = () => {};
 
 // src/cli/ecosystem.ts
 import { join as join28 } from "node:path";
-import { existsSync as existsSync30, 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");
-  if (existsSync30(agentsMdPath)) {
+  if (existsSync31(agentsMdPath)) {
     try {
       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");
@@ -27476,7 +27835,7 @@ ${MUSE_MEMORY_DIRECTIVE}
 
 ${MUSE_MEMORY_DIRECTIVE}
 `;
-    writeFileSync15(agentsMdPath, initialContent, "utf8");
+    writeFileSync16(agentsMdPath, initialContent, "utf8");
   }
 }
 async function handleInstallCommand({ positional, flags }) {
@@ -27484,15 +27843,15 @@ 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 (!existsSync30(currentPath)) {
-    writeFileSync15(currentPath, `# Active Project Constraints
+  if (!existsSync31(currentPath)) {
+    writeFileSync16(currentPath, `# Active Project Constraints
 `, "utf8");
   }
   const globalUserPath = userFilePath(globalDir);
-  if (!existsSync30(globalUserPath)) {
+  if (!existsSync31(globalUserPath)) {
     const { promptSingleSelect: promptSingleSelect2 } = await Promise.resolve().then(() => (init_prompt(), exports_prompt));
     const archetypeOptions = [
       { id: "developer", label: "Software Engineer / Developer", hint: "Code-first, direct, strict typing" },
@@ -27509,12 +27868,12 @@ async function handleInstallCommand({ positional, flags }) {
     ensureProjectAgentInstructions(targetDir);
   }
   const globalAgentsMd = join28(homedir6(), ".agents", "AGENTS.md");
-  if (existsSync30(globalAgentsMd)) {
+  if (existsSync31(globalAgentsMd)) {
     try {
       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 {}
   }
@@ -27543,10 +27902,10 @@ async function handleInstallCommand({ positional, flags }) {
 }
 async function promptOrNotifyGitHook(targetDir, autoInstall = false) {
   const gitDir = join28(targetDir, ".git");
-  if (!existsSync30(gitDir))
+  if (!existsSync31(gitDir))
     return false;
   const hookPath = join28(gitDir, "hooks", "pre-commit");
-  const isInstalled = existsSync30(hookPath) && readFileSync24(hookPath, "utf8").includes("memory harvest-auto");
+  const isInstalled = existsSync31(hookPath) && readFileSync24(hookPath, "utf8").includes("memory harvest-auto");
   if (isInstalled)
     return true;
   if (autoInstall) {
@@ -27590,7 +27949,7 @@ async function handleUninstallCommand({ positional, flags }) {
   }
   if (purge) {
     const ctx = requireRoot(flags);
-    if (ctx && existsSync30(ctx.memoryDir) && !dryRun) {
+    if (ctx && existsSync31(ctx.memoryDir) && !dryRun) {
       const { rmSync: rmSync3 } = await import("node:fs");
       rmSync3(ctx.memoryDir, { recursive: true, force: true });
       console.log(`  [PURGED] Memory directory removed: ${ctx.memoryDir}`);
@@ -27606,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 (!existsSync30(currentPath)) {
-    writeFileSync15(currentPath, `# Active Project Constraints
+  if (!existsSync31(currentPath)) {
+    writeFileSync16(currentPath, `# Active Project Constraints
 `, "utf8");
   }
   if (!isGlobal) {
@@ -27800,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}`);
@@ -27812,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));
@@ -27850,7 +28215,7 @@ var init_ecosystem = __esm(() => {
 });
 
 // src/agentcontract.ts
-import { existsSync as existsSync31 } from "node:fs";
+import { existsSync as existsSync32 } from "node:fs";
 import { join as join29 } from "node:path";
 function parseAgentMemoryContract(markdown) {
   if (!markdown || !markdown.startsWith("---"))
@@ -27883,7 +28248,7 @@ function parseAgentMemoryContract(markdown) {
 function resolveAgentFile(nameOrPath, workspaceRoot) {
   if (!nameOrPath)
     return null;
-  if (existsSync31(nameOrPath))
+  if (existsSync32(nameOrPath))
     return nameOrPath;
   const candidates = [
     join29(workspaceRoot, ".agents", `${nameOrPath}.md`),
@@ -27893,7 +28258,7 @@ function resolveAgentFile(nameOrPath, workspaceRoot) {
   if (home)
     candidates.push(join29(home, ".config", "opencode", "agents", `${nameOrPath}.md`));
   for (const c of candidates) {
-    if (existsSync31(c))
+    if (existsSync32(c))
       return c;
   }
   return null;
@@ -27903,7 +28268,7 @@ var init_agentcontract = __esm(() => {
 });
 
 // src/cli/retrieval.ts
-import { existsSync as existsSync32, readFileSync as readFileSync25 } from "node:fs";
+import { existsSync as existsSync33, readFileSync as readFileSync25 } from "node:fs";
 import { join as join30 } from "node:path";
 async function handleContextCommand({ positional, flags }) {
   let agentTypes;
@@ -28008,6 +28373,7 @@ async function handleSearchCommand({ positional, flags }) {
   const res = queryContext(ctx.store, positional[0], {
     limit,
     tokenBudget,
+    project: flags["project"],
     includeSuperseded: flags["include-superseded"] === "true",
     type: flags["type"],
     status: flags["status"],
@@ -28051,7 +28417,7 @@ async function handleHarvestCommand({ positional, flags }) {
   const project = flags["project"];
   if (!project)
     return usageError("harvest requires --project");
-  const rawText = existsSync32(target) ? readFileSync25(target, "utf8") : target;
+  const rawText = existsSync33(target) ? readFileSync25(target, "utf8") : target;
   const created = harvestMemories(ctx.store, {
     text: rawText,
     project,
@@ -28088,7 +28454,7 @@ async function handleSearchTranscriptCommand({ positional, flags }) {
   if (!query)
     return usageError("search-transcript requires <query> [file.jsonl]");
   const targetFile = filePath ? filePath.startsWith("/") ? filePath : join30(process.cwd(), filePath) : join30(process.cwd(), "transcript.jsonl");
-  if (!existsSync32(targetFile)) {
+  if (!existsSync33(targetFile)) {
     return fail(`error: transcript file not found: ${targetFile}`);
   }
   const windowSize = flags["window"] ? parseInt(flags["window"], 10) : 2;
@@ -28434,7 +28800,7 @@ function handleEntitiesCommand(parsed) {
   if (!ctx)
     return 1;
   const memoryDir = ctx.memoryDir;
-  const sub = parsed.positional[1] ?? "list";
+  const sub = parsed.positional[0] ?? "list";
   if (sub === "list" || sub === "ls") {
     const type2 = parsed.flags.type;
     const project = parsed.flags.project;
@@ -28455,7 +28821,7 @@ function handleEntitiesCommand(parsed) {
     return 0;
   }
   if (sub === "show" || sub === "get") {
-    const id = parsed.positional[2];
+    const id = parsed.positional[1];
     if (!id) {
       console.error("Error: please specify an entity ID or name (e.g. `memory entities show nextjs`)");
       return 2;
@@ -28469,7 +28835,7 @@ function handleEntitiesCommand(parsed) {
     return 0;
   }
   if (sub === "related") {
-    const id = parsed.positional[2];
+    const id = parsed.positional[1];
     if (!id) {
       console.error("Error: please specify an entity ID or name (e.g. `memory entities related nextjs`)");
       return 2;
@@ -28495,16 +28861,16 @@ 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)
     return 1;
   const memoryDir = ctx.memoryDir;
-  const sub = parsed.positional[1] ?? "get";
+  const sub = parsed.positional[0] ?? "get";
   const project = parsed.flags.project;
   if (sub === "get") {
-    const key = parsed.positional[2];
+    const key = parsed.positional[1];
     const settings2 = project ? getProjectSettings(memoryDir, project) : getSettings(memoryDir);
     if (key) {
       const parts = key.split(".");
@@ -28523,8 +28889,8 @@ function handleSettingsCommand(parsed) {
     return 0;
   }
   if (sub === "set") {
-    const key = parsed.positional[2];
-    const rawVal = parsed.positional[3];
+    const key = parsed.positional[1];
+    const rawVal = parsed.positional[2];
     if (!key || rawVal === undefined) {
       console.error("Error: please specify key and value (e.g. `memory settings set retrieval.defaultMode tree`)");
       return 2;
@@ -28577,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);
@@ -28585,7 +28951,7 @@ function handleSettingsCommand(parsed) {
     return 0;
   }
   if (sub === "import") {
-    const file = parsed.positional[2];
+    const file = parsed.positional[1];
     if (!file) {
       console.error("Error: please specify a JSON file to import (e.g. `memory settings import team-settings.json`)");
       return 2;
@@ -28614,14 +28980,14 @@ var init_nudge = __esm(() => {
 });
 
 // src/routines.ts
-import { readFileSync as readFileSync27, existsSync as existsSync33 } from "node:fs";
+import { readFileSync as readFileSync27, existsSync as existsSync34 } from "node:fs";
 import { join as join31 } from "node:path";
 function routinesPath(memoryDir) {
   return join31(memoryDir, "routines.yaml");
 }
 function loadRoutines(memoryDir) {
   const p = routinesPath(memoryDir);
-  if (!existsSync33(p))
+  if (!existsSync34(p))
     return { routines: {} };
   const doc2 = yaml.load(readFileSync27(p, "utf8"), { schema: yaml.JSON_SCHEMA }) ?? {};
   const routines = doc2.routines ?? {};
@@ -28661,7 +29027,7 @@ var init_routines = __esm(() => {
 });
 
 // src/cli/lifecycle.ts
-import { writeFileSync as writeFileSync17, readFileSync as readFileSync28, existsSync as existsSync34 } 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)
@@ -28810,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));
@@ -28824,7 +29190,7 @@ async function handleImportCommand({ positional, flags }) {
   const file = positional[0];
   if (!file)
     return usageError("import requires <file.json>");
-  if (!existsSync34(file))
+  if (!existsSync35(file))
     return fail(`error: file ${file} does not exist`);
   const raw = JSON.parse(readFileSync28(file, "utf8"));
   const res = importSnapshot(ctx.store, raw, { overwrite: flags["overwrite"] === "true" });
@@ -28975,7 +29341,7 @@ async function handleStaleCommand({ flags }) {
   const daysOverride = flags["days"] ? parseInt(flags["days"], 10) : null;
   const now = Date.now();
   const stale = list(ctx.store).filter((e) => {
-    if (e.status !== "active")
+    if (e.status !== "active" && e.status !== "confirmed")
       return false;
     const policy = stalePolicyDays(e.type);
     if (policy === null)
@@ -29365,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