eminiar 0.10.0 → 0.11.0

package/dist/cli.js

@@ -21270,6 +21270,14 @@ function findOnPath(bin) {
   }
   return void 0;
 }
+function requirePreamble(code) {
+  if (!/\brequire\s*\(/.test(code)) return void 0;
+  if (/\b(?:const|let|var|function)\s+require\b/.test(code) || /\bcreateRequire\b/.test(code)) {
+    return void 0;
+  }
+  return `${REQUIRE_PREAMBLE}
+`;
+}
 function preferredShell() {
   const sh = process.env.SHELL ?? "";
   if (/\/(zsh|bash)$/.test(sh) && existsSync5(sh)) return sh;
@@ -21290,13 +21298,14 @@ function availableLanguages() {
     return { id: l.id, bin };
   });
 }
-var require3, tsxPath, LANGUAGES;
+var require3, REQUIRE_PREAMBLE, tsxPath, LANGUAGES;
 var init_languages = __esm({
   "src/sandbox/languages.ts"() {
     "use strict";
     init_esm_shims();
     init_paths();
     require3 = createRequire2(import.meta.url);
+    REQUIRE_PREAMBLE = 'import { createRequire } from "node:module"; const require = createRequire(process.env.EMINIAR_PROJECT_ROOT ? process.env.EMINIAR_PROJECT_ROOT + "/package.json" : import.meta.url);';
     LANGUAGES = [
       {
         id: "shell",
@@ -21310,14 +21319,16 @@ var init_languages = __esm({
         aliases: ["js", "node", "mjs"],
         ext: ".mjs",
         detect: () => process.execPath,
-        argv: (bin, file3) => [bin, "--no-warnings", file3]
+        argv: (bin, file3) => [bin, "--no-warnings", file3],
+        preamble: requirePreamble
       },
       {
         id: "typescript",
         aliases: ["ts"],
         ext: ".ts",
         detect: () => process.execPath,
-        argv: (bin, file3) => [bin, "--no-warnings", tsxCli(), file3]
+        argv: (bin, file3) => [bin, "--no-warnings", tsxCli(), file3],
+        preamble: requirePreamble
       },
       {
         id: "python",
@@ -21524,6 +21535,10 @@ var init_terms = __esm({
 });
 
 // src/storage/sqlite/schema.ts
+function hasColumn(db, table, column) {
+  const cols = db.pragma(`table_info(${table})`);
+  return cols.some((c) => c.name === column);
+}
 function vecTableSql(dims) {
   return `CREATE VIRTUAL TABLE IF NOT EXISTS chunk_vec USING vec0(chunk_id INTEGER PRIMARY KEY, embedding float[${dims}])`;
 }
@@ -21866,7 +21881,6 @@ CREATE TABLE IF NOT EXISTS transcript_files (
   offset INTEGER NOT NULL DEFAULT 0,
   size INTEGER NOT NULL DEFAULT 0,
   mtime INTEGER NOT NULL DEFAULT 0,
-  head_hash TEXT,
   ingested_at INTEGER NOT NULL
 );
 
@@ -21894,6 +21908,16 @@ CREATE TABLE IF NOT EXISTS statusline_snapshots (
 CREATE INDEX IF NOT EXISTS statusline_snapshots_session_ts ON statusline_snapshots(session_id, ts);
 CREATE INDEX IF NOT EXISTS statusline_snapshots_ts ON statusline_snapshots(ts);
 `
+      },
+      {
+        // transcript_files.head_hash (fingerprint of the file head, so a rewrite with the same
+        // size is noticed) was first added to v5 after v5 had already run on real databases, so
+        // version-5 databases exist both with and without the column. Add it only when missing.
+        version: 6,
+        up(db) {
+          if (!hasColumn(db, "transcript_files", "head_hash"))
+            db.exec("ALTER TABLE transcript_files ADD COLUMN head_hash TEXT");
+        }
       }
     ];
   }
@@ -22013,7 +22037,8 @@ var init_adapter = __esm({
         if (pending2.length) {
           this.transaction(() => {
             for (const m of pending2) {
-              this.db.exec(m.sql);
+              if (m.sql) this.db.exec(m.sql);
+              m.up?.(this.db);
               this.metaSet("schema_version", String(m.version));
             }
           });
@@ -22232,18 +22257,42 @@ var init_adapter = __esm({
       }
       vecSearch(embedding, k, filters) {
         if (!this.vectors) return [];
-        const raw = this.db.prepare(
-          "SELECT chunk_id id, distance FROM chunk_vec WHERE embedding MATCH ? AND k = ? ORDER BY distance"
-        ).all(embedding, BigInt(filters ? k * 4 : k));
-        if (!filters || !raw.length) return raw.map((r) => ({ chunkId: r.id, distance: r.distance }));
         const { where, params } = filterSql(filters);
-        const allowed = new Set(
-          this.db.prepare(
-            `SELECT c.id FROM chunks c JOIN documents d ON d.id = c.document_id
-             WHERE c.id IN (${raw.map(() => "?").join(",")})${where}`
-          ).all(...raw.map((r) => r.id), ...params).map((r) => r.id)
-        );
-        return raw.filter((r) => allowed.has(r.id)).slice(0, k).map((r) => ({ chunkId: r.id, distance: r.distance }));
+        if (!where) return this.knn(embedding, k);
+        try {
+          return this.knn(
+            embedding,
+            k,
+            `AND chunk_id IN (SELECT c.id FROM chunks c JOIN documents d ON d.id = c.document_id WHERE 1=1${where})`,
+            params
+          );
+        } catch {
+          return this.vecSearchWidening(embedding, k, where, params);
+        }
+      }
+      knn(embedding, k, extra = "", params = []) {
+        return this.db.prepare(
+          `SELECT chunk_id id, distance FROM chunk_vec WHERE embedding MATCH ? AND k = ? ${extra} ORDER BY distance`
+        ).all(embedding, BigInt(k), ...params).map((r) => ({ chunkId: r.id, distance: r.distance }));
+      }
+      /** Fallback filtered KNN: fetch k*4, k*16, ... nearest until k pass the filter or all were seen. */
+      vecSearchWidening(embedding, k, where, params) {
+        const total = this.vecCount();
+        for (let fetch2 = k * 4; ; fetch2 *= 4) {
+          const raw = this.knn(embedding, Math.min(fetch2, total));
+          if (!raw.length) return [];
+          const allowed = /* @__PURE__ */ new Set();
+          for (let i = 0; i < raw.length; i += 400) {
+            const ids = raw.slice(i, i + 400).map((r) => r.chunkId);
+            for (const r of this.db.prepare(
+              `SELECT c.id FROM chunks c JOIN documents d ON d.id = c.document_id
+             WHERE c.id IN (${ids.map(() => "?").join(",")})${where}`
+            ).all(...ids, ...params))
+              allowed.add(r.id);
+          }
+          const hits = raw.filter((r) => allowed.has(r.chunkId)).slice(0, k);
+          if (hits.length >= k || fetch2 >= total) return hits;
+        }
       }
       unembeddedChunkIds(limit) {
         return this.db.prepare("SELECT id FROM chunks WHERE embedded = 0 ORDER BY id LIMIT ?").all(limit).map((r) => r.id);
@@ -22522,6 +22571,26 @@ var init_adapter = __esm({
         }
         return out;
       }
+      graphDependentFileCounts(paths2, kinds) {
+        const out = /* @__PURE__ */ new Map();
+        if (!paths2.length || !kinds.length) return out;
+        const kph = kinds.map(() => "?").join(",");
+        for (let i = 0; i < paths2.length; i += 400) {
+          const batch = paths2.slice(i, i + 400);
+          const pph = batch.map(() => "?").join(",");
+          for (const r of this.db.prepare(
+            `SELECT d.path p, COUNT(DISTINCT s.path) n
+             FROM graph_nodes d
+             JOIN graph_edges e ON e.dst = d.id AND e.kind IN (${kph})
+             JOIN graph_nodes s ON s.id = e.src
+            WHERE d.path IN (${pph}) AND s.path IS NOT NULL AND s.path <> d.path
+            GROUP BY d.path`
+          ).all(...kinds, ...batch)) {
+            out.set(r.p, r.n);
+          }
+        }
+        return out;
+      }
       edgesWhere(col, ids, kinds) {
         if (!ids.length) return [];
         const out = [];
@@ -23152,6 +23221,24 @@ var init_storage = __esm({
   }
 });
 
+// src/hooks/cursor.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join10 } from "path";
+function cursorDir() {
+  return process.env.CURSOR_CONFIG_DIR || join10(homedir3(), ".cursor");
+}
+var PENDING_TTL_MS;
+var init_cursor = __esm({
+  "src/hooks/cursor.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_context();
+    init_paths();
+    PENDING_TTL_MS = 10 * 6e4;
+  }
+});
+
 // src/install/shell.ts
 import { spawnSync } from "child_process";
 import { createInterface } from "readline";
@@ -23200,194 +23287,20 @@ var init_shell = __esm({
   }
 });
 
-// src/install/materialize.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync5, readdirSync as readdirSync3, readFileSync as readFileSync6, rmSync as rmSync2 } from "fs";
-import { join as join10 } from "path";
-function stableRoot() {
-  return join10(paths().plugin, "node_modules", "eminiar");
-}
-function stableVersion() {
-  try {
-    return JSON.parse(readFileSync6(join10(stableRoot(), "package.json"), "utf8")).version;
-  } catch {
-    return void 0;
-  }
-}
-function materialize(spec, force = false) {
-  const prefix = paths().plugin;
-  mkdirSync5(prefix, { recursive: true });
-  const root = stableRoot();
-  const here = pluginRoot();
-  if (!force && !spec && here === root) return { root, fromSpec: "self" };
-  if (!force && !spec && stableVersion() === version2() && existsSync7(join10(root, "dist", "server.js"))) {
-    log.ok(`stable copy already at v${version2()} (${root})`);
-    return { root, fromSpec: `pack:${here}` };
-  }
-  let target = spec;
-  if (!target) {
-    if (!existsSync7(join10(here, "dist", "server.js"))) {
-      throw new Error(`${here} has no dist/ \u2014 run \`npm run build\` first`);
-    }
-    const dest = paths().tmp;
-    mkdirSync5(dest, { recursive: true });
-    const pack = run(
-      npmCli(),
-      ["pack", "--ignore-scripts", "--pack-destination", dest, "--silent"],
-      { cwd: here }
-    );
-    if (!pack.ok) throw new Error(`npm pack failed: ${pack.stderr || pack.stdout}`);
-    const tarball = pack.stdout.trim().split("\n").pop();
-    target = join10(dest, tarball);
-  }
-  const install2 = run(
-    npmCli(),
-    [
-      "install",
-      "--prefix",
-      prefix,
-      "--omit=dev",
-      "--no-audit",
-      "--no-fund",
-      "--loglevel=error",
-      target
-    ],
-    {
-      env: { ...process.env, npm_config_update_notifier: "false" }
-    }
-  );
-  if (!install2.ok) throw new Error(`npm install failed: ${install2.stderr || install2.stdout}`);
-  if (!spec && target.endsWith(".tgz")) rmSync2(target, { force: true });
-  for (const must of [
-    "dist/server.js",
-    "dist/hook.js",
-    "bin/em-hook",
-    ".claude-plugin/plugin.json",
-    "hooks/hooks.json"
-  ]) {
-    if (!existsSync7(join10(root, must))) throw new Error(`stable copy is missing ${must}`);
-  }
-  log.ok(
-    `installed v${stableVersion()} into ${root} (${readdirSync3(join10(prefix, "node_modules")).length} packages)`
-  );
-  return { root, fromSpec: spec ?? `pack:${here}` };
-}
-function nativeCheck(node2, root) {
-  const script = `
-    const { createRequire } = require("node:module");
-    const req = createRequire(${JSON.stringify(join10(root, "package.json"))});
-    const out = [];
-    for (const m of ["better-sqlite3", "sqlite-vec", "web-tree-sitter", "@huggingface/transformers"]) {
-      try { const x = req(m); if (m === "better-sqlite3") { const db = new x(":memory:"); req("sqlite-vec").load(db); db.close(); } }
-      catch (e) { out.push(m + ": " + (e && e.message ? e.message.split("\\n")[0] : e)); }
-    }
-    process.stdout.write(JSON.stringify(out));
-  `;
-  const r = run(node2, ["-e", script], { cwd: root });
-  if (!r.ok) return [`native check could not run: ${r.stderr.trim().split("\n").pop()}`];
-  try {
-    return JSON.parse(r.stdout);
-  } catch {
-    return [`native check returned garbage: ${r.stdout.slice(0, 200)}`];
-  }
-}
-function rebuildNative(root) {
-  const r = run(
-    npmCli(),
-    ["rebuild", "better-sqlite3", "--prefix", paths().plugin, "--loglevel=error"],
-    { cwd: root }
-  );
-  return r.ok;
-}
-function downloadModel(node2, root, model2) {
-  const script = `
-    (async () => {
-      const tf = await import("@huggingface/transformers");
-      tf.env.cacheDir = ${JSON.stringify(paths().models)};
-      const p = await tf.pipeline("feature-extraction", ${JSON.stringify(model2)}, { dtype: "q8", device: "cpu" });
-      const r = await p(["warm up"], { pooling: "cls", normalize: true });
-      process.stdout.write(String(r.tolist()[0].length));
-    })().catch((e) => { process.stderr.write(String(e && e.message || e)); process.exit(1); });
-  `;
-  const r = run(node2, ["--input-type=module", "-e", script], { cwd: root });
-  return r.ok ? void 0 : r.stderr.trim().split("\n").pop();
-}
-var init_materialize = __esm({
-  "src/install/materialize.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_paths();
-    init_version();
-    init_shell();
-  }
-});
-
-// src/install/node-resolve.ts
-import { accessSync as accessSync3, constants as constants3, existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-import { join as join11 } from "path";
-function versionOf(bin) {
-  const r = run(bin, ["-p", "process.versions.node"]);
-  return r.ok ? r.stdout.trim() : void 0;
-}
-function nodeOk(version3) {
-  const [maj = 0, min = 0] = version3.split(".").map(Number);
-  return maj > 22 || maj === 22 && min >= 12;
-}
-function pinNode(explicit) {
-  const candidate = explicit ?? process.execPath;
-  accessSync3(candidate, constants3.X_OK);
-  const version3 = versionOf(candidate);
-  if (!version3) throw new Error(`${candidate} does not look like a node binary`);
-  if (!nodeOk(version3))
-    throw new Error(`node ${version3} at ${candidate} is too old; need >= 22.12`);
-  writeFileSync4(ensureDirs().nodePathFile, candidate);
-  return { path: candidate, version: version3 };
-}
-function pinnedNode() {
-  try {
-    const path3 = readFileSync7(ensureDirs().nodePathFile, "utf8").trim();
-    const version3 = versionOf(path3);
-    return version3 ? { path: path3, version: version3 } : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function pinRoot(root) {
-  if (!existsSync8(join11(root, "dist", "server.js")))
-    throw new Error(`${root} has no dist/server.js; cannot pin it as the stable root`);
-  writeFileSync4(ensureDirs().rootPathFile, root);
-  return root;
-}
-function pinnedRoot() {
-  try {
-    const root = readFileSync7(ensureDirs().rootPathFile, "utf8").trim();
-    return root && existsSync8(join11(root, "dist", "server.js")) ? root : void 0;
-  } catch {
-    return void 0;
-  }
-}
-var init_node_resolve = __esm({
-  "src/install/node-resolve.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_paths();
-    init_shell();
-  }
-});
-
 // src/install/register.ts
 import { createHash as createHash2 } from "crypto";
-import { cpSync, existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync4, readFileSync as readFileSync8, rmSync as rmSync3 } from "fs";
-import { join as join12 } from "path";
+import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync6, readdirSync as readdirSync3, readFileSync as readFileSync7, rmSync as rmSync3 } from "fs";
+import { join as join11 } from "path";
 function fileHash(file3) {
   try {
-    return createHash2("sha1").update(readFileSync8(file3)).digest("hex");
+    return createHash2("sha1").update(readFileSync7(file3)).digest("hex");
   } catch {
     return void 0;
   }
 }
 function probeServer(root) {
-  const bin = join12(root, "bin", "em-server");
-  if (!existsSync9(bin)) return "bin/em-server is missing";
+  const bin = join11(root, "bin", "em-server");
+  if (!existsSync8(bin)) return "bin/em-server is missing";
   const r = run(bin, ["--probe"], { timeoutMs: 2e4 });
   if (r.ok && / ok /.test(r.stdout)) return void 0;
   const lines = (r.stderr || r.stdout).trim().split("\n").filter(Boolean);
@@ -23397,11 +23310,11 @@ function probeServer(root) {
 function pluginCacheStale(stable) {
   const cache3 = pluginInstallPath("eminiar@eminiar");
   if (!cache3 || cache3 === stable) return void 0;
-  if (!existsSync9(cache3)) return `${cache3} is missing`;
+  if (!existsSync8(cache3)) return `${cache3} is missing`;
   for (const rel of CACHE_FINGERPRINT) {
-    if (fileHash(join12(cache3, rel)) !== fileHash(join12(stable, rel))) return `${rel} differs`;
+    if (fileHash(join11(cache3, rel)) !== fileHash(join11(stable, rel))) return `${rel} differs`;
   }
-  if (existsSync9(join12(cache3, ".mcp.json")) && !existsSync9(join12(stable, ".mcp.json")))
+  if (existsSync8(join11(cache3, ".mcp.json")) && !existsSync8(join11(stable, ".mcp.json")))
     return ".mcp.json is present in the cache but not in the stable copy";
   const probe3 = probeServer(cache3);
   if (probe3) return `cached copy ${probe3}`;
@@ -23458,7 +23371,7 @@ function isOurs(cmd2, stable) {
 function registerSettings(stable) {
   const settings = readJson2(settingsPath());
   const hooks = settings.hooks ?? {};
-  const hookCmd = `"${join12(stable, "bin", "em-hook")}"`;
+  const hookCmd = `"${join11(stable, "bin", "em-hook")}"`;
   for (const ev2 of HOOK_EVENTS) {
     const list2 = hooks[ev2] ?? [];
     const filtered = list2.filter(
@@ -23479,17 +23392,17 @@ function registerSettings(stable) {
   const servers = cj.mcpServers ?? {};
   servers.eminiar = {
     type: "stdio",
-    command: join12(stable, "bin", "em-server"),
+    command: join11(stable, "bin", "em-server"),
     args: [],
     env: { EMINIAR_PLUGIN_ROOT: stable }
   };
   cj.mcpServers = servers;
   writeJsonWithBackup(claudeJsonPath(), cj);
   const skills = [];
-  const skillsDir = join12(settingsPath(), "..", "skills");
+  const skillsDir = join11(settingsPath(), "..", "skills");
   mkdirSync6(skillsDir, { recursive: true });
-  for (const name of readdirSync4(join12(stable, "skills"))) {
-    cpSync(join12(stable, "skills", name), join12(skillsDir, name), { recursive: true });
+  for (const name of readdirSync3(join11(stable, "skills"))) {
+    cpSync(join11(stable, "skills", name), join11(skillsDir, name), { recursive: true });
     skills.push(name);
   }
   return { hookEvents: HOOK_EVENTS, mcpServer: true, skills };
@@ -23520,8 +23433,8 @@ function unregisterSettings(stable, wrote) {
     }
   }
   for (const name of wrote.skills ?? []) {
-    const dir = join12(settingsPath(), "..", "skills", name);
-    if (existsSync9(dir)) rmSync3(dir, { recursive: true, force: true });
+    const dir = join11(settingsPath(), "..", "skills", name);
+    if (existsSync8(dir)) rmSync3(dir, { recursive: true, force: true });
   }
 }
 function setStatusline(stable) {
@@ -23535,7 +23448,7 @@ function setStatusline(stable) {
   }
   settings.statusLine = {
     type: "command",
-    command: `"${join12(stable, "bin", "eminiar")}" statusline`
+    command: `"${join11(stable, "bin", "eminiar")}" statusline`
   };
   writeJsonWithBackup(settingsPath(), settings);
   return true;
@@ -23577,14 +23490,304 @@ var init_register = __esm({
   }
 });
 
+// src/install/cursor.ts
+import { cpSync as cpSync2, existsSync as existsSync9, mkdirSync as mkdirSync7, readdirSync as readdirSync4, readFileSync as readFileSync8, rmSync as rmSync4 } from "fs";
+import { join as join12 } from "path";
+function cursorPresent() {
+  return existsSync9(cursorDir()) || existsSync9("/Applications/Cursor.app") || !!findOnPath("cursor") || !!findOnPath("cursor-agent");
+}
+function cursorHookCommand(stable) {
+  return `"${join12(stable, "bin", "em-hook")}" --client cursor`;
+}
+function registerCursor(stable) {
+  const cfg = readJson2(cursorHooksPath());
+  if (typeof cfg.version !== "number") cfg.version = 1;
+  const hooks = cfg.hooks ?? {};
+  const command = cursorHookCommand(stable);
+  for (const ev2 of CURSOR_HOOK_EVENTS) {
+    const list2 = (Array.isArray(hooks[ev2]) ? hooks[ev2] : []).filter(
+      (h) => !isOurs(h.command, stable)
+    );
+    const entry = { command, timeout: TIMEOUTS[ev2] ?? 5 };
+    if (ev2 === "preToolUse") entry.matcher = CURSOR_PRE_TOOL_MATCHER;
+    list2.push(entry);
+    hooks[ev2] = list2;
+  }
+  cfg.hooks = hooks;
+  writeJsonWithBackup(cursorHooksPath(), cfg);
+  const mcp = readJson2(cursorMcpPath());
+  const servers = mcp.mcpServers ?? {};
+  servers.eminiar = {
+    command: join12(stable, "bin", "em-server"),
+    args: [],
+    env: { EMINIAR_PLUGIN_ROOT: stable }
+  };
+  mcp.mcpServers = servers;
+  writeJsonWithBackup(cursorMcpPath(), mcp);
+  const skills = [];
+  const src = join12(stable, "skills");
+  if (existsSync9(src)) {
+    mkdirSync7(cursorSkillsDir(), { recursive: true });
+    for (const name of readdirSync4(src)) {
+      cpSync2(join12(src, name), join12(cursorSkillsDir(), name), { recursive: true });
+      skills.push(name);
+    }
+  }
+  return { hookEvents: [...CURSOR_HOOK_EVENTS], mcpServer: true, skills };
+}
+function unregisterCursor(stable, wrote) {
+  if (!wrote) return;
+  if (wrote.hookEvents.length && existsSync9(cursorHooksPath())) {
+    const cfg = readJson2(cursorHooksPath());
+    const hooks = cfg.hooks ?? {};
+    for (const ev2 of wrote.hookEvents) {
+      if (!Array.isArray(hooks[ev2])) continue;
+      const kept = hooks[ev2].filter((h) => !isOurs(h.command, stable));
+      if (kept.length) hooks[ev2] = kept;
+      else delete hooks[ev2];
+    }
+    cfg.hooks = hooks;
+    writeJsonWithBackup(cursorHooksPath(), cfg);
+  }
+  if (wrote.mcpServer && existsSync9(cursorMcpPath())) {
+    const mcp = readJson2(cursorMcpPath());
+    const servers = mcp.mcpServers;
+    if (servers?.eminiar && isOurs(servers.eminiar.command, stable)) {
+      delete servers.eminiar;
+      writeJsonWithBackup(cursorMcpPath(), mcp);
+    }
+  }
+  for (const name of wrote.skills) {
+    const dir = join12(cursorSkillsDir(), name);
+    if (existsSync9(dir)) rmSync4(dir, { recursive: true, force: true });
+  }
+}
+function cursorStatus() {
+  const read2 = (f) => existsSync9(f) ? readFileSync8(f, "utf8") : "";
+  const hooksRaw = read2(cursorHooksPath());
+  let events = [];
+  try {
+    const cfg = hooksRaw ? JSON.parse(hooksRaw) : {};
+    const hooks = cfg.hooks ?? {};
+    events = Object.keys(hooks).filter(
+      (ev2) => Array.isArray(hooks[ev2]) && hooks[ev2].some(
+        (h) => typeof h.command === "string" && h.command.includes("em-hook")
+      )
+    );
+  } catch {
+  }
+  return { hooks: events.length > 0, mcp: read2(cursorMcpPath()).includes("em-server"), events };
+}
+var cursorHooksPath, cursorMcpPath, cursorSkillsDir, CURSOR_HOOK_EVENTS, CURSOR_PRE_TOOL_MATCHER, TIMEOUTS;
+var init_cursor2 = __esm({
+  "src/install/cursor.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_cursor();
+    init_languages();
+    init_claude_config();
+    init_register();
+    cursorHooksPath = () => join12(cursorDir(), "hooks.json");
+    cursorMcpPath = () => join12(cursorDir(), "mcp.json");
+    cursorSkillsDir = () => join12(cursorDir(), "skills");
+    CURSOR_HOOK_EVENTS = [
+      "sessionStart",
+      "beforeSubmitPrompt",
+      "preToolUse",
+      "postToolUse",
+      "postToolUseFailure",
+      "subagentStop",
+      "preCompact",
+      "afterAgentResponse",
+      "sessionEnd"
+    ];
+    CURSOR_PRE_TOOL_MATCHER = "Shell|Read|Write|Edit|Grep|Glob|WebFetch|WebSearch|Task";
+    TIMEOUTS = { sessionStart: 10, preCompact: 15, postToolUse: 10 };
+  }
+});
+
+// src/install/materialize.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, readdirSync as readdirSync5, readFileSync as readFileSync9, rmSync as rmSync5 } from "fs";
+import { join as join13 } from "path";
+function stableRoot() {
+  return join13(paths().plugin, "node_modules", "eminiar");
+}
+function stableVersion() {
+  try {
+    return JSON.parse(readFileSync9(join13(stableRoot(), "package.json"), "utf8")).version;
+  } catch {
+    return void 0;
+  }
+}
+function materialize(spec, force = false) {
+  const prefix = paths().plugin;
+  mkdirSync8(prefix, { recursive: true });
+  const root = stableRoot();
+  const here = pluginRoot();
+  if (!force && !spec && here === root) return { root, fromSpec: "self" };
+  if (!force && !spec && stableVersion() === version2() && existsSync10(join13(root, "dist", "server.js"))) {
+    log.ok(`stable copy already at v${version2()} (${root})`);
+    return { root, fromSpec: `pack:${here}` };
+  }
+  let target = spec;
+  if (!target) {
+    if (!existsSync10(join13(here, "dist", "server.js"))) {
+      throw new Error(`${here} has no dist/ \u2014 run \`npm run build\` first`);
+    }
+    const dest = paths().tmp;
+    mkdirSync8(dest, { recursive: true });
+    const pack = run(
+      npmCli(),
+      ["pack", "--ignore-scripts", "--pack-destination", dest, "--silent"],
+      { cwd: here }
+    );
+    if (!pack.ok) throw new Error(`npm pack failed: ${pack.stderr || pack.stdout}`);
+    const tarball = pack.stdout.trim().split("\n").pop();
+    target = join13(dest, tarball);
+  }
+  const install2 = run(
+    npmCli(),
+    [
+      "install",
+      "--prefix",
+      prefix,
+      "--omit=dev",
+      "--no-audit",
+      "--no-fund",
+      "--loglevel=error",
+      target
+    ],
+    {
+      env: { ...process.env, npm_config_update_notifier: "false" }
+    }
+  );
+  if (!install2.ok) throw new Error(`npm install failed: ${install2.stderr || install2.stdout}`);
+  if (!spec && target.endsWith(".tgz")) rmSync5(target, { force: true });
+  for (const must of [
+    "dist/server.js",
+    "dist/hook.js",
+    "bin/em-hook",
+    ".claude-plugin/plugin.json",
+    "hooks/hooks.json"
+  ]) {
+    if (!existsSync10(join13(root, must))) throw new Error(`stable copy is missing ${must}`);
+  }
+  log.ok(
+    `installed v${stableVersion()} into ${root} (${readdirSync5(join13(prefix, "node_modules")).length} packages)`
+  );
+  return { root, fromSpec: spec ?? `pack:${here}` };
+}
+function nativeCheck(node2, root) {
+  const script = `
+    const { createRequire } = require("node:module");
+    const req = createRequire(${JSON.stringify(join13(root, "package.json"))});
+    const out = [];
+    for (const m of ["better-sqlite3", "sqlite-vec", "web-tree-sitter", "@huggingface/transformers"]) {
+      try { const x = req(m); if (m === "better-sqlite3") { const db = new x(":memory:"); req("sqlite-vec").load(db); db.close(); } }
+      catch (e) { out.push(m + ": " + (e && e.message ? e.message.split("\\n")[0] : e)); }
+    }
+    process.stdout.write(JSON.stringify(out));
+  `;
+  const r = run(node2, ["-e", script], { cwd: root });
+  if (!r.ok) return [`native check could not run: ${r.stderr.trim().split("\n").pop()}`];
+  try {
+    return JSON.parse(r.stdout);
+  } catch {
+    return [`native check returned garbage: ${r.stdout.slice(0, 200)}`];
+  }
+}
+function rebuildNative(root) {
+  const r = run(
+    npmCli(),
+    ["rebuild", "better-sqlite3", "--prefix", paths().plugin, "--loglevel=error"],
+    { cwd: root }
+  );
+  return r.ok;
+}
+function downloadModel(node2, root, model2) {
+  const script = `
+    (async () => {
+      const tf = await import("@huggingface/transformers");
+      tf.env.cacheDir = ${JSON.stringify(paths().models)};
+      const p = await tf.pipeline("feature-extraction", ${JSON.stringify(model2)}, { dtype: "q8", device: "cpu" });
+      const r = await p(["warm up"], { pooling: "cls", normalize: true });
+      process.stdout.write(String(r.tolist()[0].length));
+    })().catch((e) => { process.stderr.write(String(e && e.message || e)); process.exit(1); });
+  `;
+  const r = run(node2, ["--input-type=module", "-e", script], { cwd: root });
+  return r.ok ? void 0 : r.stderr.trim().split("\n").pop();
+}
+var init_materialize = __esm({
+  "src/install/materialize.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+    init_version();
+    init_shell();
+  }
+});
+
+// src/install/node-resolve.ts
+import { accessSync as accessSync3, constants as constants3, existsSync as existsSync11, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
+import { join as join14 } from "path";
+function versionOf(bin) {
+  const r = run(bin, ["-p", "process.versions.node"]);
+  return r.ok ? r.stdout.trim() : void 0;
+}
+function nodeOk(version3) {
+  const [maj = 0, min = 0] = version3.split(".").map(Number);
+  return maj > 22 || maj === 22 && min >= 12;
+}
+function pinNode(explicit) {
+  const candidate = explicit ?? process.execPath;
+  accessSync3(candidate, constants3.X_OK);
+  const version3 = versionOf(candidate);
+  if (!version3) throw new Error(`${candidate} does not look like a node binary`);
+  if (!nodeOk(version3))
+    throw new Error(`node ${version3} at ${candidate} is too old; need >= 22.12`);
+  writeFileSync5(ensureDirs().nodePathFile, candidate);
+  return { path: candidate, version: version3 };
+}
+function pinnedNode() {
+  try {
+    const path3 = readFileSync10(ensureDirs().nodePathFile, "utf8").trim();
+    const version3 = versionOf(path3);
+    return version3 ? { path: path3, version: version3 } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function pinRoot(root) {
+  if (!existsSync11(join14(root, "dist", "server.js")))
+    throw new Error(`${root} has no dist/server.js; cannot pin it as the stable root`);
+  writeFileSync5(ensureDirs().rootPathFile, root);
+  return root;
+}
+function pinnedRoot() {
+  try {
+    const root = readFileSync10(ensureDirs().rootPathFile, "utf8").trim();
+    return root && existsSync11(join14(root, "dist", "server.js")) ? root : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var init_node_resolve = __esm({
+  "src/install/node-resolve.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+    init_shell();
+  }
+});
+
 // src/install/doctor.ts
 var doctor_exports = {};
 __export(doctor_exports, {
   fullDoctor: () => fullDoctor
 });
 import { spawn } from "child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
+import { join as join15 } from "path";
 function mcpHandshake(bin, ms = 15e3) {
   return new Promise((resolve9) => {
     const child = spawn(bin, [], { stdio: ["pipe", "pipe", "pipe"] });
@@ -23619,8 +23822,8 @@ function mcpHandshake(bin, ms = 15e3) {
 async function fullDoctor(opts = {}) {
   const rec = readInstallRecord();
   const stable = rec?.stableRoot ?? stableRoot();
-  const hasStable = existsSync10(join13(stable, "dist", "server.js"));
-  const bins = hasStable ? stable : join13(process.argv[1] ?? "", "..", "..");
+  const hasStable = existsSync12(join15(stable, "dist", "server.js"));
+  const bins = hasStable ? stable : join15(process.argv[1] ?? "", "..", "..");
   const fixed = [];
   if (opts.fix && hasStable) {
     try {
@@ -23645,7 +23848,7 @@ async function fullDoctor(opts = {}) {
   checks.push({
     name: "install",
     ok: !!rec,
-    detail: rec ? `v${rec.version} via ${rec.method} at ${rec.installedAt.slice(0, 10)} (${rec.stableRoot})` : "not installed (run `npx eminiar install`)"
+    detail: rec ? `v${rec.version} via ${rec.method === "none" ? "cursor" : rec.method}${rec.wrote.cursor && rec.method !== "none" ? " + cursor" : ""} at ${rec.installedAt.slice(0, 10)} (${rec.stableRoot})` : "not installed (run `npx eminiar install`)"
   });
   const pinned = pinnedNode();
   checks.push({
@@ -23682,14 +23885,29 @@ async function fullDoctor(opts = {}) {
         detail: `${lines.join(" \xB7 ")}${drift}${liveOk ? "" : " \u2014 run `eminiar doctor --fix`, then `eminiar upgrade` if it still fails"}`
       });
     }
-  } else {
-    const s = existsSync10(join13(process.env.HOME ?? "", ".claude", "settings.json")) ? readFileSync9(join13(process.env.HOME ?? "", ".claude", "settings.json"), "utf8") : "";
+  } else if (rec.method === "settings") {
+    const s = existsSync12(join15(process.env.HOME ?? "", ".claude", "settings.json")) ? readFileSync11(join15(process.env.HOME ?? "", ".claude", "settings.json"), "utf8") : "";
     checks.push({
       name: "hooks in settings.json",
       ok: s.includes("em-hook"),
       detail: s.includes("em-hook") ? "present" : "missing"
     });
   }
+  if (rec?.wrote.cursor || cursorPresent()) {
+    const cs = cursorStatus();
+    const registered = !!rec?.wrote.cursor;
+    checks.push({
+      name: "Cursor",
+      ok: registered ? cs.hooks && cs.mcp : true,
+      detail: registered ? `${cs.hooks ? `hooks on ${cs.events.length} events` : "hooks missing from ~/.cursor/hooks.json"} \xB7 ${cs.mcp ? "MCP server in ~/.cursor/mcp.json" : "MCP server missing from ~/.cursor/mcp.json"}${cs.hooks && cs.mcp ? "" : " \u2014 run `npx eminiar install --cursor`"}` : cs.hooks || cs.mcp ? "partly configured by hand; `npx eminiar install --cursor` completes and tracks it" : "installed but not registered; `npx eminiar install --cursor` adds hooks, MCP server and skills"
+    });
+    if (registered && rec?.method === "settings")
+      checks.push({
+        name: "Cursor third-party import",
+        ok: false,
+        detail: "Cursor also runs the Claude Code hooks in ~/.claude/settings.json (Settings \u2192 Agents \u2192 Third-Party Imports, on by default), so each event fires twice there; turn that setting off or reinstall Claude Code with `--method plugin`"
+      });
+  }
   const failed = needsAuthEntry();
   if (failed && opts.fix && clearNeedsAuthEntry()) fixed.push("cached launch failure cleared");
   const stillFailed = needsAuthEntry();
@@ -23700,8 +23918,8 @@ async function fullDoctor(opts = {}) {
   });
   if (opts.fix)
     checks.push({ name: "fix", ok: true, detail: fixed.join(", ") || "nothing to fix" });
-  const hookBin = join13(bins, "bin", "em-hook");
-  if (existsSync10(hookBin)) {
+  const hookBin = join15(bins, "bin", "em-hook");
+  if (existsSync12(hookBin)) {
     const r = run(hookBin, ["--selftest"], { env: { ...process.env } });
     checks.push({
       name: "hook self-test",
@@ -23709,8 +23927,8 @@ async function fullDoctor(opts = {}) {
       detail: r.ok ? r.stdout.trim() : r.stderr.trim().slice(-200) || "failed"
     });
   }
-  const serverBin = join13(bins, "bin", "em-server");
-  if (existsSync10(serverBin)) {
+  const serverBin = join15(bins, "bin", "em-server");
+  if (existsSync12(serverBin)) {
     const reply = await mcpHandshake(serverBin);
     checks.push({ name: "MCP handshake", ok: /^eminiar v|^ok$/.test(reply), detail: reply });
   }
@@ -23722,10 +23940,10 @@ async function fullDoctor(opts = {}) {
       ok: true,
       detail: `${ctx.root} \xB7 ${db.countDocuments()} docs \xB7 ${db.memoryCount()} memories \xB7 graph ${db.graphCounts().nodes} nodes`
     });
-    const cfgFile = join13(ctx.root, "eminiar.config.json");
-    if (existsSync10(cfgFile)) {
+    const cfgFile = join15(ctx.root, "eminiar.config.json");
+    if (existsSync12(cfgFile)) {
       try {
-        const parsed = ConfigSchema.safeParse(JSON.parse(readFileSync9(cfgFile, "utf8")));
+        const parsed = ConfigSchema.safeParse(JSON.parse(readFileSync11(cfgFile, "utf8")));
         checks.push({
           name: "eminiar.config.json",
           ok: parsed.success,
@@ -23748,9 +23966,9 @@ async function fullDoctor(opts = {}) {
       ok: true,
       detail: live2.length ? `running for this project (pid ${live2.join(", ")})` : "none running for this project right now; enforce routing annotates instead of denying until one connects"
     });
-    const projectMcp = join13(ctx.root, ".mcp.json");
-    if (existsSync10(projectMcp)) {
-      const raw = readFileSync9(projectMcp, "utf8");
+    const projectMcp = join15(ctx.root, ".mcp.json");
+    if (existsSync12(projectMcp)) {
+      const raw = readFileSync11(projectMcp, "utf8");
       const bad = raw.includes(`\${CLAUDE_PLUGIN_ROOT}`) && raw.includes("em-server");
       checks.push({
         name: "project .mcp.json",
@@ -23780,6 +23998,7 @@ var init_doctor2 = __esm({
     init_server_alive();
     init_storage();
     init_claude_config();
+    init_cursor2();
     init_materialize();
     init_node_resolve();
     init_register();
@@ -23880,8 +24099,8 @@ __export(install_exports, {
   install: () => install,
   writeTeamFiles: () => writeTeamFiles
 });
-import { existsSync as existsSync11, writeFileSync as writeFileSync5 } from "fs";
-import { join as join14 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync13, mkdirSync as mkdirSync9, writeFileSync as writeFileSync6 } from "fs";
+import { join as join16 } from "path";
 async function install(opts) {
   console.log(`eminiar v${version2()} installer`);
   log.step("node");
@@ -23911,8 +24130,8 @@ async function install(opts) {
   }
   log.step("data directory");
   const p = ensureDirs();
-  if (!existsSync11(p.configFile))
-    writeFileSync5(p.configFile, `${JSON.stringify(ConfigSchema.parse({}), null, 2)}
+  if (!existsSync13(p.configFile))
+    writeFileSync6(p.configFile, `${JSON.stringify(ConfigSchema.parse({}), null, 2)}
 `);
   globalDb();
   log.ok(p.home);
@@ -23922,18 +24141,23 @@ async function install(opts) {
     if (err) log.warn(`download failed (${err}); it will be retried lazily on first hybrid search`);
     else log.ok("ready");
   }
-  log.step("register with Claude Code");
-  const method = opts.method ?? (claudeCli() ? "plugin" : "settings");
+  const claude = claudeCli();
+  const wantClaude = !opts.cursor || !!claude || !!opts.method;
+  const method = opts.method ?? (claude ? "plugin" : "settings");
+  const targets = [wantClaude ? `Claude Code (${method} method)` : "", opts.cursor ? "Cursor" : ""].filter(Boolean).join(" and ");
+  log.step(`register with ${targets}`);
+  if (opts.cursor && !cursorPresent())
+    log.warn(`${cursorDirHint()} not found; Cursor files are written anyway for its first launch`);
   if (!await confirm(
-    `Register eminiar with Claude Code using the ${method} method? This edits your user-level Claude config.`,
+    `Register eminiar with ${targets}? This edits your user-level ${[wantClaude ? "Claude" : "", opts.cursor ? "Cursor" : ""].filter(Boolean).join(" and ")} config.`,
     !!opts.yes
   )) {
     log.warn("skipped registration; re-run with --yes or confirm interactively");
     return 1;
   }
   let wrote = {};
-  let usedMethod = method;
-  if (method === "plugin") {
+  let usedMethod = wantClaude ? method : "none";
+  if (usedMethod === "plugin") {
     const r = registerPlugin(stable);
     if (r.ok) {
       log.ok(r.detail);
@@ -23949,15 +24173,27 @@ async function install(opts) {
       "hooks written to ~/.claude/settings.json, MCP server to ~/.claude.json, skills to ~/.claude/skills"
     );
   }
-  if (needsAuthEntry() && clearNeedsAuthEntry())
-    log.ok("cleared Claude Code's cached connection failure for the plugin server");
-  const wantStatusline = opts.statusline ?? (!!opts.yes && !opts.team);
-  if (wantStatusline) {
-    if (setStatusline(stable)) {
-      wrote.statusline = true;
-      log.ok("statusLine set to `eminiar statusline`");
+  if (wantClaude) {
+    if (needsAuthEntry() && clearNeedsAuthEntry())
+      log.ok("cleared Claude Code's cached connection failure for the plugin server");
+    const wantStatusline = opts.statusline ?? (!!opts.yes && !opts.team);
+    if (wantStatusline) {
+      if (setStatusline(stable)) {
+        wrote.statusline = true;
+        log.ok("statusLine set to `eminiar statusline`");
+      }
     }
   }
+  if (opts.cursor) {
+    wrote.cursor = registerCursor(stable);
+    log.ok(
+      `hooks written to ${cursorDirHint()}/hooks.json, MCP server to ${cursorDirHint()}/mcp.json, skills to ${cursorDirHint()}/skills`
+    );
+    if (usedMethod === "settings")
+      log.warn(
+        "Cursor also imports Claude Code hooks from ~/.claude/settings.json (Settings \u2192 Agents \u2192 Third-Party Imports); turn that off or each event fires twice in Cursor"
+      );
+  }
   writeInstallRecord({
     version: version2(),
     method: usedMethod,
@@ -23969,21 +24205,25 @@ async function install(opts) {
   });
   if (opts.team) {
     log.step("team defaults");
-    writeTeamFiles(resolveProjectRoot(), opts.marketplace);
+    writeTeamFiles(resolveProjectRoot(), opts.marketplace, { cursor: !!opts.cursor, stable });
   }
   log.step("doctor");
   const checks = await fullDoctor();
   console.log(formatDoctor(checks));
+  const restart = [wantClaude ? "Claude Code" : "", opts.cursor ? "Cursor" : ""].filter(Boolean).join(" and ");
   console.log(
     `
-Restart Claude Code to load eminiar. Try /em-doctor, then em_execute with an intent.`
+Restart ${restart} to load eminiar. Try ${wantClaude ? "/em-doctor, then " : ""}em_execute with an intent.`
   );
   return checks.every((c) => c.ok) ? 0 : 1;
 }
-function writeTeamFiles(root, marketplace) {
-  const cfg = join14(root, "eminiar.config.json");
-  if (!existsSync11(cfg)) {
-    writeFileSync5(
+function cursorDirHint() {
+  return process.env.CURSOR_CONFIG_DIR || "~/.cursor";
+}
+function writeTeamFiles(root, marketplace, extra = {}) {
+  const cfg = join16(root, "eminiar.config.json");
+  if (!existsSync13(cfg)) {
+    writeFileSync6(
       cfg,
       `${JSON.stringify(
         {
@@ -24013,7 +24253,7 @@ function writeTeamFiles(root, marketplace) {
   }
   if (marketplace) {
     const m = /^github:(.+)$/.exec(marketplace);
-    const file3 = join14(root, ".claude", "settings.json");
+    const file3 = join16(root, ".claude", "settings.json");
     const settings = readJson2(file3);
     const known = settings.extraKnownMarketplaces ?? {};
     known.eminiar = m ? { source: { source: "github", repo: m[1] } } : { source: { source: "url", url: marketplace } };
@@ -24026,7 +24266,19 @@ function writeTeamFiles(root, marketplace) {
       `${file3}: marketplace + enabledPlugins added \u2014 teammates are prompted to install on next launch`
     );
   } else {
-    log.info("teammates: `npx eminiar install` (reads the committed eminiar.config.json)");
+    log.info(
+      `teammates: \`npx eminiar install${extra.cursor ? " --cursor" : ""}\` (reads the committed eminiar.config.json)`
+    );
+  }
+  if (extra.cursor) {
+    const src = join16(extra.stable ?? "", "rules", "eminiar.mdc");
+    const dst = join16(root, ".cursor", "rules", "eminiar.mdc");
+    if (existsSync13(dst)) log.ok(`${dst} already exists`);
+    else if (existsSync13(src)) {
+      mkdirSync9(join16(root, ".cursor", "rules"), { recursive: true });
+      copyFileSync2(src, dst);
+      log.ok(`wrote ${dst} \u2014 commit it`);
+    }
   }
 }
 var init_install = __esm({
@@ -24040,6 +24292,7 @@ var init_install = __esm({
     init_global();
     init_version();
     init_claude_config();
+    init_cursor2();
     init_doctor2();
     init_materialize();
     init_node_resolve();
@@ -24062,12 +24315,14 @@ async function upgrade() {
   const fromCheckout = rec.fromSpec.startsWith("pack:") || rec.fromSpec === "self";
   return install({
     yes: true,
-    method: rec.method,
+    // "none" means Cursor-only last time; let install() decide again from what is present.
+    method: rec.method === "none" ? void 0 : rec.method,
     noModel: false,
     spec: fromCheckout ? void 0 : "eminiar@latest",
     force: fromCheckout,
     node: rec.node,
-    statusline: !!rec.wrote.statusline
+    statusline: !!rec.wrote.statusline,
+    cursor: !!rec.wrote.cursor
   });
 }
 var init_upgrade = __esm({
@@ -24085,13 +24340,14 @@ var uninstall_exports = {};
 __export(uninstall_exports, {
   uninstall: () => uninstall
 });
-import { existsSync as existsSync12, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync14, rmSync as rmSync6 } from "fs";
 async function uninstall(opts) {
   const rec = readInstallRecord();
   const p = paths();
   const plan = [
     rec?.method === "plugin" || !rec ? "claude plugin uninstall eminiar@eminiar + marketplace remove" : "",
     rec?.method === "settings" ? "remove eminiar hook entries from ~/.claude/settings.json, mcpServers.eminiar from ~/.claude.json, em-* skills" : "",
+    rec?.wrote.cursor ? "remove eminiar hook entries from ~/.cursor/hooks.json, mcpServers.eminiar from ~/.cursor/mcp.json, em-* skills from ~/.cursor/skills" : "",
     rec?.wrote.statusline ? "clear the eminiar statusLine" : "",
     `delete ${p.plugin}`,
     opts.purgeData ? `delete ${p.home} (ALL indexes, memories, stats)` : `keep ${p.home} (indexes, memories, stats)`
@@ -24102,11 +24358,13 @@ async function uninstall(opts) {
   const stable = rec?.stableRoot ?? `${p.plugin}/node_modules/eminiar`;
   if (!rec || rec.method === "plugin") unregisterPlugin();
   if (rec?.method === "settings") unregisterSettings(stable, rec.wrote);
+  if (rec?.wrote.cursor) unregisterCursor(stable, rec.wrote.cursor);
   if (rec?.wrote.statusline) clearStatusline(stable);
-  if (existsSync12(p.plugin)) rmSync4(p.plugin, { recursive: true, force: true });
-  if (opts.purgeData) rmSync4(p.home, { recursive: true, force: true });
-  else if (existsSync12(p.installFile)) rmSync4(p.installFile, { force: true });
-  log.ok("eminiar removed from Claude Code; restart it to finish");
+  if (existsSync14(p.plugin)) rmSync6(p.plugin, { recursive: true, force: true });
+  if (opts.purgeData) rmSync6(p.home, { recursive: true, force: true });
+  else if (existsSync14(p.installFile)) rmSync6(p.installFile, { force: true });
+  const from = [rec?.method !== "none" ? "Claude Code" : "", rec?.wrote.cursor ? "Cursor" : ""].filter(Boolean).join(" and ");
+  log.ok(`eminiar removed from ${from || "Claude Code"}; restart it to finish`);
   return 0;
 }
 var init_uninstall = __esm({
@@ -24115,6 +24373,7 @@ var init_uninstall = __esm({
     init_esm_shims();
     init_paths();
     init_claude_config();
+    init_cursor2();
     init_register();
     init_shell();
   }
@@ -30413,7 +30672,7 @@ function chunkMarkdown(text3, baseTitle, opts = DEFAULT_CHUNKER) {
     if (/^\s*(```|~~~)/.test(line)) inFence = !inFence;
     const m = !inFence && /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(line);
     if (m) {
-      if (current.lines.length) sections.push(current);
+      sections.push(current);
       const level = m[1].length;
       while (stack.length && stack[stack.length - 1].level >= level) stack.pop();
       stack.push({ level, text: m[2] });
@@ -30422,14 +30681,23 @@ function chunkMarkdown(text3, baseTitle, opts = DEFAULT_CHUNKER) {
     }
     current.lines.push(line);
   });
-  if (current.lines.length) sections.push(current);
+  sections.push(current);
   const out = [];
-  for (const s of sections) {
+  sections.forEach((s, k) => {
     const title = s.path.length ? `${baseTitle} > ${s.path.join(" > ")}` : baseTitle;
     const body = s.lines.join("\n");
+    if (!body.trim()) {
+      const next = sections[k + 1];
+      const isParent = next !== void 0 && next.path.length > s.path.length && s.path.every((p, j) => next.path[j] === p);
+      if (s.path.length && !isParent) {
+        const heading = s.path[s.path.length - 1];
+        out.push({ title, body: heading, startLine: s.startLine, endLine: s.startLine });
+      }
+      return;
+    }
     if (body.length <= opts.maxChars) {
       out.push({ title, body, startLine: s.startLine, endLine: s.startLine + s.lines.length - 1 });
-      continue;
+      return;
     }
     let fence = false;
     const fenceState = s.lines.map((l) => {
@@ -30445,7 +30713,7 @@ function chunkMarkdown(text3, baseTitle, opts = DEFAULT_CHUNKER) {
         s.startLine - 1
       )
     );
-  }
+  });
   return out;
 }
 var init_markdown = __esm({
@@ -30553,11 +30821,24 @@ __export(indexer_exports, {
   indexContent: () => indexContent,
   indexPath: () => indexPath
 });
-import { readFileSync as readFileSync10, statSync } from "fs";
+import { readFileSync as readFileSync12, statSync } from "fs";
 import { relative, resolve as resolve2 } from "path";
 function indexContent(db, input2) {
   const kind = input2.kind ?? (input2.contentType === "code" ? "code" : input2.contentType === "json" ? "json" : void 0);
-  const { chunks, kind: k } = input2.chunks ? { chunks: finalize2(input2.chunks, input2.contentType ?? "code"), kind: kind ?? "code" } : chunk(input2.content, input2.title, kind, input2.uri);
+  const cut = input2.chunks ? { chunks: finalize2(input2.chunks, input2.contentType ?? "code"), kind: kind ?? "code" } : chunk(input2.content, input2.title, kind, input2.uri);
+  const k = cut.kind;
+  const fallback = cut.chunks.length === 0 && input2.content.trim().length > 0;
+  const chunks = fallback ? finalize2(
+    [
+      {
+        title: input2.title,
+        body: input2.content,
+        startLine: 1,
+        endLine: input2.content.split("\n").length
+      }
+    ],
+    kindToContentType(k)
+  ) : cut.chunks;
   const contentHash = hashText(input2.content);
   const existing = input2.uri ? db.findDocumentByUri(input2.uri) : void 0;
   if (existing && existing.content_hash === contentHash) {
@@ -30567,7 +30848,8 @@ function indexContent(db, input2) {
         created: false,
         chunks: chunks.length,
         chars: input2.content.length,
-        kind: k
+        kind: k,
+        fallback
       };
     }
     db.deleteDocument(existing.id);
@@ -30584,11 +30866,25 @@ function indexContent(db, input2) {
     },
     chunks
   );
-  return { documentId: id, created, chunks: chunks.length, chars: input2.content.length, kind: k };
+  return {
+    documentId: id,
+    created,
+    chunks: chunks.length,
+    chars: input2.content.length,
+    kind: k,
+    fallback
+  };
 }
 function indexPath(db, root, target, opts = {}) {
   const abs = resolve2(root, target);
-  const summary = { files: 0, indexed: 0, unchanged: 0, skipped: [], chunks: 0 };
+  const summary = {
+    files: 0,
+    indexed: 0,
+    unchanged: 0,
+    skipped: [],
+    chunks: 0,
+    fallbacks: 0
+  };
   const st = statSync(abs);
   const files = st.isDirectory() ? import_fast_glob.default.sync(opts.globs ?? ["**/*.md"], {
     cwd: abs,
@@ -30607,7 +30903,7 @@ function indexPath(db, root, target, opts = {}) {
         summary.skipped.push({ path: rel, reason: `too large (${size} bytes)` });
         continue;
       }
-      const content = readFileSync10(file3, "utf8");
+      const content = readFileSync12(file3, "utf8");
       if (content.includes("\0")) {
         summary.skipped.push({ path: rel, reason: "binary" });
         continue;
@@ -30623,6 +30919,7 @@ function indexPath(db, root, target, opts = {}) {
       if (r.created) summary.indexed++;
       else summary.unchanged++;
       summary.chunks += r.chunks;
+      if (r.fallback) summary.fallbacks++;
     } catch (err) {
       summary.skipped.push({ path: rel, reason: err.message });
     }
@@ -30698,7 +30995,7 @@ var init_em_index = __esm({
           });
           kickEmbedding(ctx, db);
           return text(
-            `${r.created ? "indexed" : "unchanged"} "${args.title}" as doc ${r.documentId}: ${r.chunks} chunks, ${r.chars} chars (${r.kind})`
+            `${r.created ? "indexed" : "unchanged"} "${args.title}" as doc ${r.documentId}: ${r.chunks} chunks, ${r.chars} chars (${r.kind})${r.fallback ? " (no sections found; indexed as one chunk)" : ""}`
           );
         }
         if (!args.path) return errorResult("provide `path` or `content`");
@@ -30708,7 +31005,7 @@ var init_em_index = __esm({
           recursive: args.recursive ?? true
         });
         const lines = [
-          `${args.path}: ${s.files} file(s), ${s.indexed} indexed, ${s.unchanged} unchanged, ${s.chunks} chunks`
+          `${args.path}: ${s.files} file(s), ${s.indexed} indexed, ${s.unchanged} unchanged, ${s.chunks} chunks${s.fallbacks ? ` (${s.fallbacks} with no sections found; indexed as one chunk)` : ""}`
         ];
         for (const sk of s.skipped.slice(0, 10)) lines.push(`  skipped ${sk.path}: ${sk.reason}`);
         if (s.skipped.length > 10) lines.push(`  \u2026 ${s.skipped.length - 10} more skipped`);
@@ -32221,8 +32518,8 @@ var init_routes = __esm({
 });
 
 // src/graph/languages/parser.ts
-import { existsSync as existsSync13 } from "fs";
-import { extname as extname2, join as join15 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { extname as extname2, join as join17 } from "path";
 function grammarFor(path3) {
   switch (extname2(path3).toLowerCase()) {
     case ".ts":
@@ -32255,8 +32552,8 @@ async function getParser(grammar) {
   }
   let lang = languages.get(grammar);
   if (!lang) {
-    const file3 = join15(pluginRoot(), "vendor", "grammars", `${grammar}.wasm`);
-    if (!existsSync13(file3)) throw new Error(`grammar missing: ${file3}`);
+    const file3 = join17(pluginRoot(), "vendor", "grammars", `${grammar}.wasm`);
+    if (!existsSync15(file3)) throw new Error(`grammar missing: ${file3}`);
     lang = await parserMod.Language.load(file3);
     languages.set(grammar, lang);
   }
@@ -32314,8 +32611,8 @@ var init_parser = __esm({
 });
 
 // src/graph/languages/go.ts
-import { existsSync as existsSync14, readdirSync as readdirSync5, readFileSync as readFileSync11 } from "fs";
-import { dirname as dirname4, join as join16, normalize, relative as relative2, resolve as resolve3 } from "path";
+import { existsSync as existsSync16, readdirSync as readdirSync6, readFileSync as readFileSync13 } from "fs";
+import { dirname as dirname4, join as join18, normalize, relative as relative2, resolve as resolve3 } from "path";
 function goModule(root, fromAbs) {
   let dir = dirname4(fromAbs);
   while (dir.startsWith(root)) {
@@ -32323,9 +32620,9 @@ function goModule(root, fromAbs) {
     if (hit !== void 0) {
       if (hit) return hit;
     } else {
-      const file3 = join16(dir, "go.mod");
-      if (existsSync14(file3)) {
-        const m = /^module\s+(\S+)/m.exec(readFileSync11(file3, "utf8"));
+      const file3 = join18(dir, "go.mod");
+      if (existsSync16(file3)) {
+        const m = /^module\s+(\S+)/m.exec(readFileSync13(file3, "utf8"));
         const info = m ? { module: m[1], dir } : null;
         goModCache.set(dir, info);
         if (info) return info;
@@ -32342,11 +32639,11 @@ function resolveGoPackage(root, fromRel, importPath) {
   let dir;
   if (importPath === mod.module) dir = mod.dir;
   else if (importPath.startsWith(`${mod.module}/`))
-    dir = join16(mod.dir, importPath.slice(mod.module.length + 1));
-  if (!dir || !existsSync14(dir)) return [];
+    dir = join18(mod.dir, importPath.slice(mod.module.length + 1));
+  if (!dir || !existsSync16(dir)) return [];
   try {
-    return readdirSync5(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).sort().map(
-      (f) => normalize(relative2(root, join16(dir, f))).split("\\").join("/")
+    return readdirSync6(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).sort().map(
+      (f) => normalize(relative2(root, join18(dir, f))).split("\\").join("/")
     );
   } catch {
     return [];
@@ -32748,13 +33045,13 @@ var init_go = __esm({
 });
 
 // src/graph/languages/php.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync12, statSync as statSync2 } from "fs";
-import { dirname as dirname5, join as join17, normalize as normalize2, relative as relative3, resolve as resolve4 } from "path";
+import { readdirSync as readdirSync7, readFileSync as readFileSync14, statSync as statSync2 } from "fs";
+import { dirname as dirname5, join as join19, normalize as normalize2, relative as relative3, resolve as resolve4 } from "path";
 function readComposer(dir) {
-  const file3 = join17(dir, "composer.json");
+  const file3 = join19(dir, "composer.json");
   if (!isFile(file3)) return null;
   try {
-    const json3 = JSON.parse(readFileSync12(file3, "utf8"));
+    const json3 = JSON.parse(readFileSync14(file3, "utf8"));
     const info = { dir, psr4: [], psr0: [], classmap: [], files: [], require: [] };
     for (const key of ["autoload", "autoload-dev"]) {
       const section = json3[key];
@@ -32796,7 +33093,7 @@ function phpFilesUnder(abs, budget) {
   if (isFile(abs)) return abs.endsWith(".php") ? [abs] : [];
   let entries;
   try {
-    entries = readdirSync6(abs, { recursive: true, encoding: "utf8" });
+    entries = readdirSync7(abs, { recursive: true, encoding: "utf8" });
   } catch {
     return [];
   }
@@ -32804,7 +33101,7 @@ function phpFilesUnder(abs, budget) {
   for (const e of entries) {
     if (budget.left <= 0) break;
     if (!e.endsWith(".php") || e.split(/[\\/]/).includes("vendor")) continue;
-    out.push(join17(abs, e));
+    out.push(join19(abs, e));
     budget.left--;
   }
   return out;
@@ -32814,11 +33111,11 @@ function classmapClasses(root, auto) {
   const classes = /* @__PURE__ */ new Map();
   const budget = { left: CLASSMAP_MAX_FILES };
   for (const entry of auto.classmap) {
-    for (const f of phpFilesUnder(join17(auto.dir, entry), budget)) {
+    for (const f of phpFilesUnder(join19(auto.dir, entry), budget)) {
       if (relative3(root, f).startsWith("..")) continue;
       let code;
       try {
-        code = readFileSync12(f, "utf8");
+        code = readFileSync14(f, "utf8");
       } catch {
         continue;
       }
@@ -32838,11 +33135,11 @@ function autoloadedFunctions(root, auto) {
   if (auto.functions) return auto.functions;
   const functions = /* @__PURE__ */ new Map();
   for (const entry of auto.files) {
-    const f = join17(auto.dir, entry);
+    const f = join19(auto.dir, entry);
     if (!isFile(f) || relative3(root, f).startsWith("..")) continue;
     let code;
     try {
-      code = readFileSync12(f, "utf8");
+      code = readFileSync14(f, "utf8");
     } catch {
       continue;
     }
@@ -32862,14 +33159,14 @@ function resolvePhpClass(root, fromRel, fqcn) {
     for (const { prefix, dirs } of auto.psr4) {
       if (!name.startsWith(prefix)) continue;
       const rest2 = name.slice(prefix.length).split("\\");
-      for (const d of dirs) candidates2.push(join17(auto.dir, d, ...rest2));
+      for (const d of dirs) candidates2.push(join19(auto.dir, d, ...rest2));
     }
     for (const { prefix, dirs } of auto.psr0) {
       if (!name.startsWith(prefix)) continue;
       const cut = name.lastIndexOf("\\");
       const ns = cut === -1 ? [] : name.slice(0, cut).split("\\");
       const cls = name.slice(cut + 1).split("_");
-      for (const d of dirs) candidates2.push(join17(auto.dir, d, ...ns, ...cls));
+      for (const d of dirs) candidates2.push(join19(auto.dir, d, ...ns, ...cls));
     }
   } else {
     const parts = name.split("\\");
@@ -33106,7 +33403,7 @@ async function parsePhp(root, rel, code) {
           for (let i = left.includes("__FILE__") ? 1 : 0; i < Number(up[1] ?? 1); i++)
             base = dirname5(base);
         }
-        if (base && right !== void 0) candidates2.push(join17(base, right));
+        if (base && right !== void 0) candidates2.push(join19(base, right));
       }
       const hit = candidates2.find((c) => isFile(c) && !relative3(root, c).startsWith(".."));
       if (!hit) continue;
@@ -33815,25 +34112,25 @@ var init_php = __esm({
 });
 
 // src/graph/languages/python.ts
-import { existsSync as existsSync15, statSync as statSync3 } from "fs";
-import { dirname as dirname6, join as join18, normalize as normalize3, relative as relative4, resolve as resolve5 } from "path";
+import { existsSync as existsSync17, statSync as statSync3 } from "fs";
+import { dirname as dirname6, join as join20, normalize as normalize3, relative as relative4, resolve as resolve5 } from "path";
 function resolvePython(root, fromRel, module, level) {
   const parts = module ? module.split(".") : [];
   const candidates2 = [];
   if (level > 0) {
     let base = dirname6(resolve5(root, fromRel));
     for (let i = 1; i < level; i++) base = dirname6(base);
-    candidates2.push(join18(base, ...parts));
+    candidates2.push(join20(base, ...parts));
   } else {
     candidates2.push(resolve5(root, ...parts), resolve5(root, "src", ...parts));
     let dir = dirname6(resolve5(root, fromRel));
     while (dir.startsWith(root) && dir !== root) {
-      candidates2.push(join18(dir, ...parts));
+      candidates2.push(join20(dir, ...parts));
       dir = dirname6(dir);
     }
   }
   for (const c of candidates2) {
-    for (const f of [`${c}.py`, join18(c, "__init__.py"), `${c}.pyi`]) {
+    for (const f of [`${c}.py`, join20(c, "__init__.py"), `${c}.pyi`]) {
       if (isFile2(f) && !relative4(root, f).startsWith(".."))
         return normalize3(relative4(root, f)).split("\\").join("/");
     }
@@ -33872,7 +34169,7 @@ async function parsePython(root, rel, code) {
       walkRefs(stmt);
   }
   edges.push(...refs.edges());
-  if (!existsSync15(join18(root, rel))) {
+  if (!existsSync17(join20(root, rel))) {
   }
   const errors = tree.rootNode.hasError ? tree.rootNode.descendantsOfType("ERROR").length : 0;
   fileNode.meta = {
@@ -34219,16 +34516,16 @@ var init_python = __esm({
 });
 
 // src/graph/resolve.ts
-import { existsSync as existsSync16, readdirSync as readdirSync7, readFileSync as readFileSync13, statSync as statSync4 } from "fs";
-import { dirname as dirname7, join as join19, normalize as normalize4, relative as relative5, resolve as resolve6 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync8, readFileSync as readFileSync15, statSync as statSync4 } from "fs";
+import { dirname as dirname7, join as join21, normalize as normalize4, relative as relative5, resolve as resolve6 } from "path";
 function loadTsPaths(root) {
   const hit = tsPathsCache.get(root);
   if (hit !== void 0) return hit;
   let out = null;
   try {
-    const file3 = join19(root, "tsconfig.json");
-    if (existsSync16(file3)) {
-      const raw = readFileSync13(file3, "utf8").replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "").replace(/,(\s*[}\]])/g, "$1");
+    const file3 = join21(root, "tsconfig.json");
+    if (existsSync18(file3)) {
+      const raw = readFileSync15(file3, "utf8").replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "").replace(/,(\s*[}\]])/g, "$1");
       const cfg = JSON.parse(raw);
       const co = cfg.compilerOptions ?? {};
       if (co.paths) {
@@ -34266,16 +34563,16 @@ function probe(abs) {
     if (tryFile(abs + ext)) return abs + ext;
   }
   for (const ext of EXTS) {
-    const idx = join19(abs, `index${ext}`);
+    const idx = join21(abs, `index${ext}`);
     if (tryFile(idx)) return idx;
   }
   return void 0;
 }
 function readPackageJson(dir) {
   try {
-    const file3 = join19(dir, "package.json");
-    if (!existsSync16(file3)) return void 0;
-    return JSON.parse(readFileSync13(file3, "utf8"));
+    const file3 = join21(dir, "package.json");
+    if (!existsSync18(file3)) return void 0;
+    return JSON.parse(readFileSync15(file3, "utf8"));
   } catch {
     return void 0;
   }
@@ -34291,9 +34588,9 @@ function loadWorkspaces(root) {
   if (Array.isArray(ws)) globs.push(...ws);
   else if (ws?.packages) globs.push(...ws.packages);
   try {
-    const yaml = join19(root, "pnpm-workspace.yaml");
-    if (existsSync16(yaml)) {
-      for (const m of readFileSync13(yaml, "utf8").matchAll(/^\s*-\s*['"]?([^'"\n#]+?)['"]?\s*$/gm))
+    const yaml = join21(root, "pnpm-workspace.yaml");
+    if (existsSync18(yaml)) {
+      for (const m of readFileSync15(yaml, "utf8").matchAll(/^\s*-\s*['"]?([^'"\n#]+?)['"]?\s*$/gm))
         globs.push(m[1].trim());
     }
   } catch {
@@ -34306,8 +34603,8 @@ function loadWorkspaces(root) {
     else {
       const base = resolve6(root, g.slice(0, star));
       try {
-        for (const d of readdirSync7(base, { withFileTypes: true })) {
-          if (d.isDirectory()) dirs.push(join19(base, d.name));
+        for (const d of readdirSync8(base, { withFileTypes: true })) {
+          if (d.isDirectory()) dirs.push(join21(base, d.name));
         }
       } catch {
       }
@@ -35450,8 +35747,8 @@ var init_link = __esm({
 });
 
 // src/graph/reindex.ts
-import { readFileSync as readFileSync14, statSync as statSync5 } from "fs";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync16, statSync as statSync5 } from "fs";
+import { join as join22 } from "path";
 function listCodeFiles(ctx) {
   return import_fast_glob2.default.sync(ctx.config.graph.include, {
     cwd: ctx.root,
@@ -35462,7 +35759,7 @@ function listCodeFiles(ctx) {
   });
 }
 async function indexOne(ctx, db, rel, force) {
-  const abs = join20(ctx.root, rel);
+  const abs = join22(ctx.root, rel);
   const st = statSync5(abs);
   const backend = getCodeBackend(ctx);
   const language = backend.languageOf(rel) ?? null;
@@ -35482,7 +35779,7 @@ async function indexOne(ctx, db, rel, force) {
     }
     return "skipped";
   }
-  const code = readFileSync14(abs, "utf8");
+  const code = readFileSync16(abs, "utf8");
   const hash2 = hashText(code);
   const prev = db.fileIndexGet(rel);
   if (!force && prev?.hash === hash2 && prev.status !== "skipped") return "unchanged";
@@ -35563,7 +35860,7 @@ async function reindexCode(ctx, db, opts = {}) {
     summary.unsupported++;
     if (db.fileIndexGet(rel)?.status === "unsupported") continue;
     try {
-      const st = statSync5(join20(ctx.root, rel));
+      const st = statSync5(join22(ctx.root, rel));
       db.fileIndexSet({
         path: rel,
         hash: "",
@@ -35579,7 +35876,7 @@ async function reindexCode(ctx, db, opts = {}) {
   }
   for (const rel of targets) {
     try {
-      if (!statSafe(join20(ctx.root, rel))) {
+      if (!statSafe(join22(ctx.root, rel))) {
         if (db.fileIndexGet(rel)) {
           removeOne(db, rel);
           summary.removed++;
@@ -35591,7 +35888,7 @@ async function reindexCode(ctx, db, opts = {}) {
       const error62 = err.message;
       summary.errors.push({ path: rel, error: error62 });
       try {
-        const st = statSync5(join20(ctx.root, rel));
+        const st = statSync5(join22(ctx.root, rel));
         db.fileIndexSet({
           path: rel,
           hash: "",
@@ -35694,10 +35991,10 @@ function indexFreshness(ctx, db) {
   const dirty = [];
   for (const r of rows.slice(0, 400)) {
     try {
-      const abs = join20(ctx.root, r.path);
+      const abs = join22(ctx.root, r.path);
       const st = statSync5(abs);
       if (r.mtime !== null && Math.abs(st.mtimeMs - r.mtime) < 1 && st.size === r.size) continue;
-      if (hashText(readFileSync14(abs, "utf8")) !== r.hash) dirty.push(r.path);
+      if (hashText(readFileSync16(abs, "utf8")) !== r.hash) dirty.push(r.path);
     } catch {
       dirty.push(r.path);
     }
@@ -35731,10 +36028,10 @@ var init_reindex = __esm({
 });
 
 // src/session/current.ts
-import { readFileSync as readFileSync15, statSync as statSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join21 } from "path";
+import { readFileSync as readFileSync17, statSync as statSync6, writeFileSync as writeFileSync7 } from "fs";
+import { join as join23 } from "path";
 function file2(ctx) {
-  return join21(projectDir(ctx.id), "current-session");
+  return join23(projectDir(ctx.id), "current-session");
 }
 function getCurrentSession(ctx) {
   if (process.env.EMINIAR_SESSION_ID) return process.env.EMINIAR_SESSION_ID;
@@ -35746,7 +36043,7 @@ function getCurrentSession(ctx) {
     return "unknown";
   }
   if (cached4 && cached4.file === f && cached4.mtimeMs === mtimeMs) return cached4.id;
-  const id = readFileSync15(f, "utf8").trim() || "unknown";
+  const id = readFileSync17(f, "utf8").trim() || "unknown";
   cached4 = { file: f, mtimeMs, id };
   return id;
 }
@@ -35917,15 +36214,15 @@ __export(store_exports, {
   write: () => write
 });
 import {
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync16,
+  existsSync as existsSync19,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync18,
   renameSync,
   statSync as statSync7,
   unlinkSync,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "fs";
-import { dirname as dirname8, join as join22, relative as relative6, sep } from "path";
+import { dirname as dirname8, join as join24, relative as relative6, sep } from "path";
 function isStatus(s) {
   return typeof s === "string" && MEMORY_STATUSES.includes(s);
 }
@@ -35939,13 +36236,13 @@ function memoriesRel(ctx) {
   return ctx.config.memories.dir.replace(/^\.\//, "").replace(/\/+$/, "");
 }
 function memoriesDir(ctx) {
-  return join22(ctx.root, memoriesRel(ctx));
+  return join24(ctx.root, memoriesRel(ctx));
 }
 function relOf(ctx, name) {
   return `${memoriesRel(ctx)}/${name}.md`;
 }
 function absOf(ctx, name) {
-  return join22(ctx.root, relOf(ctx, name));
+  return join24(ctx.root, relOf(ctx, name));
 }
 function nameOfFile(ctx, abs) {
   const rel = relative6(memoriesDir(ctx), abs).split(sep).join("/");
@@ -36003,7 +36300,7 @@ function impliedFileLinks(root, body, skipPrefix) {
     if (!p || p.startsWith("..") || out.has(p) || skipPrefix && p.startsWith(`${skipPrefix}/`))
       continue;
     try {
-      if (statSync7(join22(root, p)).isFile()) out.add(p);
+      if (statSync7(join24(root, p)).isFile()) out.add(p);
     } catch {
     }
     if (out.size >= 30) break;
@@ -36012,8 +36309,8 @@ function impliedFileLinks(root, body, skipPrefix) {
 }
 function writeMemoryFile(ctx, name, meta4, body) {
   const abs = absOf(ctx, name);
-  mkdirSync7(dirname8(abs), { recursive: true });
-  writeFileSync7(abs, serializeMemoryFile(meta4, `
+  mkdirSync10(dirname8(abs), { recursive: true });
+  writeFileSync8(abs, serializeMemoryFile(meta4, `
 ${body.trim()}
 `));
 }
@@ -36051,13 +36348,13 @@ function forgetInDb(db, name, rel) {
 function syncFile(ctx, db, name, opts = {}) {
   const abs = absOf(ctx, name);
   const rel = relOf(ctx, name);
-  if (!existsSync17(abs)) return void 0;
+  if (!existsSync19(abs)) return void 0;
   let st = statSync7(abs);
   const row = db.memoryGetByName(name);
   const mtime = Math.floor(st.mtimeMs);
   if (!opts.force && row && row.file_mtime === mtime && row.file_size === st.size)
     return { changed: false, row };
-  let text3 = readFileSync16(abs, "utf8");
+  let text3 = readFileSync18(abs, "utf8");
   let hash2 = hashText(text3);
   if (!opts.force && row && row.file_hash === hash2) {
     db.memoryUpsertByName({
@@ -36095,7 +36392,7 @@ function syncFile(ctx, db, name, opts = {}) {
       parsed.hadFrontmatter ? parsed.body : `
 ${parsed.body.replace(/^\s*\n/, "")}`
     );
-    writeFileSync7(abs, text3);
+    writeFileSync8(abs, text3);
     st = statSync7(abs);
     hash2 = hashText(text3);
   }
@@ -36137,15 +36434,15 @@ tags: ${tags.join(", ")}` : ""}`,
 }
 function setMeta(ctx, db, name, patch) {
   const abs = absOf(ctx, name);
-  if (!existsSync17(abs)) return false;
-  const parsed = parseMemoryFile(readFileSync16(abs, "utf8"));
+  if (!existsSync19(abs)) return false;
+  const parsed = parseMemoryFile(readFileSync18(abs, "utf8"));
   const meta4 = { ...parsed.meta };
   for (const [k, v] of Object.entries(patch)) {
     if (v === void 0) delete meta4[k];
     else meta4[k] = v;
   }
   meta4.updated = (/* @__PURE__ */ new Date()).toISOString();
-  writeFileSync7(abs, serializeMemoryFile(meta4, parsed.body));
+  writeFileSync8(abs, serializeMemoryFile(meta4, parsed.body));
   syncFile(ctx, db, name, { force: true });
   return true;
 }
@@ -36154,10 +36451,10 @@ function migrateLegacy(ctx, db) {
   for (const row of db.memoryLegacyRows()) {
     const kind = isKind(row.kind) ? row.kind : "note";
     const base = `${kind}/${slugify2(row.content)}`;
-    const taken = existsSync17(absOf(ctx, base)) || !!db.memoryGetByName(base);
+    const taken = existsSync19(absOf(ctx, base)) || !!db.memoryGetByName(base);
     const name = taken ? `${base}-${row.id}` : base;
     const created = new Date(row.created_at).toISOString();
-    if (!existsSync17(absOf(ctx, name))) {
+    if (!existsSync19(absOf(ctx, name))) {
       writeMemoryFile(
         ctx,
         name,
@@ -36182,7 +36479,7 @@ function reconcile(ctx, db) {
   const out = { files: 0, synced: 0, removed: 0, migrated: 0, skipped: [] };
   out.migrated = migrateLegacy(ctx, db);
   const dir = memoriesDir(ctx);
-  const files = existsSync17(dir) ? import_fast_glob3.default.sync("**/*.md", { cwd: dir, absolute: true, onlyFiles: true, dot: true }) : [];
+  const files = existsSync19(dir) ? import_fast_glob3.default.sync("**/*.md", { cwd: dir, absolute: true, onlyFiles: true, dot: true }) : [];
   const seen = /* @__PURE__ */ new Set();
   for (const f of files) {
     const name = nameOfFile(ctx, f);
@@ -36210,7 +36507,7 @@ function write(ctx, db, input2) {
     );
   const abs = absOf(ctx, name);
   const prev = db.memoryGetByName(name);
-  const exists = !!prev || existsSync17(abs);
+  const exists = !!prev || existsSync19(abs);
   if (exists && !input2.replace)
     throw new Error(
       `memory "${name}" already exists; pass replace: true to overwrite it, or em_memory {action: "edit"} to change part of it`
@@ -36219,7 +36516,7 @@ function write(ctx, db, input2) {
   let extra = {};
   if (exists) {
     try {
-      extra = parseMemoryFile(readFileSync16(abs, "utf8")).meta;
+      extra = parseMemoryFile(readFileSync18(abs, "utf8")).meta;
     } catch {
     }
   }
@@ -36246,7 +36543,7 @@ function write(ctx, db, input2) {
 function read(ctx, db, name) {
   const synced = syncFile(ctx, db, name);
   if (!synced) return void 0;
-  const parsed = parseMemoryFile(readFileSync16(absOf(ctx, name), "utf8"));
+  const parsed = parseMemoryFile(readFileSync18(absOf(ctx, name), "utf8"));
   return {
     name,
     kind: synced.row.kind,
@@ -36271,14 +36568,14 @@ function escapeRe(s) {
 }
 function edit(ctx, db, name, opts) {
   const abs = absOf(ctx, name);
-  if (!existsSync17(abs)) throw new Error(`memory "${name}" does not exist`);
+  if (!existsSync19(abs)) throw new Error(`memory "${name}" does not exist`);
   syncFile(ctx, db, name);
-  const parsed = parseMemoryFile(readFileSync16(abs, "utf8"));
+  const parsed = parseMemoryFile(readFileSync18(abs, "utf8"));
   const re = new RegExp(opts.regex ? opts.find : escapeRe(opts.find), "g");
   const count = (parsed.body.match(re) ?? []).length;
   if (!count) return 0;
   const body = parsed.body.replace(re, opts.replace);
-  writeFileSync7(
+  writeFileSync8(
     abs,
     serializeMemoryFile({ ...parsed.meta, updated: (/* @__PURE__ */ new Date()).toISOString() }, body)
   );
@@ -36289,12 +36586,12 @@ function rename(ctx, db, from, to) {
   if (!isValidName(to)) throw new Error(`invalid memory name "${to}"`);
   const absFrom = absOf(ctx, from);
   const absTo = absOf(ctx, to);
-  if (!existsSync17(absFrom)) throw new Error(`memory "${from}" does not exist`);
-  if (existsSync17(absTo) || db.memoryGetByName(to)) throw new Error(`memory "${to}" already exists`);
-  mkdirSync7(dirname8(absTo), { recursive: true });
+  if (!existsSync19(absFrom)) throw new Error(`memory "${from}" does not exist`);
+  if (existsSync19(absTo) || db.memoryGetByName(to)) throw new Error(`memory "${to}" already exists`);
+  mkdirSync10(dirname8(absTo), { recursive: true });
   renameSync(absFrom, absTo);
-  const parsed = parseMemoryFile(readFileSync16(absTo, "utf8"));
-  writeFileSync7(
+  const parsed = parseMemoryFile(readFileSync18(absTo, "utf8"));
+  writeFileSync8(
     absTo,
     serializeMemoryFile(
       { ...parsed.meta, name: to, updated: (/* @__PURE__ */ new Date()).toISOString() },
@@ -36308,11 +36605,11 @@ function rename(ctx, db, from, to) {
   for (const row of db.memoryList({ limit: 1e5 })) {
     if (!row.name || row.name === to) continue;
     const abs = absOf(ctx, row.name);
-    if (!existsSync17(abs)) continue;
-    const text3 = readFileSync16(abs, "utf8");
+    if (!existsSync19(abs)) continue;
+    const text3 = readFileSync18(abs, "utf8");
     if (!ref.test(text3)) continue;
     ref.lastIndex = 0;
-    writeFileSync7(abs, text3.replace(ref, `mem:${to}`));
+    writeFileSync8(abs, text3.replace(ref, `mem:${to}`));
     syncFile(ctx, db, row.name, { force: true });
     refsUpdated++;
   }
@@ -36320,19 +36617,19 @@ function rename(ctx, db, from, to) {
 }
 function remove(ctx, db, name) {
   const abs = absOf(ctx, name);
-  const existed = existsSync17(abs) || !!db.memoryGetByName(name);
-  if (existsSync17(abs)) unlinkSync(abs);
+  const existed = existsSync19(abs) || !!db.memoryGetByName(name);
+  if (existsSync19(abs)) unlinkSync(abs);
   forgetInDb(db, name, relOf(ctx, name));
   return existed;
 }
 function gitignoreHint(ctx) {
   if (hinted.has(ctx.root)) return void 0;
   hinted.add(ctx.root);
-  const file3 = join22(ctx.root, ".gitignore");
-  if (!existsSync17(file3)) return void 0;
+  const file3 = join24(ctx.root, ".gitignore");
+  if (!existsSync19(file3)) return void 0;
   const dir = memoriesRel(ctx);
   const top2 = dir.split("/")[0];
-  const ignored = readFileSync16(file3, "utf8").split(/\r?\n/).map((l) => l.trim().replace(/^\//, "").replace(/\/$/, "")).some((l) => l === top2 || l === dir || l === `${top2}/**` || l === `${dir}/**`);
+  const ignored = readFileSync18(file3, "utf8").split(/\r?\n/).map((l) => l.trim().replace(/^\//, "").replace(/\/$/, "")).some((l) => l === top2 || l === dir || l === `${top2}/**` || l === `${dir}/**`);
   return ignored ? `note: .gitignore ignores ${dir}, so memories stay local to this machine (remove that line to share them with the team)` : void 0;
 }
 var import_fast_glob3, MEMORY_KINDS, SEGMENT, NAME_RE, MEM_LINK_RE, PATH_RE, hinted;
@@ -36962,12 +37259,12 @@ var init_em_graph_changes = __esm({
 });
 
 // src/graph/architecture.ts
-import { existsSync as existsSync18, readFileSync as readFileSync17 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync19 } from "fs";
+import { join as join25 } from "path";
 function pkgJson(root) {
   try {
-    const f = join23(root, "package.json");
-    return existsSync18(f) ? JSON.parse(readFileSync17(f, "utf8")) : {};
+    const f = join25(root, "package.json");
+    return existsSync20(f) ? JSON.parse(readFileSync19(f, "utf8")) : {};
   } catch {
     return {};
   }
@@ -38319,11 +38616,14 @@ var init_catalog = __esm({
 });
 
 // src/docs/manifest.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync8, readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname9, join as join24 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync11, readFileSync as readFileSync20, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname9, join as join26 } from "path";
 function docsTag(name) {
   return `${DOCS_PREFIX}${name}`;
 }
+function nameFromTag(tag) {
+  return tag.startsWith(DOCS_PREFIX) ? tag.slice(DOCS_PREFIX.length) : void 0;
+}
 function isValidName2(name) {
   return NAME_RE2.test(name);
 }
@@ -38332,7 +38632,7 @@ function slugify3(input2) {
   return (s || "source").slice(0, 64);
 }
 function manifestPathAt(root, rel = ".eminiar/docs.json") {
-  return join24(root, rel);
+  return join26(root, rel);
 }
 function manifestPath(ctx) {
   return manifestPathAt(ctx.root, ctx.config.docs.manifest);
@@ -38360,9 +38660,9 @@ function normalize5(raw) {
   return { version: 1, sources: out };
 }
 function readManifestAt(file3) {
-  if (!existsSync19(file3)) return empty();
+  if (!existsSync21(file3)) return empty();
   try {
-    return normalize5(JSON.parse(readFileSync18(file3, "utf8")));
+    return normalize5(JSON.parse(readFileSync20(file3, "utf8")));
   } catch {
     return empty();
   }
@@ -38372,12 +38672,12 @@ function readManifest(ctx) {
 }
 function writeManifest(ctx, m) {
   const file3 = manifestPath(ctx);
-  mkdirSync8(dirname9(file3), { recursive: true });
+  mkdirSync11(dirname9(file3), { recursive: true });
   const sorted = {
     version: 1,
     sources: [...m.sources].sort((a, b) => a.name.localeCompare(b.name))
   };
-  writeFileSync8(file3, `${JSON.stringify(sorted, null, 2)}
+  writeFileSync9(file3, `${JSON.stringify(sorted, null, 2)}
 `);
   return file3;
 }
@@ -38473,11 +38773,11 @@ var init_manifest = __esm({
 });
 
 // src/docs/discover.ts
-import { existsSync as existsSync20, readFileSync as readFileSync19, statSync as statSync8 } from "fs";
-import { basename, join as join25, relative as relative7 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync21, statSync as statSync8 } from "fs";
+import { basename, join as join27, relative as relative7 } from "path";
 function readText(file3) {
   try {
-    return readFileSync19(file3, "utf8");
+    return readFileSync21(file3, "utf8");
   } catch {
     return void 0;
   }
@@ -38531,7 +38831,7 @@ function findProjects(root, opts) {
   const found = /* @__PURE__ */ new Set();
   for (const m of markers) {
     for (const f of glob(root, [`*/${m}`, `*/*/${m}`], 3)) {
-      const dir = join25(f, "..");
+      const dir = join27(f, "..");
       const rel = relative7(root, dir);
       if (!rel || rel.split("/").some((p) => p.startsWith(".") || p === "node_modules")) continue;
       found.add(dir);
@@ -38540,7 +38840,7 @@ function findProjects(root, opts) {
   const max = opts.maxProjects ?? 40;
   const seenNames = /* @__PURE__ */ new Set();
   const nameOf = (dir) => {
-    const pkg = readJson3(join25(dir, "package.json"));
+    const pkg = readJson3(join27(dir, "package.json"));
     return typeof pkg?.name === "string" ? pkg.name : void 0;
   };
   const rootName = nameOf(root);
@@ -38558,7 +38858,7 @@ function findProjects(root, opts) {
   return out;
 }
 function npmSignals(dir, includeDev, project) {
-  const pkg = readJson3(join25(dir, "package.json"));
+  const pkg = readJson3(join27(dir, "package.json"));
   if (!pkg) return [];
   const sections = ["dependencies", ...includeDev ? ["devDependencies"] : []];
   const out = [];
@@ -38575,13 +38875,13 @@ function npmSignals(dir, includeDev, project) {
 }
 function pythonSignals(dir, project) {
   const out = [];
-  const py = readText(join25(dir, "pyproject.toml"));
+  const py = readText(join27(dir, "pyproject.toml"));
   if (py) {
     const block = /dependencies\s*=\s*\[([\s\S]*?)\]/.exec(py)?.[1] ?? "";
     for (const m of block.matchAll(/["']([A-Za-z0-9_.-]+)/g))
       out.push({ kind: "pypi", key: m[1].toLowerCase(), project });
   }
-  const req = readText(join25(dir, "requirements.txt"));
+  const req = readText(join27(dir, "requirements.txt"));
   if (req) {
     for (const line of req.split("\n")) {
       const name = /^\s*([A-Za-z0-9_.-]+)/.exec(line)?.[1];
@@ -38592,7 +38892,7 @@ function pythonSignals(dir, project) {
   return out;
 }
 function goSignals(dir, project) {
-  const mod = readText(join25(dir, "go.mod"));
+  const mod = readText(join27(dir, "go.mod"));
   if (!mod) return [];
   const out = [];
   const block = /require\s*\(([\s\S]*?)\)/g;
@@ -38789,8 +39089,8 @@ function localCandidates(root, dir, project, isRegistered) {
       why: "project readme and top-level guides"
     });
   for (const d of ["docs", "doc", "documentation"]) {
-    const abs = join25(dir, d);
-    if (!existsSync20(abs)) continue;
+    const abs = join27(dir, d);
+    if (!existsSync22(abs)) continue;
     const files = glob(abs, ["**/*.md", "**/*.mdx", "**/*.rst", "**/*.txt"]).filter(
       (f) => !SKIP_EXT.has(f.slice(f.lastIndexOf(".")))
     );
@@ -38813,8 +39113,8 @@ function localCandidates(root, dir, project, isRegistered) {
     "docs/decisions",
     "decisions"
   ]) {
-    const abs = join25(dir, d);
-    if (!existsSync20(abs)) continue;
+    const abs = join27(dir, d);
+    if (!existsSync22(abs)) continue;
     if (out.some((c) => c.path && rel(abs).startsWith(`${c.path}/`))) break;
     const files = glob(abs, ["**/*.md"]);
     push({
@@ -39611,7 +39911,7 @@ var init_category = __esm({
 });
 
 // src/docs/graph.ts
-import { existsSync as existsSync21, statSync as statSync9 } from "fs";
+import { existsSync as existsSync23, statSync as statSync9 } from "fs";
 import { dirname as dirname10, posix, relative as relative8, sep as sep2 } from "path";
 function manifestRel(ctx) {
   return relative8(ctx.root, manifestPath(ctx)).split(sep2).join("/");
@@ -39709,7 +40009,7 @@ function localDocPages(ctx, db) {
 }
 function stampOf(ctx, db) {
   const file3 = manifestPath(ctx);
-  const st = existsSync21(file3) ? statSync9(file3) : void 0;
+  const st = existsSync23(file3) ? statSync9(file3) : void 0;
   const counts = db.graphNodeCounts();
   const syncs = readManifest(ctx).sources.map((s) => syncState(db, s.name)?.at ?? 0).join(",");
   return `${st ? `${Math.floor(st.mtimeMs)}:${st.size}` : "none"}|${counts.file ?? 0}|${counts.package ?? 0}|${syncs}`;
@@ -40848,7 +41148,7 @@ function removeDocSource(ctx, db, name) {
   const removed = removeSource(ctx, name);
   const documents = db.deleteDocumentsBySource(docsTag(name));
   clearSyncState(db, name);
-  if (removed) syncDocsGraphQuietly(ctx, db);
+  if (removed || documents) syncDocsGraphQuietly(ctx, db);
   return { removed, documents };
 }
 function formatAdd(o) {
@@ -40903,7 +41203,8 @@ var init_add = __esm({
 var em_docs_exports = {};
 __export(em_docs_exports, {
   emDocs: () => emDocs,
-  formatDiscovery: () => formatDiscovery
+  formatDiscovery: () => formatDiscovery,
+  orphanedDocSources: () => orphanedDocSources
 });
 function toInput(a) {
   return {
@@ -40930,6 +41231,26 @@ function ago(ts) {
   if (s < 172800) return `${Math.round(s / 3600)}h ago`;
   return `${Math.round(s / 86400)}d ago`;
 }
+function orphanedDocSources(db, registered, stats = db.documentSourceStats(DOCS_PREFIX)) {
+  const known = new Set(registered);
+  const out = [];
+  for (const s of stats) {
+    const name = nameFromTag(s.source);
+    if (name === void 0 || known.has(name)) continue;
+    out.push({ name, documents: s.documents, chunks: s.chunks, latest: s.latest });
+  }
+  return out;
+}
+function formatOrphans(orphans2) {
+  const names = orphans2.map((o) => o.name);
+  return [
+    `# Orphaned in the index (${orphans2.length}; pages without a manifest entry)`,
+    ...orphans2.map(
+      (o) => `- ${o.name} \xB7 ${o.documents} doc(s) \xB7 ${o.chunks} chunks \xB7 indexed ${ago(o.latest)}`
+    ),
+    `em_docs {action:"remove", names:${JSON.stringify(names)}} drops them; {action:"add", pick:"recommended"} or {action:"add", name, url|path} re-registers.`
+  ];
+}
 function formatDiscovery(d, max = 40) {
   const lines = [];
   lines.push(
@@ -41112,19 +41433,30 @@ var init_em_docs = __esm({
             case "remove": {
               const names = [...args.name ? [args.name] : [], ...args.names ?? []];
               if (!names.length) return errorResult("remove needs `name` or `names`");
+              let unknown2 = 0;
               const lines = names.map((n) => {
                 const r = removeDocSource(ctx, db, n);
-                return r.removed ? `removed ${n} (${r.documents} document(s) dropped)` : `${n}: not registered${r.documents ? ` (${r.documents} orphan document(s) dropped)` : ""}`;
+                if (r.removed) return `removed ${n} (${r.documents} document(s) dropped)`;
+                if (r.documents) return `removed ${n} (orphaned; ${r.documents} document(s) dropped)`;
+                unknown2++;
+                return `${n}: not registered and not in the index; em_docs {action:"list"} shows both`;
               });
-              return done(lines.join("\n"));
+              const out = lines.join("\n");
+              return unknown2 === names.length ? errorResult(out) : done(out);
             }
             case "list": {
               const m = readManifest(ctx);
-              if (!m.sources.length)
-                return done(
-                  `no documentation sources registered (${manifestPath(ctx)}). em_docs {action:"discover"} finds local docs and the libraries, services and APIs this project uses.`
-                );
-              const stats = new Map(db.documentSourceStats(DOCS_PREFIX).map((s) => [s.source, s]));
+              const sourceStats = db.documentSourceStats(DOCS_PREFIX);
+              const orphans2 = orphanedDocSources(
+                db,
+                m.sources.map((s) => s.name),
+                sourceStats
+              );
+              if (!m.sources.length) {
+                const none = `no documentation sources registered (${manifestPath(ctx)}). em_docs {action:"discover"} finds local docs and the libraries, services and APIs this project uses.`;
+                return done(orphans2.length ? [none, "", ...formatOrphans(orphans2)].join("\n") : none);
+              }
+              const stats = new Map(sourceStats.map((s) => [s.source, s]));
               const catalog = mergedCatalog(ctx.config.docs.catalog);
               const categorised = m.sources.map((s) => ({
                 s,
@@ -41155,9 +41487,10 @@ var init_em_docs = __esm({
                   `- ${s.name} [${s.kind}]${s.provider ? ` \u2190 ${s.provider}` : ""}${s.tags?.length ? ` (${s.tags.join(", ")})` : ""} \xB7 ${st?.documents ?? 0} doc(s) \xB7 ${st?.chunks ?? 0} chunks \xB7 ${state} \xB7 ${where}`
                 );
               }
+              if (orphans2.length) lines.push("", ...formatOrphans(orphans2));
               lines.push(
                 "",
-                `${m.sources.length} source(s); em_docs {action:"lookup", query} searches them all, {action:"sync"} refreshes.`
+                `${m.sources.length} source(s)${orphans2.length ? ` + ${orphans2.length} orphaned` : ""}; em_docs {action:"lookup", query} searches them all, {action:"sync"} refreshes.`
               );
               return done(lines.join("\n"));
             }
@@ -41203,10 +41536,18 @@ ${r.urls.map((u) => `  ${u}`).join("\n")}
                 raw += r.hits.reduce((n, h) => n + h.chunk.body.length, 0);
                 responses.push(r);
               }
-              const out = formatResults(
-                responses,
-                args.max_tokens ?? ctx.config.search.defaultMaxTokens
+              let out = formatResults(responses, args.max_tokens ?? ctx.config.search.defaultMaxTokens);
+              const hitSources = new Set(
+                responses.flatMap((r) => r.hits.map((h) => h.chunk.document.source))
               );
+              const orphaned = orphanedDocSources(
+                db,
+                m.sources.map((s) => s.name)
+              ).filter((o) => hitSources.has(docsTag(o.name)));
+              if (orphaned.length)
+                out += `
+
+note: ${orphaned.map((o) => o.name).join(", ")} ${orphaned.length === 1 ? "is" : "are"} not in the manifest (orphaned pages); em_docs {action:"list"} explains`;
               recordStat(ctx, "em_docs", {
                 rawChars: raw,
                 returnedChars: out.length,
@@ -42467,6 +42808,9 @@ function memoriesForFile(db, rel, opts = {}) {
     trace
   };
 }
+function dependentFiles(db, paths2) {
+  return db.graphDependentFileCounts(paths2, DEPENDENCY_KINDS);
+}
 function riskLine(path3, f) {
   if (f.risk < RISKY && !f.bugOrigins) return void 0;
   const parts = [`${f.fixes}/${f.commits} commits were fixes`];
@@ -42494,10 +42838,10 @@ function fileContext(db, rel, opts = {}) {
   }
   const fanKey = `fanin:${rel}`;
   if (opts.edit && !seen.has(fanKey)) {
-    const fanIn = db.metricsGet([fileId(rel)])[0]?.fan_in ?? 0;
-    if (fanIn >= FAN_IN) {
+    const dependents = dependentFiles(db, [rel]).get(rel) ?? 0;
+    if (dependents >= FAN_IN) {
       lines.push(
-        `eminiar graph: ${rel} is imported by ${fanIn} files; em_graph_impact {node:"${fileId(rel)}"} lists them before you change an exported signature.`
+        `eminiar graph: ${rel} is imported by ${dependents} files; em_graph_impact {node:"${fileId(rel)}"} lists them before you change an exported signature.`
       );
       keys.push(fanKey);
     }
@@ -42554,6 +42898,7 @@ var init_recall = __esm({
     "use strict";
     init_esm_shims();
     init_ids();
+    init_metrics();
     init_model();
     init_pipeline();
     init_query();
@@ -44231,14 +44576,14 @@ __export(ingest_exports, {
   usageEnabled: () => usageEnabled
 });
 import { createHash as createHash4 } from "crypto";
-import { closeSync, existsSync as existsSync22, openSync, readdirSync as readdirSync8, readSync, statSync as statSync10 } from "fs";
-import { homedir as homedir3 } from "os";
-import { basename as basename2, dirname as dirname11, join as join26, resolve as resolve7, sep as sep3 } from "path";
+import { closeSync, existsSync as existsSync24, openSync, readdirSync as readdirSync9, readSync, statSync as statSync10 } from "fs";
+import { homedir as homedir4 } from "os";
+import { basename as basename2, dirname as dirname11, join as join28, resolve as resolve7, sep as sep3 } from "path";
 function isValidSessionId(id) {
   return SESSION_ID_RE.test(id);
 }
 function claudeDir2() {
-  return process.env.EMINIAR_CLAUDE_DIR || join26(homedir3(), ".claude");
+  return process.env.EMINIAR_CLAUDE_DIR || join28(homedir4(), ".claude");
 }
 function insideDir(path3, dir) {
   const d = resolve7(dir);
@@ -44257,7 +44602,7 @@ function transcriptSlug(root) {
   return root.replace(/[^A-Za-z0-9]/g, "-");
 }
 function transcriptDirFor(root) {
-  return join26(claudeDir2(), "projects", transcriptSlug(root));
+  return join28(claudeDir2(), "projects", transcriptSlug(root));
 }
 function usageEnabled(ctx) {
   return ctx.config.usage.enabled !== false;
@@ -44427,7 +44772,7 @@ function add(a, b) {
 }
 function listJsonl(dir) {
   try {
-    return readdirSync8(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join26(dir, f));
+    return readdirSync9(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join28(dir, f));
   } catch {
     return [];
   }
@@ -44447,7 +44792,7 @@ function firstEntrySessionId(path3) {
 function sidechainFilesFor(db, dir, sessionId) {
   if (!isValidSessionId(sessionId)) return [];
   const inside = (p) => insideDir(p, dir) && p.endsWith(".jsonl");
-  const out = listJsonl(join26(dir, sessionId, "subagents")).filter(inside);
+  const out = listJsonl(join28(dir, sessionId, "subagents")).filter(inside);
   for (const path3 of listJsonl(dir)) {
     if (!inside(path3) || !basename2(path3).startsWith("agent-")) continue;
     const known = db.transcriptFileGet(path3)?.session_id;
@@ -44491,11 +44836,11 @@ function ingestSession(db, root, sessionId, transcriptPath, opts = {}) {
 function ingestProject(db, root, opts = {}) {
   const dir = transcriptDirFor(root);
   const files = new Set(listJsonl(dir));
-  if (existsSync22(dir)) {
+  if (existsSync24(dir)) {
     try {
-      for (const entry of readdirSync8(dir, { withFileTypes: true })) {
+      for (const entry of readdirSync9(dir, { withFileTypes: true })) {
         if (entry.isDirectory())
-          for (const sub of listJsonl(join26(dir, entry.name, "subagents"))) files.add(sub);
+          for (const sub of listJsonl(join28(dir, entry.name, "subagents"))) files.add(sub);
       }
     } catch {
     }
@@ -44546,12 +44891,17 @@ function usageLine(ctx, sessionId) {
   if (!usageEnabled(ctx)) return void 0;
   try {
     const db = getStorage(ctx);
-    ingestSession(db, ctx.root, sessionId, void 0, { overrides: ctx.config.usage.pricing });
+    let failed;
+    try {
+      ingestSession(db, ctx.root, sessionId, void 0, { overrides: ctx.config.usage.pricing });
+    } catch (err) {
+      failed = `usage: ingest failed: ${err.message}`;
+    }
     const b = usageBrief(db, ctx, { sessionId });
-    if (!b.todayUsd && !b.sessionUsd) return void 0;
-    return `usage: today ${formatUsd(b.todayUsd)} \xB7 session ${formatUsd(b.sessionUsd)} \xB7 see em_usage`;
-  } catch {
-    return void 0;
+    const line = b.todayUsd || b.sessionUsd ? `usage: today ${formatUsd(b.todayUsd)} \xB7 session ${formatUsd(b.sessionUsd)} \xB7 see em_usage` : void 0;
+    return [line, failed].filter((s) => s).join("\n") || void 0;
+  } catch (err) {
+    return `usage: unavailable: ${err.message}`;
   }
 }
 function mergeByTool(rows) {
@@ -45825,7 +46175,10 @@ var init_em_search = __esm({
           }
         }
         const out = formatResults(responses, args.max_tokens ?? ctx.config.search.defaultMaxTokens);
-        const note = mode !== "lexical" && mode !== "regex" && !vectorSearch && ctx.config.embeddings.enabled ? "\n\n(embeddings: model still loading \u2014 lexical results only this time)" : "";
+        let note = mode !== "lexical" && mode !== "regex" && !vectorSearch && ctx.config.embeddings.enabled ? "\n\n(embeddings: model still loading \u2014 lexical results only this time)" : "";
+        const sources = Array.isArray(args.source) ? args.source : args.source ? [args.source] : [];
+        if (mode === "semantic" && !ctx.config.docs.embed && sources.some((s) => s.startsWith("docs:")) && responses.every((r) => r.hits.length === 0))
+          note += '\n\n(docs:* pages are indexed without vectors because docs.embed is off; use mode "hybrid" or "lexical", or set docs.embed: true in eminiar.config.json and em_docs {action:"sync", force:true})';
         recordStat(ctx, "em_search", {
           rawChars: responses.reduce(
             (a, r) => a + r.hits.reduce((b, h) => b + h.chunk.body.length, 0),
@@ -45841,14 +46194,14 @@ var init_em_search = __esm({
 });
 
 // src/ui/api.ts
-import { existsSync as existsSync23, readdirSync as readdirSync9 } from "fs";
-import { join as join27, relative as relative9 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync10 } from "fs";
+import { join as join29, relative as relative9 } from "path";
 function listProjects() {
   const dir = paths().projects;
   const out = [];
-  for (const id of readdirSync9(dir, { withFileTypes: true })) {
+  for (const id of readdirSync10(dir, { withFileTypes: true })) {
     if (!id.isDirectory()) continue;
-    const db = join27(dir, id.name, "eminiar.db");
+    const db = join29(dir, id.name, "eminiar.db");
     try {
       const a = new SqliteAdapter(db, { vectors: false });
       out.push({ id: id.name, root: a.sessionLatest()?.project_root ?? null });
@@ -45874,8 +46227,8 @@ function statsPayload(ctx) {
   const db = getStorage(ctx);
   const sessionId = getCurrentSession(ctx);
   const g = globalDb();
-  const onboardingDir = join27(memoriesDir(ctx), "onboarding");
-  const onboarding = existsSync23(onboardingDir) ? readdirSync9(onboardingDir).filter((f) => f.endsWith(".md")).map((f) => f.slice(0, -3)) : [];
+  const onboardingDir = join29(memoriesDir(ctx), "onboarding");
+  const onboarding = existsSync25(onboardingDir) ? readdirSync10(onboardingDir).filter((f) => f.endsWith(".md")).map((f) => f.slice(0, -3)) : [];
   return {
     project: ctx.root,
     projectId: ctx.id,
@@ -46477,8 +46830,8 @@ var init_namepath = __esm({
 });
 
 // src/code/symbols.ts
-import { existsSync as existsSync24, readFileSync as readFileSync20 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync22 } from "fs";
+import { join as join30 } from "path";
 function isExported2(n) {
   if (!n.meta) return false;
   try {
@@ -46514,7 +46867,7 @@ var init_symbols2 = __esm({
 });
 
 // src/ui/graph-api.ts
-import { readFileSync as readFileSync21, realpathSync as realpathSync2, statSync as statSync11 } from "fs";
+import { readFileSync as readFileSync23, realpathSync as realpathSync2, statSync as statSync11 } from "fs";
 import { relative as relative10, resolve as resolve8 } from "path";
 function metaOf2(row) {
   if (!row?.meta) return {};
@@ -46600,7 +46953,7 @@ function filePayload(ctx, rel) {
   }));
   if (st.size > MAX_CODE_BYTES)
     return { path: clean, tooLarge: true, size: st.size, status: row?.status ?? null, symbols };
-  const content = readFileSync21(real, "utf8");
+  const content = readFileSync23(real, "utf8");
   return {
     path: clean,
     size: st.size,
@@ -47286,8 +47639,8 @@ var init_lineage = __esm({
 });
 
 // src/ui/history-graph-api.ts
-import { existsSync as existsSync25 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync27 } from "fs";
+import { join as join31 } from "path";
 function parseList(raw) {
   if (!raw) return [];
   try {
@@ -47526,7 +47879,7 @@ function buildHistoryGraph(ctx, db, m, opts = {}) {
       path: p,
       line: null,
       root: id === focusId,
-      missing: existsSync25(join29(ctx.root, p)) ? void 0 : true,
+      missing: existsSync27(join31(ctx.root, p)) ? void 0 : true,
       risk: h?.risk,
       fixes: h?.fixes
     });
@@ -47885,9 +48238,9 @@ __export(server_exports, {
   uiDir: () => uiDir
 });
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync22, statSync as statSync12 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync24, statSync as statSync12 } from "fs";
 import { createServer } from "http";
-import { extname as extname3, join as join30, normalize as normalize6 } from "path";
+import { extname as extname3, join as join32, normalize as normalize6 } from "path";
 import { URL as URL2 } from "url";
 function json2(res, status, body) {
   res.writeHead(status, {
@@ -47909,7 +48262,7 @@ function strList(v) {
   return void 0;
 }
 function uiDir() {
-  return process.env.EMINIAR_UI_DIR || join30(pluginRoot(), "dist", "ui");
+  return process.env.EMINIAR_UI_DIR || join32(pluginRoot(), "dist", "ui");
 }
 function originAllowed(req, port) {
   const host = req.headers.host ?? "";
@@ -47933,25 +48286,25 @@ function originAllowed(req, port) {
 function serveStatic(res, p) {
   const dir = uiDir();
   const rel = p === "/" ? "index.html" : p.replace(/^\/+/, "");
-  const file3 = normalize6(join30(dir, rel));
+  const file3 = normalize6(join32(dir, rel));
   if (!file3.startsWith(normalize6(dir))) return false;
-  if (!existsSync26(file3) || !statSync12(file3).isFile()) return false;
+  if (!existsSync28(file3) || !statSync12(file3).isFile()) return false;
   const type = MIME[extname3(file3).toLowerCase()] ?? "application/octet-stream";
   if (rel === "index.html") {
     const stamp = (name) => {
       try {
-        return `/${name}?v=${Math.floor(statSync12(join30(dir, name)).mtimeMs)}`;
+        return `/${name}?v=${Math.floor(statSync12(join32(dir, name)).mtimeMs)}`;
       } catch {
         return `/${name}`;
       }
     };
-    const html = readFileSync22(file3, "utf8").replace('"/app.global.js"', `"${stamp("app.global.js")}"`).replace('"/styles.css"', `"${stamp("styles.css")}"`);
+    const html = readFileSync24(file3, "utf8").replace('"/app.global.js"', `"${stamp("app.global.js")}"`).replace('"/styles.css"', `"${stamp("styles.css")}"`);
     res.writeHead(200, { "content-type": type, "cache-control": "no-store" });
     res.end(html);
     return true;
   }
   res.writeHead(200, { "content-type": type, "cache-control": "no-cache" });
-  res.end(readFileSync22(file3));
+  res.end(readFileSync24(file3));
   return true;
 }
 async function serve(opts) {
@@ -48390,7 +48743,7 @@ __export(statusline_exports, {
   renderStatusline: () => renderStatusline,
   usageSegments: () => usageSegments
 });
-import { existsSync as existsSync27, readFileSync as readFileSync23, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync25, writeFileSync as writeFileSync10 } from "fs";
 function epochMs(v) {
   if (typeof v === "number" && Number.isFinite(v)) return v < 1e12 ? v * 1e3 : v;
   if (typeof v === "string") {
@@ -48452,8 +48805,8 @@ function renderStatusline(raw) {
   const key = cacheKey(input2);
   const cache3 = paths().statuslineCache;
   try {
-    if (existsSync27(cache3)) {
-      const c = JSON.parse(readFileSync23(cache3, "utf8"));
+    if (existsSync29(cache3)) {
+      const c = JSON.parse(readFileSync25(cache3, "utf8"));
       if (Date.now() - c.at < CACHE_TTL_MS && c.key === key) return c.line;
     }
   } catch {
@@ -48484,7 +48837,7 @@ function renderStatusline(raw) {
     line = `eminiar \xB7 unavailable (${err.message.slice(0, 40)})`;
   }
   try {
-    writeFileSync9(cache3, JSON.stringify({ at: Date.now(), line, key }));
+    writeFileSync10(cache3, JSON.stringify({ at: Date.now(), line, key }));
   } catch {
   }
   return line;
@@ -48518,9 +48871,11 @@ var USAGE = `eminiar v${version2()} \u2014 local-first context, memory & knowled
 Usage: eminiar <command> [options]
 
 Setup
-  install [--no-model] [--method plugin|settings] [--team] [--yes] [--force]   Install into Claude Code
+  install [--no-model] [--method plugin|settings] [--cursor] [--team] [--yes] [--force]
+                               Install into Claude Code; --cursor also registers with Cursor
+                               (hooks, MCP server, skills under ~/.cursor)
   upgrade                      Update to the latest version and re-register
-  uninstall [--purge-data]     Remove from Claude Code (data kept unless --purge-data)
+  uninstall [--purge-data]     Remove from Claude Code and Cursor (data kept unless --purge-data)
   doctor [--json] [--fix]      Check installation health; --fix re-pins node/root and clears
                                Claude Code's cached launch failure
   replace-context-mode [--yes] Remove the context-mode plugin after parity sign-off
@@ -48548,7 +48903,7 @@ Use
   ui [--port 7331] [--no-open] Web dashboard: stats, memories, graph, search, sessions, actions
                                (alias: serve)
   statusline                   Claude Code statusLine command (reads JSON on stdin)
-  hook [--event E]             Run the hook handler manually (reads JSON on stdin)
+  hook [--event E] [--client claude|cursor]   Run the hook handler manually (reads JSON on stdin)
   version | help
 `;
 function text2(r) {
@@ -48578,6 +48933,7 @@ var commands = {
         node: { type: "string" },
         yes: { type: "boolean" },
         statusline: { type: "boolean" },
+        cursor: { type: "boolean" },
         force: { type: "boolean" }
       },
       strict: false
@@ -48585,6 +48941,7 @@ var commands = {
     const { install: install2 } = await Promise.resolve().then(() => (init_install(), install_exports));
     return install2({
       force: !!values.force,
+      cursor: !!values.cursor,
       noModel: !!values["no-model"],
       method: values.method === "settings" ? "settings" : values.method === "plugin" ? "plugin" : void 0,
       team: !!values.team,
@@ -49037,7 +49394,8 @@ try {
 } catch (err) {
   console.error(`eminiar ${cmd} failed: ${err.message}`);
   if (process.env.EMINIAR_DEBUG) console.error(err.stack);
-  if (cmd !== "doctor") console.error(formatDoctor(runDoctor()));
+  if (cmd === "usage") console.error("run `eminiar doctor` to check the installation");
+  else if (cmd !== "doctor") console.error(formatDoctor(runDoctor()));
   process.exit(1);
 }
 /*! Bundled license information: