@openez-graph/cli 0.11.1 → 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;
@@ -13223,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"() {
@@ -13232,6 +13391,7 @@ var init_sqlite = __esm({
     init_repository();
     init_secure_storage();
     init_local_workspace();
+    init_remove_workspace();
     init_schema();
   }
 });
@@ -13316,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");
@@ -13425,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`;
             }
           }
@@ -13435,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;
@@ -13484,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) {
@@ -17826,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}
@@ -17854,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();
@@ -32635,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) {
     }
@@ -32710,7 +32870,7 @@ var require_source_map_support = __commonJS({
       }
       var contents = "";
       try {
-        if (!fs22) {
+        if (!fs23) {
           var xhr = new XMLHttpRequest();
           xhr.open(
             "GET",
@@ -32722,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) {
       }
@@ -32987,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 = "";
           }
@@ -36761,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;
@@ -38339,7 +38499,7 @@ ${lanes.join("\n")}
       var tracing;
       var tracingEnabled;
       ((tracingEnabled2) => {
-        let fs22;
+        let fs23;
         let traceCount = 0;
         let traceFd = 0;
         let mode;
@@ -38348,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})`);
@@ -38361,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`);
@@ -38372,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")
           );
@@ -38384,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);
@@ -38459,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");
         }
@@ -38485,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];
@@ -38583,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");
         }
@@ -38597,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 = {}));
@@ -248718,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);
@@ -249015,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);
@@ -249251,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();
@@ -249499,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;
@@ -251435,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();
@@ -251474,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;
@@ -278658,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();
@@ -278843,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) {
@@ -278865,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);
       }
@@ -279027,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;
   }
 });
 
@@ -279223,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) {
@@ -279249,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);
@@ -280635,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 = {}) {
@@ -280828,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),
@@ -280839,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();
@@ -281099,7 +281259,9 @@ async function writeEmbeddingsToRepo(repo, chunkRows, provider) {
   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)`);
+      process.stdout.write(
+        `\r[embedding] batch ${batchNum}/${totalBatches} (${totalWritten} written)`
+      );
     }
     const batch = toEmbed.slice(i, i + BATCH_SIZE);
     try {
@@ -281265,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")
         );
       }
     }
@@ -281462,9 +281624,7 @@ async function indexWorkspace(input) {
             reusedSymbolIds.add(newId);
           }
           for (const pending of pendingSymbolEdges) {
-            const newId = symbolNodeIdsByFileAndName.get(
-              `${file.relativePath}\0${pending.label}`
-            );
+            const newId = symbolNodeIdsByFileAndName.get(`${file.relativePath}\0${pending.label}`);
             if (!newId) continue;
             edges[pending.definesEdgeIdx].toNodeId = newId;
             edges[pending.representedByEdgeIdx].fromNodeId = newId;
@@ -281662,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();
@@ -295564,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 });
@@ -296762,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"]
+        }
       }
     ]
   }));
@@ -296935,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}`);
     }
@@ -296973,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 {
@@ -296996,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";
@@ -297066,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()
@@ -297091,7 +297309,7 @@ __export(mcp_bridge_exports, {
   startMcpServer: () => startMcpServer
 });
 async function startMcpServer(defaultPath, version4) {
-  await createAndStartMcpServer({ defaultPath, version: version4, build: "ebc5064-dirty" });
+  await createAndStartMcpServer({ defaultPath, version: version4, build: "56dde1b-dirty" });
 }
 var init_mcp_bridge = __esm({
   "src/mcp-bridge.ts"() {
@@ -301061,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");
 }
@@ -301241,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) {
@@ -301291,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 {
@@ -301584,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)
   };
@@ -301871,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) => {
@@ -303490,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
@@ -303710,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",