@openez-graph/cli 0.11.0 → 0.12.0

package/dist/cli.cjs

@@ -2912,7 +2912,7 @@ var require_command = __commonJS({
     var EventEmitter2 = require("events").EventEmitter;
     var childProcess = require("child_process");
     var path24 = require("path");
-    var fs22 = require("fs");
+    var fs23 = require("fs");
     var process3 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -3906,7 +3906,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs22.existsSync(executableFile)) return;
+        if (fs23.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -3925,10 +3925,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path24.resolve(baseDir, baseName);
-          if (fs22.existsSync(localBin)) return localBin;
+          if (fs23.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path24.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs22.existsSync(`${localBin}${ext}`)
+            (ext) => fs23.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -3940,7 +3940,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs22.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs23.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
@@ -11528,6 +11528,8 @@ var init_schema = __esm({
         nodeCount: integer("node_count").notNull().default(0),
         edgeCount: integer("edge_count").notNull().default(0),
         lastError: text("last_error"),
+        pinnedAt: text("pinned_at"),
+        pinOrder: integer("pin_order"),
         createdAt: text("created_at").notNull().default(sql`(datetime('now'))`),
         updatedAt: text("updated_at").notNull().default(sql`(datetime('now'))`)
       },
@@ -11724,9 +11726,11 @@ function getRegistryDb() {
       const sqlite = createNativeDatabase(dbPath);
       sqlite.pragma("journal_mode = WAL");
       sqlite.pragma("foreign_keys = ON");
-      registryDb = drizzle(sqlite, { schema: schema_exports });
+      const db = drizzle(sqlite, { schema: schema_exports });
       initializeRegistrySchema(sqlite);
+      registryDb = db;
     } catch (err) {
+      registryDb = null;
       const message = err instanceof Error ? err.message : String(err);
       throw new Error(`Failed to open registry DB at "${dbPath}": ${message}`);
     }
@@ -11751,6 +11755,7 @@ function initializeRegistrySchema(sqlite) {
       node_count INTEGER NOT NULL DEFAULT 0,
       edge_count INTEGER NOT NULL DEFAULT 0,
       last_error TEXT,
+      pinned_at TEXT,
       created_at TEXT NOT NULL DEFAULT (datetime('now')),
       updated_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
@@ -11764,6 +11769,38 @@ function initializeRegistrySchema(sqlite) {
       updated_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
   `);
+  migrateRegistryColumns(sqlite);
+}
+function migrateRegistryColumns(sqlite) {
+  const getColumns = () => new Set(
+    sqlite.prepare("PRAGMA table_info(workspaces)").all().map(
+      (row) => row.name
+    )
+  );
+  const addColumnIfMissing = (name, definition) => {
+    if (getColumns().has(name)) return;
+    try {
+      sqlite.exec(`ALTER TABLE workspaces ADD COLUMN ${definition}`);
+    } catch (err) {
+      if (!getColumns().has(name)) {
+        throw err;
+      }
+    }
+  };
+  addColumnIfMissing("pinned_at", "pinned_at TEXT");
+  addColumnIfMissing("pin_order", "pin_order INTEGER");
+  const unbackfilled = sqlite.prepare(
+    "SELECT id FROM workspaces WHERE pinned_at IS NOT NULL AND pin_order IS NULL ORDER BY pinned_at DESC"
+  ).all();
+  if (unbackfilled.length > 0) {
+    const maxRow = sqlite.prepare("SELECT MAX(pin_order) AS max_order FROM workspaces WHERE pin_order IS NOT NULL").get();
+    let next = (maxRow?.max_order ?? 0) + 1;
+    const stmt = sqlite.prepare("UPDATE workspaces SET pin_order = ? WHERE id = ?");
+    for (const row of unbackfilled) {
+      stmt.run(next, row.id);
+      next += 1;
+    }
+  }
 }
 var import_node_fs2, import_node_os, import_node_path3, registryDb;
 var init_registry_db = __esm({
@@ -11796,8 +11833,20 @@ function getWorkspaceDb(rootPath) {
   const db = drizzle(sqlite, { schema: schema_exports });
   initializeWorkspaceSchema(sqlite);
   dbCache.set(rootPath, db);
+  nativeCache.set(rootPath, sqlite);
   return db;
 }
+function closeWorkspaceDb(rootPath) {
+  const native = nativeCache.get(rootPath);
+  if (native) {
+    try {
+      native.close();
+    } catch {
+    }
+    nativeCache.delete(rootPath);
+  }
+  dbCache.delete(rootPath);
+}
 function initializeWorkspaceSchema(sqlite) {
   const tables = getWorkspaceTableDefinitions();
   for (const ddl of tables) {
@@ -12045,7 +12094,7 @@ function getWorkspaceTableDefinitions() {
     )`
   ];
 }
-var import_node_fs3, import_node_path4, WORKSPACE_DB_DIR_NAME, WORKSPACE_DB_FILE_NAME, dbCache;
+var import_node_fs3, import_node_path4, WORKSPACE_DB_DIR_NAME, WORKSPACE_DB_FILE_NAME, dbCache, nativeCache;
 var init_workspace_db = __esm({
   "../../packages/db/src/sqlite/workspace-db.ts"() {
     "use strict";
@@ -12057,6 +12106,7 @@ var init_workspace_db = __esm({
     WORKSPACE_DB_DIR_NAME = ".openez";
     WORKSPACE_DB_FILE_NAME = "index.sqlite";
     dbCache = /* @__PURE__ */ new Map();
+    nativeCache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -12181,7 +12231,7 @@ function createRegistryRepository() {
   return {
     async listWorkspaces() {
       const rows = db.select().from(workspaces).all();
-      return rows.map(mapWorkspaceRow);
+      return rows.map(mapWorkspaceRow).sort(compareWorkspaces);
     },
     async getWorkspace(id) {
       const row = db.select().from(workspaces).where(eq(workspaces.id, id)).get();
@@ -12291,6 +12341,15 @@ function createRegistryRepository() {
     async deleteWorkspace(id) {
       db.delete(workspaces).where(eq(workspaces.id, id)).run();
     },
+    async setPinned(id, pinned) {
+      if (pinned) {
+        const maxRow = native.prepare("SELECT MAX(pin_order) AS max_order FROM workspaces WHERE pin_order IS NOT NULL").get();
+        const nextOrder = (maxRow?.max_order ?? 0) + 1;
+        native.prepare("UPDATE workspaces SET pinned_at = ?, pin_order = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), nextOrder, id);
+      } else {
+        native.prepare("UPDATE workspaces SET pinned_at = NULL, pin_order = NULL WHERE id = ?").run(id);
+      }
+    },
     async getSetting(key) {
       const row = native.prepare("SELECT value FROM settings WHERE key = ?").get(key);
       if (!row) return null;
@@ -12348,10 +12407,23 @@ function mapWorkspaceRow(row) {
     nodeCount: row.nodeCount,
     edgeCount: row.edgeCount,
     lastError: row.lastError ?? void 0,
+    pinnedAt: row.pinnedAt ?? void 0,
+    pinOrder: row.pinOrder ?? void 0,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt
   };
 }
+function compareWorkspaces(a, b) {
+  if (a.pinnedAt && !b.pinnedAt) return -1;
+  if (!a.pinnedAt && b.pinnedAt) return 1;
+  if (a.pinnedAt && b.pinnedAt) {
+    const aOrder = a.pinOrder ?? -Infinity;
+    const bOrder = b.pinOrder ?? -Infinity;
+    if (aOrder !== bOrder) return bOrder - aOrder;
+    if (a.pinnedAt !== b.pinnedAt) return b.pinnedAt.localeCompare(a.pinnedAt);
+  }
+  return b.createdAt.localeCompare(a.createdAt);
+}
 function getNativeWorkspaceDb(rootPath) {
   const db = getWorkspaceDb(rootPath);
   const native = db.$client;
@@ -12594,6 +12666,36 @@ function createWorkspaceRepository(rootPath) {
       }
       return ids;
     },
+    async upsertGraphNodesBatch(inputs) {
+      if (inputs.length === 0) return [];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const BATCH = 500;
+      const results = [];
+      for (let i = 0; i < inputs.length; i += BATCH) {
+        const batch = inputs.slice(i, i + BATCH);
+        const placeholders = batch.map(() => "(?, ?, ?, ?, ?, ?, ?)").join(",");
+        const params = [];
+        for (const item of batch) {
+          const id = import_node_crypto2.default.randomUUID();
+          params.push(
+            id,
+            item.type,
+            item.label,
+            item.refId ?? null,
+            item.metadata ?? "{}",
+            now,
+            now
+          );
+        }
+        const rows = native.prepare(
+          `INSERT INTO graph_nodes (id, type, label, ref_id, metadata, created_at, updated_at) VALUES ${placeholders}
+             ON CONFLICT(type, label) WHERE type != 'symbol' DO UPDATE SET ref_id = COALESCE(excluded.ref_id, graph_nodes.ref_id), metadata = excluded.metadata, updated_at = excluded.updated_at
+             RETURNING id, label`
+        ).all(...params);
+        results.push(...rows.map((r) => ({ label: r.label, id: String(r.id) })));
+      }
+      return results;
+    },
     async getGraphNode(id) {
       const row = native.prepare("SELECT * FROM graph_nodes WHERE id = ?").get(id);
       return row ? mapNodeRow(row) : null;
@@ -13193,6 +13295,93 @@ var init_local_workspace = __esm({
   }
 });
 
+// ../../packages/db/src/sqlite/remove-workspace.ts
+async function pathExists(target) {
+  try {
+    await import_promises5.default.stat(target);
+    return true;
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return false;
+    }
+    throw err;
+  }
+}
+async function removeWorkspace(selector) {
+  const repo = createRegistryRepository();
+  const workspace = selector.id ? await repo.getWorkspace(selector.id) : selector.rootPath ? await repo.getWorkspaceByPath(selector.rootPath) : null;
+  if (!workspace) return null;
+  const warnings = [];
+  if (workspace.indexingStatus === "running" || workspace.graphStatus === "running") {
+    warnings.push(
+      "Workspace appears to be indexing or building its graph; stop the process first to avoid stale writes."
+    );
+  }
+  const dataDirPath = getLocalWorkspaceDir(workspace.rootPath);
+  let dataDirRemoved = false;
+  let rootPathExists = null;
+  try {
+    rootPathExists = await pathExists(workspace.rootPath);
+    if (!rootPathExists) {
+      warnings.push(`Workspace root path does not exist on disk: ${workspace.rootPath}`);
+    } else {
+      closeWorkspaceDb(workspace.rootPath);
+      try {
+        await import_promises5.default.rm(dataDirPath, { recursive: true, force: true });
+        dataDirRemoved = !await pathExists(dataDirPath);
+      } catch (err) {
+        dataDirRemoved = false;
+        warnings.push(
+          `Failed to delete ${dataDirPath}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  } catch (err) {
+    warnings.push(
+      `Could not check workspace root path ${workspace.rootPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  let unregistered = false;
+  let rootPathAbsent = false;
+  if (rootPathExists === false) {
+    rootPathAbsent = true;
+  } else if (rootPathExists === true) {
+    try {
+      rootPathAbsent = !await pathExists(workspace.rootPath);
+    } catch (err) {
+      warnings.push(
+        `Could not re-check workspace root path ${workspace.rootPath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  if (dataDirRemoved || rootPathAbsent) {
+    await repo.deleteWorkspace(workspace.id);
+    unregistered = true;
+  } else {
+    warnings.push(
+      "Workspace was not unregistered because the data directory could not be removed. Retry to attempt cleanup again."
+    );
+  }
+  return {
+    workspaceId: workspace.id,
+    rootPath: workspace.rootPath,
+    unregistered,
+    dataDirRemoved,
+    dataDirPath,
+    warnings
+  };
+}
+var import_promises5;
+var init_remove_workspace = __esm({
+  "../../packages/db/src/sqlite/remove-workspace.ts"() {
+    "use strict";
+    import_promises5 = __toESM(require("fs/promises"), 1);
+    init_local_workspace();
+    init_repository();
+    init_workspace_db();
+  }
+});
+
 // ../../packages/db/src/sqlite/index.ts
 var init_sqlite = __esm({
   "../../packages/db/src/sqlite/index.ts"() {
@@ -13202,6 +13391,7 @@ var init_sqlite = __esm({
     init_repository();
     init_secure_storage();
     init_local_workspace();
+    init_remove_workspace();
     init_schema();
   }
 });
@@ -13286,7 +13476,7 @@ var require_package = __commonJS({
 var require_main = __commonJS({
   "../../node_modules/.pnpm/dotenv@16.6.1/node_modules/dotenv/lib/main.js"(exports2, module4) {
     "use strict";
-    var fs22 = require("fs");
+    var fs23 = require("fs");
     var path24 = require("path");
     var os9 = require("os");
     var crypto4 = require("crypto");
@@ -13395,7 +13585,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs22.existsSync(filepath)) {
+            if (fs23.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -13405,7 +13595,7 @@ var require_main = __commonJS({
       } else {
         possibleVaultPath = path24.resolve(process.cwd(), ".env.vault");
       }
-      if (fs22.existsSync(possibleVaultPath)) {
+      if (fs23.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
@@ -13454,7 +13644,7 @@ var require_main = __commonJS({
       const parsedAll = {};
       for (const path25 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs22.readFileSync(path25, { encoding }));
+          const parsed = DotenvModule.parse(fs23.readFileSync(path25, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
@@ -17796,7 +17986,7 @@ async function loadBrainConfig(startDir = process.cwd()) {
       retrieval: defaults3.retrieval
     };
   }
-  const source = await import_promises5.default.readFile(configFile, "utf8");
+  const source = await import_promises6.default.readFile(configFile, "utf8");
   const sanitized = source.replace(/^import\s+type\s+.*$/gm, "").replace(/^import\s+.*$/gm, "").replace(/const\s+config\s*:\s*[^=]+=/m, "const config =").replace(/export default\s+/m, "const __default__ = ");
   const evaluator = new Function(
     `${sanitized}
@@ -17824,11 +18014,11 @@ async function getBrainSettings(startDir = process.cwd()) {
     retrieval: config2.retrieval ?? defaults2.retrieval
   };
 }
-var import_promises5, import_node_path9, import_node_fs7, CONFIG_FILE_CANDIDATES;
+var import_promises6, import_node_path9, import_node_fs7, CONFIG_FILE_CANDIDATES;
 var init_load_brain_config = __esm({
   "../../packages/config/src/load-brain-config.ts"() {
     "use strict";
-    import_promises5 = __toESM(require("fs/promises"), 1);
+    import_promises6 = __toESM(require("fs/promises"), 1);
     import_node_path9 = __toESM(require("path"), 1);
     import_node_fs7 = require("fs");
     init_types2();
@@ -30293,13 +30483,7 @@ function walkTree(root, config2, lines) {
           endLine: endRow,
           ...receiver ? { receiver } : {}
         });
-        extractCallsInNode(
-          node,
-          config2,
-          fullName,
-          calledIdentifiers,
-          callExpressions
-        );
+        extractCallsInNode(node, config2, fullName, calledIdentifiers, callExpressions);
         const isContextNode = symbolRule.establishesContext || config2.contextNodeTypes.has(node.type);
         if (isContextNode) {
           const contextName = symbolRule.extractContextName ? symbolRule.extractContextName(node) ?? fullName : fullName;
@@ -30324,9 +30508,7 @@ function walkTree(root, config2, lines) {
 }
 function extractCallsInNode(symbolNode, config2, callerName, calledIdentifiers, callExpressions) {
   const nestedSymbolTypes = config2.symbolRules.map((r) => r.nodeType);
-  const nestedSymbols = symbolNode.descendantsOfType(nestedSymbolTypes).filter(
-    (n) => !(n.startIndex === symbolNode.startIndex && n.endIndex === symbolNode.endIndex)
-  );
+  const nestedSymbols = symbolNode.descendantsOfType(nestedSymbolTypes).filter((n) => !(n.startIndex === symbolNode.startIndex && n.endIndex === symbolNode.endIndex));
   const callNodes = symbolNode.descendantsOfType(config2.callRule.nodeType);
   for (const callNode of callNodes) {
     const insideNested = nestedSymbols.some(
@@ -32613,11 +32795,11 @@ var require_source_map_support = __commonJS({
     "use strict";
     var SourceMapConsumer = require_source_map().SourceMapConsumer;
     var path24 = require("path");
-    var fs22;
+    var fs23;
     try {
-      fs22 = require("fs");
-      if (!fs22.existsSync || !fs22.readFileSync) {
-        fs22 = null;
+      fs23 = require("fs");
+      if (!fs23.existsSync || !fs23.readFileSync) {
+        fs23 = null;
       }
     } catch (err) {
     }
@@ -32688,7 +32870,7 @@ var require_source_map_support = __commonJS({
       }
       var contents = "";
       try {
-        if (!fs22) {
+        if (!fs23) {
           var xhr = new XMLHttpRequest();
           xhr.open(
             "GET",
@@ -32700,8 +32882,8 @@ var require_source_map_support = __commonJS({
           if (xhr.readyState === 4 && xhr.status === 200) {
             contents = xhr.responseText;
           }
-        } else if (fs22.existsSync(path25)) {
-          contents = fs22.readFileSync(path25, "utf8");
+        } else if (fs23.existsSync(path25)) {
+          contents = fs23.readFileSync(path25, "utf8");
         }
       } catch (er) {
       }
@@ -32965,9 +33147,9 @@ var require_source_map_support = __commonJS({
         var line = +match2[2];
         var column = +match2[3];
         var contents = fileContentsCache[source];
-        if (!contents && fs22 && fs22.existsSync(source)) {
+        if (!contents && fs23 && fs23.existsSync(source)) {
           try {
-            contents = fs22.readFileSync(source, "utf8");
+            contents = fs23.readFileSync(source, "utf8");
           } catch (er) {
             contents = "";
           }
@@ -36739,10 +36921,10 @@ var require_typescript = __commonJS({
       function and2(f, g2) {
         return (arg) => f(arg) && g2(arg);
       }
-      function or2(...fs22) {
+      function or2(...fs23) {
         return (...args) => {
           let lastResult;
-          for (const f of fs22) {
+          for (const f of fs23) {
             lastResult = f(...args);
             if (lastResult) {
               return lastResult;
@@ -38317,7 +38499,7 @@ ${lanes.join("\n")}
       var tracing;
       var tracingEnabled;
       ((tracingEnabled2) => {
-        let fs22;
+        let fs23;
         let traceCount = 0;
         let traceFd = 0;
         let mode;
@@ -38326,9 +38508,9 @@ ${lanes.join("\n")}
         const legend = [];
         function startTracing2(tracingMode, traceDir, configFilePath) {
           Debug.assert(!tracing, "Tracing already started");
-          if (fs22 === void 0) {
+          if (fs23 === void 0) {
             try {
-              fs22 = require("fs");
+              fs23 = require("fs");
             } catch (e) {
               throw new Error(`tracing requires having fs
 (original error: ${e.message || e})`);
@@ -38339,8 +38521,8 @@ ${lanes.join("\n")}
           if (legendPath === void 0) {
             legendPath = combinePaths(traceDir, "legend.json");
           }
-          if (!fs22.existsSync(traceDir)) {
-            fs22.mkdirSync(traceDir, { recursive: true });
+          if (!fs23.existsSync(traceDir)) {
+            fs23.mkdirSync(traceDir, { recursive: true });
           }
           const countPart = mode === "build" ? `.${process.pid}-${++traceCount}` : mode === "server" ? `.${process.pid}` : ``;
           const tracePath = combinePaths(traceDir, `trace${countPart}.json`);
@@ -38350,10 +38532,10 @@ ${lanes.join("\n")}
             tracePath,
             typesPath
           });
-          traceFd = fs22.openSync(tracePath, "w");
+          traceFd = fs23.openSync(tracePath, "w");
           tracing = tracingEnabled2;
           const meta = { cat: "__metadata", ph: "M", ts: 1e3 * timestamp(), pid: 1, tid: 1 };
-          fs22.writeSync(
+          fs23.writeSync(
             traceFd,
             "[\n" + [{ name: "process_name", args: { name: "tsc" }, ...meta }, { name: "thread_name", args: { name: "Main" }, ...meta }, { name: "TracingStartedInBrowser", ...meta, cat: "disabled-by-default-devtools.timeline" }].map((v) => JSON.stringify(v)).join(",\n")
           );
@@ -38362,10 +38544,10 @@ ${lanes.join("\n")}
         function stopTracing() {
           Debug.assert(tracing, "Tracing is not in progress");
           Debug.assert(!!typeCatalog.length === (mode !== "server"));
-          fs22.writeSync(traceFd, `
+          fs23.writeSync(traceFd, `
 ]
 `);
-          fs22.closeSync(traceFd);
+          fs23.closeSync(traceFd);
           tracing = void 0;
           if (typeCatalog.length) {
             dumpTypes(typeCatalog);
@@ -38437,11 +38619,11 @@ ${lanes.join("\n")}
         function writeEvent(eventType, phase, name, args, extras, time3 = 1e3 * timestamp()) {
           if (mode === "server" && phase === "checkTypes") return;
           mark("beginTracing");
-          fs22.writeSync(traceFd, `,
+          fs23.writeSync(traceFd, `,
 {"pid":1,"tid":1,"ph":"${eventType}","cat":"${phase}","ts":${time3},"name":"${name}"`);
-          if (extras) fs22.writeSync(traceFd, `,${extras}`);
-          if (args) fs22.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
-          fs22.writeSync(traceFd, `}`);
+          if (extras) fs23.writeSync(traceFd, `,${extras}`);
+          if (args) fs23.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
+          fs23.writeSync(traceFd, `}`);
           mark("endTracing");
           measure("Tracing", "beginTracing", "endTracing");
         }
@@ -38463,9 +38645,9 @@ ${lanes.join("\n")}
           var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
           mark("beginDumpTypes");
           const typesPath = legend[legend.length - 1].typesPath;
-          const typesFd = fs22.openSync(typesPath, "w");
+          const typesFd = fs23.openSync(typesPath, "w");
           const recursionIdentityMap = /* @__PURE__ */ new Map();
-          fs22.writeSync(typesFd, "[");
+          fs23.writeSync(typesFd, "[");
           const numTypes = types.length;
           for (let i = 0; i < numTypes; i++) {
             const type = types[i];
@@ -38561,13 +38743,13 @@ ${lanes.join("\n")}
               flags: Debug.formatTypeFlags(type.flags).split("|"),
               display
             };
-            fs22.writeSync(typesFd, JSON.stringify(descriptor));
+            fs23.writeSync(typesFd, JSON.stringify(descriptor));
             if (i < numTypes - 1) {
-              fs22.writeSync(typesFd, ",\n");
+              fs23.writeSync(typesFd, ",\n");
             }
           }
-          fs22.writeSync(typesFd, "]\n");
-          fs22.closeSync(typesFd);
+          fs23.writeSync(typesFd, "]\n");
+          fs23.closeSync(typesFd);
           mark("endDumpTypes");
           measure("Dump types", "beginDumpTypes", "endDumpTypes");
         }
@@ -38575,7 +38757,7 @@ ${lanes.join("\n")}
           if (!legendPath) {
             return;
           }
-          fs22.writeFileSync(legendPath, JSON.stringify(legend));
+          fs23.writeFileSync(legendPath, JSON.stringify(legend));
         }
         tracingEnabled2.dumpLegend = dumpLegend;
       })(tracingEnabled || (tracingEnabled = {}));
@@ -248696,7 +248878,7 @@ var require_dist = __commonJS({
       enumerable: true
     }) : target, mod));
     var path24 = __toESM2(require("path"));
-    var fs22 = __toESM2(require("fs"));
+    var fs23 = __toESM2(require("fs"));
     function cleanPath(path$1) {
       let normalized = (0, path24.normalize)(path$1);
       if (normalized.length > 1 && normalized[normalized.length - 1] === path24.sep) normalized = normalized.substring(0, normalized.length - 1);
@@ -248993,7 +249175,7 @@ var require_dist = __commonJS({
           symlinks: /* @__PURE__ */ new Map(),
           visited: [""].slice(0, 0),
           controller: new Aborter(),
-          fs: options.fs || fs22
+          fs: options.fs || fs23
         };
         this.joinPath = build$7(this.root, options);
         this.pushDirectory = build$6(this.root, options);
@@ -249229,7 +249411,7 @@ var require_dist2 = __commonJS({
       value: mod,
       enumerable: true
     }) : target, mod));
-    var fs22 = require("fs");
+    var fs23 = require("fs");
     var path24 = require("path");
     var url = require("url");
     var fdir = require_dist();
@@ -249477,12 +249659,12 @@ var require_dist2 = __commonJS({
       opts.cwd = (opts.cwd instanceof URL ? (0, url.fileURLToPath)(opts.cwd) : (0, path24.resolve)(opts.cwd)).replace(BACKSLASHES, "/");
       opts.ignore = ensureStringArray(opts.ignore);
       opts.fs && (opts.fs = {
-        readdir: opts.fs.readdir || fs22.readdir,
-        readdirSync: opts.fs.readdirSync || fs22.readdirSync,
-        realpath: opts.fs.realpath || fs22.realpath,
-        realpathSync: opts.fs.realpathSync || fs22.realpathSync,
-        stat: opts.fs.stat || fs22.stat,
-        statSync: opts.fs.statSync || fs22.statSync
+        readdir: opts.fs.readdir || fs23.readdir,
+        readdirSync: opts.fs.readdirSync || fs23.readdirSync,
+        realpath: opts.fs.realpath || fs23.realpath,
+        realpathSync: opts.fs.realpathSync || fs23.realpathSync,
+        stat: opts.fs.stat || fs23.stat,
+        statSync: opts.fs.statSync || fs23.statSync
       });
       if (opts.debug) log("globbing with options:", opts);
       return opts;
@@ -251413,30 +251595,30 @@ ${nodeLocation}` : message;
           yield path25;
       }
     }
-    var fs22 = runtime.fs;
+    var fs23 = runtime.fs;
     var RealFileSystemHost = class {
       async delete(path25) {
         try {
-          await fs22.delete(path25);
+          await fs23.delete(path25);
         } catch (err) {
           throw this.#getFileNotFoundErrorIfNecessary(err, path25);
         }
       }
       deleteSync(path25) {
         try {
-          fs22.deleteSync(path25);
+          fs23.deleteSync(path25);
         } catch (err) {
           throw this.#getFileNotFoundErrorIfNecessary(err, path25);
         }
       }
       readDirSync(dirPath) {
         try {
-          const entries = fs22.readDirSync(dirPath);
+          const entries = fs23.readDirSync(dirPath);
           for (const entry of entries) {
             entry.name = FileUtils.pathJoin(dirPath, entry.name);
             if (entry.isSymlink) {
               try {
-                const info = fs22.statSync(entry.name);
+                const info = fs23.statSync(entry.name);
                 if (info != null) {
                   entry.isDirectory = info.isDirectory();
                   entry.isFile = info.isFile();
@@ -251452,84 +251634,84 @@ ${nodeLocation}` : message;
       }
       async readFile(filePath, encoding = "utf-8") {
         try {
-          return await fs22.readFile(filePath, encoding);
+          return await fs23.readFile(filePath, encoding);
         } catch (err) {
           throw this.#getFileNotFoundErrorIfNecessary(err, filePath);
         }
       }
       readFileSync(filePath, encoding = "utf-8") {
         try {
-          return fs22.readFileSync(filePath, encoding);
+          return fs23.readFileSync(filePath, encoding);
         } catch (err) {
           throw this.#getFileNotFoundErrorIfNecessary(err, filePath);
         }
       }
       async writeFile(filePath, fileText) {
-        return fs22.writeFile(filePath, fileText);
+        return fs23.writeFile(filePath, fileText);
       }
       writeFileSync(filePath, fileText) {
-        fs22.writeFileSync(filePath, fileText);
+        fs23.writeFileSync(filePath, fileText);
       }
       mkdir(dirPath) {
-        return fs22.mkdir(dirPath);
+        return fs23.mkdir(dirPath);
       }
       mkdirSync(dirPath) {
-        fs22.mkdirSync(dirPath);
+        fs23.mkdirSync(dirPath);
       }
       move(srcPath, destPath) {
-        return fs22.move(srcPath, destPath);
+        return fs23.move(srcPath, destPath);
       }
       moveSync(srcPath, destPath) {
-        fs22.moveSync(srcPath, destPath);
+        fs23.moveSync(srcPath, destPath);
       }
       copy(srcPath, destPath) {
-        return fs22.copy(srcPath, destPath);
+        return fs23.copy(srcPath, destPath);
       }
       copySync(srcPath, destPath) {
-        fs22.copySync(srcPath, destPath);
+        fs23.copySync(srcPath, destPath);
       }
       async fileExists(filePath) {
         try {
-          return (await fs22.stat(filePath))?.isFile() ?? false;
+          return (await fs23.stat(filePath))?.isFile() ?? false;
         } catch {
           return false;
         }
       }
       fileExistsSync(filePath) {
         try {
-          return fs22.statSync(filePath)?.isFile() ?? false;
+          return fs23.statSync(filePath)?.isFile() ?? false;
         } catch {
           return false;
         }
       }
       async directoryExists(dirPath) {
         try {
-          return (await fs22.stat(dirPath))?.isDirectory() ?? false;
+          return (await fs23.stat(dirPath))?.isDirectory() ?? false;
         } catch {
           return false;
         }
       }
       directoryExistsSync(dirPath) {
         try {
-          return fs22.statSync(dirPath)?.isDirectory() ?? false;
+          return fs23.statSync(dirPath)?.isDirectory() ?? false;
         } catch {
           return false;
         }
       }
       realpathSync(path25) {
-        return fs22.realpathSync(path25);
+        return fs23.realpathSync(path25);
       }
       getCurrentDirectory() {
-        return FileUtils.standardizeSlashes(fs22.getCurrentDirectory());
+        return FileUtils.standardizeSlashes(fs23.getCurrentDirectory());
       }
       glob(patterns) {
-        return fs22.glob(backSlashesToForward(patterns));
+        return fs23.glob(backSlashesToForward(patterns));
       }
       globSync(patterns) {
-        return fs22.globSync(backSlashesToForward(patterns));
+        return fs23.globSync(backSlashesToForward(patterns));
       }
       isCaseSensitive() {
-        return fs22.isCaseSensitive();
+        return fs23.isCaseSensitive();
       }
       #getDirectoryNotFoundErrorIfNecessary(err, path25) {
         return FileUtils.isNotExistsError(err) ? new exports2.errors.DirectoryNotFoundError(FileUtils.getStandardizedAbsolutePath(this, path25)) : err;
@@ -278636,8 +278818,8 @@ var require_utils4 = __commonJS({
     exports2.array = array2;
     var errno = require_errno();
     exports2.errno = errno;
-    var fs22 = require_fs();
-    exports2.fs = fs22;
+    var fs23 = require_fs();
+    exports2.fs = fs23;
     var path24 = require_path();
     exports2.path = path24;
     var pattern = require_pattern();
@@ -278821,12 +279003,12 @@ var require_fs2 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
-    var fs22 = require("fs");
+    var fs23 = require("fs");
     exports2.FILE_SYSTEM_ADAPTER = {
-      lstat: fs22.lstat,
-      stat: fs22.stat,
-      lstatSync: fs22.lstatSync,
-      statSync: fs22.statSync
+      lstat: fs23.lstat,
+      stat: fs23.stat,
+      lstatSync: fs23.lstatSync,
+      statSync: fs23.statSync
     };
     function createFileSystemAdapter(fsMethods) {
       if (fsMethods === void 0) {
@@ -278843,12 +279025,12 @@ var require_settings = __commonJS({
   "../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/settings.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var fs22 = require_fs2();
+    var fs23 = require_fs2();
     var Settings = class {
       constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
-        this.fs = fs22.createFileSystemAdapter(this._options.fs);
+        this.fs = fs23.createFileSystemAdapter(this._options.fs);
         this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
       }
@@ -279005,8 +279187,8 @@ var require_utils5 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.fs = void 0;
-    var fs22 = require_fs3();
-    exports2.fs = fs22;
+    var fs23 = require_fs3();
+    exports2.fs = fs23;
   }
 });
 
@@ -279201,14 +279383,14 @@ var require_fs4 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
-    var fs22 = require("fs");
+    var fs23 = require("fs");
     exports2.FILE_SYSTEM_ADAPTER = {
-      lstat: fs22.lstat,
-      stat: fs22.stat,
-      lstatSync: fs22.lstatSync,
-      statSync: fs22.statSync,
-      readdir: fs22.readdir,
-      readdirSync: fs22.readdirSync
+      lstat: fs23.lstat,
+      stat: fs23.stat,
+      lstatSync: fs23.lstatSync,
+      statSync: fs23.statSync,
+      readdir: fs23.readdir,
+      readdirSync: fs23.readdirSync
     };
     function createFileSystemAdapter(fsMethods) {
       if (fsMethods === void 0) {
@@ -279227,12 +279409,12 @@ var require_settings2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     var path24 = require("path");
     var fsStat = require_out();
-    var fs22 = require_fs4();
+    var fs23 = require_fs4();
     var Settings = class {
       constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
-        this.fs = fs22.createFileSystemAdapter(this._options.fs);
+        this.fs = fs23.createFileSystemAdapter(this._options.fs);
         this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path24.sep);
         this.stats = this._getValue(this._options.stats, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
@@ -280613,16 +280795,16 @@ var require_settings4 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-    var fs22 = require("fs");
+    var fs23 = require("fs");
     var os9 = require("os");
     var CPU_COUNT = Math.max(os9.cpus().length, 1);
     exports2.DEFAULT_FILE_SYSTEM_ADAPTER = {
-      lstat: fs22.lstat,
-      lstatSync: fs22.lstatSync,
-      stat: fs22.stat,
-      statSync: fs22.statSync,
-      readdir: fs22.readdir,
-      readdirSync: fs22.readdirSync
+      lstat: fs23.lstat,
+      lstatSync: fs23.lstatSync,
+      stat: fs23.stat,
+      statSync: fs23.statSync,
+      readdir: fs23.readdir,
+      readdirSync: fs23.readdirSync
     };
     var Settings = class {
       constructor(_options = {}) {
@@ -280806,7 +280988,7 @@ async function scanWorkspaceFiles(input) {
   });
   const results = await Promise.all(
     entries.map(async (absolutePath) => {
-      const stat4 = await import_promises6.default.stat(absolutePath);
+      const stat4 = await import_promises7.default.stat(absolutePath);
       return {
         absolutePath,
         relativePath: import_node_path13.default.relative(rootPath, absolutePath),
@@ -280817,12 +280999,12 @@ async function scanWorkspaceFiles(input) {
   );
   return results.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
 }
-var import_fast_glob, import_promises6, import_node_path13, import_node_fs10, DEFAULT_INCLUDE_PATTERNS, DEFAULT_EXCLUDE_PATTERNS;
+var import_fast_glob, import_promises7, import_node_path13, import_node_fs10, DEFAULT_INCLUDE_PATTERNS, DEFAULT_EXCLUDE_PATTERNS;
 var init_scanner = __esm({
   "../../packages/indexer/src/scanner.ts"() {
     "use strict";
     import_fast_glob = __toESM(require_out4(), 1);
-    import_promises6 = __toESM(require("fs/promises"), 1);
+    import_promises7 = __toESM(require("fs/promises"), 1);
     import_node_path13 = __toESM(require("path"), 1);
     import_node_fs10 = require("fs");
     init_languages();
@@ -281073,7 +281255,14 @@ async function writeEmbeddingsToRepo(repo, chunkRows, provider) {
   const BATCH_SIZE = 50;
   let totalWritten = 0;
   let failedBatches = 0;
+  const totalBatches = Math.ceil(toEmbed.length / BATCH_SIZE);
   for (let i = 0; i < toEmbed.length; i += BATCH_SIZE) {
+    const batchNum = Math.floor(i / BATCH_SIZE) + 1;
+    if (batchNum % 10 === 0 || batchNum === totalBatches) {
+      process.stdout.write(
+        `\r[embedding] batch ${batchNum}/${totalBatches} (${totalWritten} written)`
+      );
+    }
     const batch = toEmbed.slice(i, i + BATCH_SIZE);
     try {
       const vectors = await provider.embed(
@@ -281118,6 +281307,9 @@ async function writeEmbeddingsToRepo(repo, chunkRows, provider) {
       );
     }
   }
+  if (totalBatches > 0) {
+    process.stdout.write("\n");
+  }
   return { written: totalWritten + reusedWritten, failedBatches };
 }
 async function parseInline(tasks, onProgress) {
@@ -281161,6 +281353,15 @@ async function indexWorkspace(input) {
   const excludeGlobs = workspace.excludeGlobs || configuredWorkspace?.exclude.join("\n") || "";
   const embeddingProvider = await getEmbeddingProvider();
   const runMode = input.mode ?? "incremental";
+  if (embeddingProvider) {
+    process.stdout.write(
+      `[embedding] provider=${embeddingProvider.provider} model=${embeddingProvider.model}
+`
+    );
+  } else {
+    process.stdout.write(`[embedding] disabled (no provider configured)
+`);
+  }
   const reportProgress = async (message, progress) => {
     await input.onProgress?.({ message, progress });
   };
@@ -281226,7 +281427,7 @@ async function indexWorkspace(input) {
         const i = readIndex++;
         fileContents.set(
           filesToRead[i].relativePath,
-          await import_promises7.default.readFile(filesToRead[i].absolutePath, "utf8")
+          await import_promises8.default.readFile(filesToRead[i].absolutePath, "utf8")
         );
       }
     }
@@ -281358,6 +281559,8 @@ async function indexWorkspace(input) {
         const chunkNodeIds = await repo.insertGraphNodesBatch(chunkNodeInputs);
         const edges = [];
         const reusedSymbolIds = /* @__PURE__ */ new Set();
+        const newSymbolInputs = [];
+        const pendingSymbolEdges = [];
         for (const [ci, chunkId] of chunkIds.entries()) {
           const chunkNodeId = chunkNodeIds[ci];
           edges.push({ fromNodeId: fileNodeId, toNodeId: chunkNodeId, type: "contains" });
@@ -281366,7 +281569,7 @@ async function indexWorkspace(input) {
           if (symbolName) {
             const fileSymbolKey = `${file.relativePath}\0${symbolName}`;
             let symbolNodeId = symbolNodeIdsByFileAndName.get(fileSymbolKey);
-            if (!symbolNodeId) {
+            if (symbolNodeIdsByFileAndName.has(fileSymbolKey) === false) {
               const existingSymbolId = fileExistingSymbols.get(symbolName);
               if (existingSymbolId) {
                 repo.updateSymbolNode(
@@ -281381,7 +281584,7 @@ async function indexWorkspace(input) {
                 );
                 symbolNodeId = existingSymbolId;
               } else {
-                symbolNodeId = await repo.upsertGraphNode({
+                newSymbolInputs.push({
                   type: "symbol",
                   label: symbolName,
                   refId: chunkId,
@@ -281390,14 +281593,41 @@ async function indexWorkspace(input) {
                     filePath: file.relativePath,
                     language: indexed.language,
                     parser: indexed.parser
-                  })
+                  }),
+                  _chunkIndex: ci
                 });
+                symbolNodeId = "";
               }
               symbolNodeIdsByFileAndName.set(fileSymbolKey, symbolNodeId);
+            } else {
+              symbolNodeId = symbolNodeIdsByFileAndName.get(fileSymbolKey) ?? "";
             }
             reusedSymbolIds.add(symbolNodeId);
+            const definesEdgeIdx = edges.length;
             edges.push({ fromNodeId: fileNodeId, toNodeId: symbolNodeId, type: "defines" });
+            const representedByEdgeIdx = edges.length;
             edges.push({ fromNodeId: symbolNodeId, toNodeId: chunkNodeId, type: "represented_by" });
+            if (symbolNodeId === "") {
+              pendingSymbolEdges.push({ label: symbolName, definesEdgeIdx, representedByEdgeIdx });
+            }
+          }
+        }
+        if (newSymbolInputs.length > 0) {
+          const symbolIds = await repo.insertGraphNodesBatch(
+            newSymbolInputs.map(({ _chunkIndex, ...rest }) => rest)
+          );
+          for (let si = 0; si < newSymbolInputs.length; si++) {
+            const input2 = newSymbolInputs[si];
+            const fileSymbolKey = `${file.relativePath}\0${input2.label}`;
+            const newId = symbolIds[si];
+            symbolNodeIdsByFileAndName.set(fileSymbolKey, newId);
+            reusedSymbolIds.add(newId);
+          }
+          for (const pending of pendingSymbolEdges) {
+            const newId = symbolNodeIdsByFileAndName.get(`${file.relativePath}\0${pending.label}`);
+            if (!newId) continue;
+            edges[pending.definesEdgeIdx].toNodeId = newId;
+            edges[pending.representedByEdgeIdx].fromNodeId = newId;
           }
         }
         const staleSymbolIds = [];
@@ -281409,6 +281639,8 @@ async function indexWorkspace(input) {
         if (staleSymbolIds.length > 0) {
           repo.deleteGraphNodesByIds(staleSymbolIds);
         }
+        const batchNodeInputs = [];
+        const importEdgeInputs = [];
         for (const importPath of indexed.importPaths) {
           if (typeof importPath !== "string" || importPath.length === 0) continue;
           const resolvedImportPath = workspaceFileResolver?.resolveImport(
@@ -281417,25 +281649,43 @@ async function indexWorkspace(input) {
             indexed.language ?? void 0
           );
           if (!resolvedImportPath) continue;
-          const targetNodeId = await repo.upsertGraphNode({
+          batchNodeInputs.push({
             type: "file",
             label: resolvedImportPath,
             metadata: JSON.stringify({ path: resolvedImportPath })
           });
-          edges.push({
-            fromNodeId: fileNodeId,
-            toNodeId: targetNodeId,
-            type: "imports",
-            metadata: JSON.stringify({ importPath })
-          });
+          importEdgeInputs.push({ importPath, resolvedImportPath });
         }
         for (const link of indexed.wikilinks) {
-          const entityNodeId = await repo.upsertGraphNode({
+          batchNodeInputs.push({
             type: "entity",
             label: link,
             metadata: "{}"
           });
-          edges.push({ fromNodeId: fileNodeId, toNodeId: entityNodeId, type: "mentions" });
+        }
+        if (batchNodeInputs.length > 0) {
+          const upsertedNodes = await repo.upsertGraphNodesBatch(batchNodeInputs);
+          const nodeByLabel = /* @__PURE__ */ new Map();
+          for (const node of upsertedNodes) {
+            nodeByLabel.set(node.label, node.id);
+          }
+          for (const { importPath, resolvedImportPath } of importEdgeInputs) {
+            const targetNodeId = nodeByLabel.get(resolvedImportPath);
+            if (targetNodeId) {
+              edges.push({
+                fromNodeId: fileNodeId,
+                toNodeId: targetNodeId,
+                type: "imports",
+                metadata: JSON.stringify({ importPath })
+              });
+            }
+          }
+          for (const link of indexed.wikilinks) {
+            const entityNodeId = nodeByLabel.get(link);
+            if (entityNodeId) {
+              edges.push({ fromNodeId: fileNodeId, toNodeId: entityNodeId, type: "mentions" });
+            }
+          }
         }
         const edgeSet = /* @__PURE__ */ new Set();
         const dedupedEdges = edges.filter((e) => {
@@ -281463,7 +281713,11 @@ async function indexWorkspace(input) {
         filesUpdated += 1;
       }
     });
-    if (allChunkRowsForEmbeddings.length > 0) {
+    if (allChunkRowsForEmbeddings.length > 0 && embeddingProvider) {
+      await reportProgress(
+        `Embedding ${allChunkRowsForEmbeddings.length} chunks via ${embeddingProvider.provider}/${embeddingProvider.model}...`,
+        90
+      );
       const embeddingResult = await writeEmbeddingsToRepo(
         repo,
         allChunkRowsForEmbeddings,
@@ -281473,10 +281727,12 @@ async function indexWorkspace(input) {
       embeddingFailures += embeddingResult.failedBatches;
     }
     if (bulkWriteMode) {
+      await reportProgress("Rebuilding FTS index...", 93);
       repo.restoreFtsTriggers();
       repo.setOptimizedWriteMode(false);
       bulkWriteMode = false;
     }
+    await reportProgress("Resolving call edges...", 95);
     const globalSymbolNodes = await repo.loadAllSymbolNodes();
     const insertedCallEdges = /* @__PURE__ */ new Set();
     const callEdges = [];
@@ -281566,11 +281822,11 @@ async function indexWorkspace(input) {
     embeddingFailures
   };
 }
-var import_promises7, import_node_path14, RESOLVABLE_SOURCE_EXTENSIONS;
+var import_promises8, import_node_path14, RESOLVABLE_SOURCE_EXTENSIONS;
 var init_index_workspace = __esm({
   "../../packages/indexer/src/index-workspace.ts"() {
     "use strict";
-    import_promises7 = __toESM(require("fs/promises"), 1);
+    import_promises8 = __toESM(require("fs/promises"), 1);
     import_node_path14 = __toESM(require("path"), 1);
     init_src2();
     init_src3();
@@ -295468,12 +295724,12 @@ var require_dist3 = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs22, exportName) {
+    function addFormats(ajv, list, fs23, exportName) {
       var _a3;
       var _b;
       (_a3 = (_b = ajv.opts.code).formats) !== null && _a3 !== void 0 ? _a3 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs22[f]);
+        ajv.addFormat(f, fs23[f]);
     }
     module4.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -296666,6 +296922,19 @@ function createMcpServer(options) {
           },
           required: []
         }
+      },
+      {
+        name: "remove_workspace",
+        description: "Remove a workspace from the registry and delete its .openez data directory. Destructive and irreversible: call only with confirm: true after explicit user approval.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            workspaceId: { type: "string" },
+            path: { type: "string" },
+            confirm: { type: "boolean" }
+          },
+          required: ["confirm"]
+        }
       }
     ]
   }));
@@ -296839,6 +297108,34 @@ ${result.answerContext}`
         const summary = await indexWorkspace({ workspaceId: workspace.id, mode: input.mode });
         return jsonResponse(summary);
       }
+      case "remove_workspace": {
+        const input = removeWorkspaceSchema.parse(request.params.arguments ?? {});
+        if (input.confirm !== true) {
+          return jsonResponse({
+            error: "remove_workspace permanently deletes the registry entry and the workspace's .openez data directory. Requires confirm: true.",
+            hint: "Ask the user for approval, then call remove_workspace again with confirm: true."
+          });
+        }
+        if (input.workspaceId && input.path) {
+          return jsonResponse({ error: "Pass either workspaceId or path, not both." });
+        }
+        if (!input.workspaceId && !input.path) {
+          return jsonResponse({ error: "Pass an explicit workspaceId or path." });
+        }
+        const report = await removeWorkspace({
+          id: input.workspaceId,
+          rootPath: input.path ? import_node_path15.default.resolve(input.path) : void 0
+        });
+        if (!report) {
+          return jsonResponse({
+            error: "Workspace not found",
+            workspaceId: input.workspaceId,
+            path: input.path
+          });
+        }
+        stopWatcherForWorkspace(report.workspaceId);
+        return jsonResponse(report);
+      }
       default:
         throw new Error(`Unknown tool: ${request.params.name}`);
     }
@@ -296877,15 +297174,18 @@ async function autoIndexAndSync(searchRoot) {
   if (!WATCH_ENABLED) {
     return;
   }
-  let debounceTimer = null;
+  const debounceTimer = null;
   const watcher = esm_default.watch(resolvedRoot, {
     ignored: WATCH_IGNORE_PATTERNS,
     ignoreInitial: true,
     persistent: true
   });
+  activeWatcher = { watcher, workspaceId: workspace.id, rootPath: resolvedRoot, debounceTimer };
   const triggerReindex = () => {
-    if (debounceTimer) clearTimeout(debounceTimer);
-    debounceTimer = setTimeout(async () => {
+    const current = activeWatcher;
+    if (!current) return;
+    if (current.debounceTimer) clearTimeout(current.debounceTimer);
+    current.debounceTimer = setTimeout(async () => {
       try {
         await indexWorkspace({ workspaceId: workspace.id, mode: "incremental" });
       } catch {
@@ -296900,9 +297200,17 @@ async function autoIndexAndSync(searchRoot) {
       `OpenEZ MCP auto-sync watcher disabled: ${error2 instanceof Error ? error2.message : String(error2)}`
     );
     void watcher.close();
+    activeWatcher = null;
   });
 }
-var import_node_fs11, import_node_path15, MIN_RESPONSE_TOKENS, codeQuerySchema, codeContextSchema, graphNeighborsSchema, memoryWriteSchema, memoryRecallSchema, indexWorkspaceSchema, MCP_CATCHUP_INTERVAL_MS, catchupState, WATCH_DEBOUNCE_MS, WATCH_ENABLED, WATCH_IGNORE_PATTERNS;
+function stopWatcherForWorkspace(workspaceId) {
+  if (activeWatcher && activeWatcher.workspaceId === workspaceId) {
+    if (activeWatcher.debounceTimer) clearTimeout(activeWatcher.debounceTimer);
+    void activeWatcher.watcher.close();
+    activeWatcher = null;
+  }
+}
+var import_node_fs11, import_node_path15, MIN_RESPONSE_TOKENS, codeQuerySchema, codeContextSchema, graphNeighborsSchema, memoryWriteSchema, memoryRecallSchema, indexWorkspaceSchema, removeWorkspaceSchema, MCP_CATCHUP_INTERVAL_MS, catchupState, activeWatcher, WATCH_DEBOUNCE_MS, WATCH_ENABLED, WATCH_IGNORE_PATTERNS;
 var init_mcp_core = __esm({
   "../mcp/src/mcp-core.ts"() {
     "use strict";
@@ -296970,8 +297278,14 @@ var init_mcp_core = __esm({
       path: external_exports.string().optional(),
       mode: external_exports.enum(["incremental", "full"]).optional()
     });
+    removeWorkspaceSchema = external_exports.object({
+      workspaceId: external_exports.string().optional(),
+      path: external_exports.string().optional(),
+      confirm: external_exports.boolean().optional()
+    });
     MCP_CATCHUP_INTERVAL_MS = Number(process.env.OPENEZ_MCP_CATCHUP_INTERVAL_MS ?? 5e3);
     catchupState = /* @__PURE__ */ new Map();
+    activeWatcher = null;
     WATCH_DEBOUNCE_MS = 2e3;
     WATCH_ENABLED = ["1", "true", "yes"].includes(
       (process.env.OPENEZ_MCP_WATCH ?? "").toLowerCase()
@@ -296995,7 +297309,7 @@ __export(mcp_bridge_exports, {
   startMcpServer: () => startMcpServer
 });
 async function startMcpServer(defaultPath, version4) {
-  await createAndStartMcpServer({ defaultPath, version: version4, build: "cc56c89-dirty" });
+  await createAndStartMcpServer({ defaultPath, version: version4, build: "56dde1b-dirty" });
 }
 var init_mcp_bridge = __esm({
   "src/mcp-bridge.ts"() {
@@ -300965,21 +301279,73 @@ function initializeRegistrySchema2(db) {
       node_count INTEGER NOT NULL DEFAULT 0,
       edge_count INTEGER NOT NULL DEFAULT 0,
       last_error TEXT,
+      pinned_at TEXT,
+      pin_order INTEGER,
       created_at TEXT NOT NULL DEFAULT (datetime('now')),
       updated_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
     CREATE UNIQUE INDEX IF NOT EXISTS idx_workspaces_root_path ON workspaces(root_path);
   `);
+  migrateRegistryColumns2(db);
+}
+function migrateRegistryColumns2(db) {
+  const getColumns = () => new Set(
+    db.prepare("PRAGMA table_info(workspaces)").all().map(
+      (row) => row.name
+    )
+  );
+  const addColumnIfMissing = (name, definition) => {
+    if (getColumns().has(name)) return;
+    try {
+      db.exec(`ALTER TABLE workspaces ADD COLUMN ${definition}`);
+    } catch (err) {
+      if (!getColumns().has(name)) {
+        throw err;
+      }
+    }
+  };
+  addColumnIfMissing("pinned_at", "pinned_at TEXT");
+  addColumnIfMissing("pin_order", "pin_order INTEGER");
+  const unbackfilled = db.prepare(
+    "SELECT id FROM workspaces WHERE pinned_at IS NOT NULL AND pin_order IS NULL ORDER BY pinned_at DESC"
+  ).all();
+  if (unbackfilled.length > 0) {
+    const maxRow = db.prepare("SELECT MAX(pin_order) AS max_order FROM workspaces WHERE pin_order IS NOT NULL").get();
+    let next = (maxRow?.max_order ?? 0) + 1;
+    const stmt = db.prepare("UPDATE workspaces SET pin_order = ? WHERE id = ?");
+    for (const row of unbackfilled) {
+      stmt.run(next, row.id);
+      next += 1;
+    }
+  }
 }
 function getRegistryDb2() {
   if (!registryDb2) {
     const dbPath = resolveRegistryDbPath2();
     ensureDirForFile(dbPath);
-    registryDb2 = openSqlite(dbPath);
-    initializeRegistrySchema2(registryDb2);
+    const db = openSqlite(dbPath);
+    try {
+      initializeRegistrySchema2(db);
+      registryDb2 = db;
+    } catch (err) {
+      db.close();
+      registryDb2 = null;
+      throw err;
+    }
   }
   return registryDb2;
 }
+function closeWorkspaceDb2(rootPath) {
+  const normalized = normalizeRootPath2(rootPath);
+  const db = workspaceDbs.get(normalized);
+  if (db) {
+    try {
+      db.close();
+    } catch {
+    }
+    workspaceDbs.delete(normalized);
+  }
+}
 function resolveWorkspaceDbPath(rootPath) {
   return import_node_path17.default.join(rootPath, ".openez", "index.sqlite");
 }
@@ -301145,12 +301511,16 @@ function mapWorkspace(row) {
     nodeCount: Number(row.node_count ?? 0),
     edgeCount: Number(row.edge_count ?? 0),
     lastError: row.last_error ? String(row.last_error) : void 0,
+    pinnedAt: row.pinned_at ? String(row.pinned_at) : void 0,
+    pinOrder: row.pin_order != null ? Number(row.pin_order) : void 0,
     createdAt: String(row.created_at),
     updatedAt: String(row.updated_at)
   };
 }
 function listRegistryWorkspaces() {
-  const rows = getRegistryDb2().prepare("SELECT * FROM workspaces ORDER BY created_at DESC").all();
+  const rows = getRegistryDb2().prepare(
+    "SELECT * FROM workspaces ORDER BY (pinned_at IS NULL), pin_order DESC, pinned_at DESC, created_at DESC"
+  ).all();
   return rows.map(mapWorkspace);
 }
 function getRegistryWorkspace(id) {
@@ -301195,8 +301565,19 @@ function ensureRegistryWorkspace(input) {
   );
   return getRegistryWorkspace(nextId);
 }
-function deleteRegistryWorkspace(id) {
-  getRegistryDb2().prepare("DELETE FROM workspaces WHERE id = ?").run(id);
+function setRegistryWorkspacePinned(id, pinned) {
+  const db = getRegistryDb2();
+  if (pinned) {
+    const maxRow = db.prepare("SELECT MAX(pin_order) AS max_order FROM workspaces WHERE pin_order IS NOT NULL").get();
+    const nextOrder = (maxRow?.max_order ?? 0) + 1;
+    db.prepare("UPDATE workspaces SET pinned_at = ?, pin_order = ? WHERE id = ?").run(
+      (/* @__PURE__ */ new Date()).toISOString(),
+      nextOrder,
+      id
+    );
+  } else {
+    db.prepare("UPDATE workspaces SET pinned_at = NULL, pin_order = NULL WHERE id = ?").run(id);
+  }
 }
 function mapRunRow(row, kind) {
   return {
@@ -301488,6 +301869,7 @@ function mapWorkspace2(ws) {
     nodeCount: ws.nodeCount,
     edgeCount: ws.edgeCount,
     lastError: ws.lastError ?? null,
+    pinnedAt: ws.pinnedAt ?? null,
     createdAt: new Date(ws.createdAt),
     updatedAt: new Date(ws.updatedAt)
   };
@@ -301775,14 +302157,34 @@ var init_server3 = __esm({
         return c.json({ success: false, error: "Failed to create workspace" });
       }
     });
-    app.delete("/api/workspaces/:id", (c) => {
+    app.delete("/api/workspaces/:id", async (c) => {
       try {
         const id = c.req.param("id");
-        deleteRegistryWorkspace(id);
-        return c.json({ success: true });
+        const ws = getRegistryWorkspace(id);
+        if (ws) closeWorkspaceDb2(ws.rootPath);
+        const report = await removeWorkspace({ id });
+        if (!report) return c.json({ success: false, error: "Workspace not found" }, 404);
+        return c.json({ success: true, report });
       } catch (err) {
         console.error("Failed to delete workspace:", err);
-        return c.json({ success: false, error: "Failed to delete workspace" });
+        return c.json({ success: false, error: "Failed to delete workspace" }, 500);
+      }
+    });
+    app.patch("/api/workspaces/:id/pin", async (c) => {
+      try {
+        const id = c.req.param("id");
+        const body = await c.req.json().catch(() => null);
+        if (typeof body?.pinned !== "boolean") {
+          return c.json({ success: false, error: "pinned (boolean) is required" }, 400);
+        }
+        if (!getRegistryWorkspace(id)) {
+          return c.json({ success: false, error: "Workspace not found" }, 404);
+        }
+        setRegistryWorkspacePinned(id, body.pinned);
+        return c.json({ success: true });
+      } catch (err) {
+        console.error("Failed to pin workspace:", err);
+        return c.json({ success: false, error: "Failed to pin workspace" });
       }
     });
     app.get("/api/workspaces/:id/index", (c) => {
@@ -303394,6 +303796,7 @@ var init_setup_devin = __esm({
 // src/cli.ts
 var import_node_fs21 = __toESM(require("fs"), 1);
 var import_node_path25 = __toESM(require("path"), 1);
+var import_node_readline = __toESM(require("readline"), 1);
 init_esm2();
 
 // ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/esm.mjs
@@ -303614,10 +304017,62 @@ program2.command("list").description("List all registered workspaces").action(as
   console.log("Registered workspaces:");
   for (const workspace of workspaces2) {
     const statusIcon = workspace.status === "indexed" ? "\u2713" : workspace.status === "error" ? "\u2717" : "\u25CB";
-    console.log(`  ${statusIcon} ${workspace.name} (${workspace.id})`);
+    const pinMarker = workspace.pinnedAt ? " \u{1F4CC}" : "";
+    console.log(`  ${statusIcon}${pinMarker} ${workspace.name} (${workspace.id})`);
     console.log(`       ${workspace.rootPath}`);
   }
 });
+function confirmDestructive(prompt) {
+  if (!process.stdin.isTTY) return Promise.reject(new Error("Confirmation required; rerun with --yes."));
+  const rl = import_node_readline.default.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve4) => {
+    rl.question(`${prompt} [y/N] `, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      resolve4(normalized === "y" || normalized === "yes");
+    });
+  });
+}
+program2.command("remove").alias("rm").description("Remove a workspace from the registry and delete its .openez data directory").argument("[path]", "path to the workspace directory", process.cwd()).option("--id <workspaceId>", "workspace id (takes precedence over path)").option("-y, --yes", "skip confirmation prompt").action(async (targetPath, options) => {
+  const registry2 = createRegistryRepository();
+  const resolvedPath = import_node_path25.default.resolve(targetPath);
+  const workspace = options.id ? await registry2.getWorkspace(options.id) : await registry2.getWorkspaceByPath(resolvedPath);
+  if (!workspace) {
+    console.error(`Error: no registered workspace found for ${options.id ?? resolvedPath}`);
+    process.exit(1);
+  }
+  const dataDir = getLocalWorkspaceDir(workspace.rootPath);
+  console.log(`Workspace: ${workspace.name} (${workspace.id})`);
+  console.log(`  Path:     ${workspace.rootPath}`);
+  console.log(`  Data dir: ${dataDir}`);
+  console.log(`  Indexed:  ${workspace.documentCount} docs, ${workspace.chunkCount} chunks`);
+  console.log(
+    "This removes the registry entry and deletes the data directory. Source code is not touched."
+  );
+  if (!options.yes) {
+    const confirmed = await confirmDestructive("Proceed?");
+    if (!confirmed) {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  const report = await removeWorkspace({ id: workspace.id });
+  if (!report) {
+    console.error(`Error: workspace '${workspace.id}' no longer exists in the registry.`);
+    process.exit(1);
+  }
+  if (report.unregistered) {
+    console.log(`\u2713 Unregistered workspace ${report.workspaceId}`);
+  } else {
+    console.log(`\u2717 Workspace ${report.workspaceId} could not be unregistered (see warnings)`);
+  }
+  if (report.dataDirRemoved) {
+    console.log(`\u2713 Deleted ${report.dataDirPath}`);
+  }
+  for (const warning of report.warnings) {
+    console.log(`! ${warning}`);
+  }
+});
 var EMBEDDING_CONFIG_KEYS = [
   "embedding.provider",
   "embedding.openai_api_key",