@codecell-germany/company-agent-wiki-skill 0.1.0 → 0.1.2

package/dist/index.js

@@ -1189,8 +1189,8 @@ var require_command = __commonJS({
   "node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter = require("node:events").EventEmitter;
     var childProcess = require("node:child_process");
-    var path8 = require("node:path");
-    var fs8 = require("node:fs");
+    var path9 = require("node:path");
+    var fs9 = require("node:fs");
     var process2 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -2184,7 +2184,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs8.existsSync(executableFile)) return;
+        if (fs9.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
@@ -2202,11 +2202,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path8.resolve(baseDir, baseName);
-          if (fs8.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path8.extname(baseName))) return void 0;
+          const localBin = path9.resolve(baseDir, baseName);
+          if (fs9.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path9.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs8.existsSync(`${localBin}${ext}`)
+            (ext) => fs9.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -2218,21 +2218,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs8.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs9.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path8.resolve(
-            path8.dirname(resolvedScriptPath),
+          executableDir = path9.resolve(
+            path9.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path8.basename(
+            const legacyName = path9.basename(
               this._scriptPath,
-              path8.extname(this._scriptPath)
+              path9.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2243,7 +2243,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path8.extname(executableFile));
+        launchWithNode = sourceExt.includes(path9.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -3158,7 +3158,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path8.basename(filename, path8.extname(filename));
+        this._name = path9.basename(filename, path9.extname(filename));
         return this;
       }
       /**
@@ -3172,9 +3172,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path9) {
-        if (path9 === void 0) return this._executableDir;
-        this._executableDir = path9;
+      executableDir(path10) {
+        if (path10 === void 0) return this._executableDir;
+        this._executableDir = path10;
         return this;
       }
       /**
@@ -6823,7 +6823,7 @@ var require_parse = __commonJS({
 var require_gray_matter = __commonJS({
   "node_modules/gray-matter/index.js"(exports2, module2) {
     "use strict";
-    var fs8 = require("fs");
+    var fs9 = require("fs");
     var sections = require_section_matter();
     var defaults = require_defaults();
     var stringify = require_stringify();
@@ -6907,7 +6907,7 @@ var require_gray_matter = __commonJS({
       return stringify(file, data, options3);
     };
     matter2.read = function(filepath, options3) {
-      const str2 = fs8.readFileSync(filepath, "utf8");
+      const str2 = fs9.readFileSync(filepath, "utf8");
       const file = matter2(str2, options3);
       file.path = filepath;
       return file;
@@ -6936,8 +6936,8 @@ var require_gray_matter = __commonJS({
 });
 
 // src/index.ts
-var import_node_fs7 = __toESM(require("node:fs"));
-var import_node_path7 = __toESM(require("node:path"));
+var import_node_fs8 = __toESM(require("node:fs"));
+var import_node_path8 = __toESM(require("node:path"));
 
 // node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
@@ -6963,8 +6963,10 @@ var WORKSPACE_INTERNAL_DIR = ".company-agent-wiki";
 var WORKSPACE_CONFIG_FILE = "workspace.json";
 var INDEX_DB_FILE = "index.sqlite";
 var INDEX_MANIFEST_FILE = "index-manifest.json";
+var GLOBAL_REGISTRY_DIR_NAME = "company-agent-wiki";
+var GLOBAL_REGISTRY_FILE = "workspaces.json";
 var WORKSPACE_LAYOUT_VERSION = 1;
-var CLI_SCHEMA_VERSION = "2026-04-12";
+var CLI_SCHEMA_VERSION = "2026-04-13";
 var INDEX_SCHEMA_VERSION = 1;
 var DEFAULT_MANAGED_ROOT_ID = "canonical";
 var DEFAULT_MANAGED_ROOT_PATH = "knowledge/canonical";
@@ -6979,6 +6981,7 @@ var EXIT_CODES = {
   notFound: 6,
   git: 7,
   sqliteLocked: 8,
+  workspaceBusy: 9,
   runtime: 10
 };
 
@@ -7139,8 +7142,8 @@ function getGitDiff(filePath, baseRef, compareRef) {
 }
 
 // src/lib/indexer.ts
-var import_node_fs4 = __toESM(require("node:fs"));
-var import_node_path5 = __toESM(require("node:path"));
+var import_node_fs5 = __toESM(require("node:fs"));
+var import_node_path6 = __toESM(require("node:path"));
 var import_better_sqlite3 = __toESM(require("better-sqlite3"));
 
 // src/lib/fs-utils.ts
@@ -7159,6 +7162,7 @@ function writeJsonFile(targetPath, value) {
 }
 function writeJsonAtomic(targetPath, value) {
   const tempPath = `${targetPath}.tmp`;
+  ensureDir(import_node_path2.default.dirname(targetPath));
   writeJsonFile(tempPath, value);
   import_node_fs2.default.renameSync(tempPath, targetPath);
 }
@@ -7340,8 +7344,29 @@ var import_node_path4 = __toESM(require("node:path"));
 function getDefaultCodexHome() {
   return process.env.CODEX_HOME || import_node_path4.default.join(import_node_os.default.homedir(), ".codex");
 }
+function getGlobalRegistryDir() {
+  const explicit = process.env.COMPANY_AGENT_WIKI_CONFIG_HOME;
+  if (explicit?.trim()) {
+    return import_node_path4.default.resolve(explicit);
+  }
+  if (process.env.VITEST || process.env.NODE_ENV === "test") {
+    return import_node_path4.default.join(import_node_os.default.tmpdir(), GLOBAL_REGISTRY_DIR_NAME, "vitest");
+  }
+  if (process.platform === "darwin") {
+    return import_node_path4.default.join(import_node_os.default.homedir(), "Library", "Application Support", GLOBAL_REGISTRY_DIR_NAME);
+  }
+  if (process.platform === "win32") {
+    const roaming = process.env.APPDATA || import_node_path4.default.join(import_node_os.default.homedir(), "AppData", "Roaming");
+    return import_node_path4.default.join(roaming, GLOBAL_REGISTRY_DIR_NAME);
+  }
+  const xdgConfig = process.env.XDG_CONFIG_HOME || import_node_path4.default.join(import_node_os.default.homedir(), ".config");
+  return import_node_path4.default.join(xdgConfig, GLOBAL_REGISTRY_DIR_NAME);
+}
+function getGlobalRegistryPath() {
+  return import_node_path4.default.join(getGlobalRegistryDir(), GLOBAL_REGISTRY_FILE);
+}
 function resolveWorkspacePaths(workspaceRoot) {
-  const absoluteRoot = import_node_path4.default.resolve(workspaceRoot);
+  const absoluteRoot = normalizeWorkspaceRootPath(workspaceRoot);
   const internalDir = import_node_path4.default.join(absoluteRoot, WORKSPACE_INTERNAL_DIR);
   return {
     workspaceRoot: absoluteRoot,
@@ -7367,6 +7392,160 @@ function detectWorkspaceRoot(startDir = process.cwd()) {
     current = parent;
   }
 }
+function createDefaultGlobalRegistry() {
+  return {
+    schemaVersion: WORKSPACE_LAYOUT_VERSION,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspaces: []
+  };
+}
+function normalizeWorkspaceRootPath(candidatePath) {
+  const resolved = import_node_path4.default.resolve(candidatePath);
+  try {
+    return import_node_fs3.default.realpathSync.native ? import_node_fs3.default.realpathSync.native(resolved) : import_node_fs3.default.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function loadGlobalWorkspaceRegistry() {
+  const registryPath = getGlobalRegistryPath();
+  if (!fileExists(registryPath)) {
+    return createDefaultGlobalRegistry();
+  }
+  const raw = readJsonFile(registryPath);
+  const registry = createDefaultGlobalRegistry();
+  registry.schemaVersion = raw.schemaVersion || registry.schemaVersion;
+  registry.updatedAt = raw.updatedAt || registry.updatedAt;
+  const deduped = /* @__PURE__ */ new Map();
+  for (const entry of raw.workspaces || []) {
+    const normalizedPath = normalizeWorkspaceRootPath(entry.path);
+    if (!fileExists(resolveWorkspacePaths(normalizedPath).configPath)) {
+      continue;
+    }
+    const normalizedEntry = {
+      workspaceId: entry.workspaceId,
+      path: normalizedPath,
+      label: entry.label || import_node_path4.default.basename(normalizedPath),
+      registeredAt: entry.registeredAt,
+      lastUsedAt: entry.lastUsedAt,
+      source: entry.source
+    };
+    const existing = deduped.get(normalizedPath);
+    if (!existing || existing.lastUsedAt < normalizedEntry.lastUsedAt) {
+      deduped.set(normalizedPath, normalizedEntry);
+    }
+  }
+  registry.workspaces = Array.from(deduped.values()).sort((left, right) => left.label.localeCompare(right.label));
+  if (raw.defaultWorkspace) {
+    const normalizedDefault = normalizeWorkspaceRootPath(raw.defaultWorkspace);
+    if (deduped.has(normalizedDefault)) {
+      registry.defaultWorkspace = normalizedDefault;
+    }
+  }
+  const serializedRaw = JSON.stringify(raw);
+  const serializedNormalized = JSON.stringify(registry);
+  if (serializedRaw !== serializedNormalized) {
+    saveGlobalWorkspaceRegistry(registry);
+  }
+  return registry;
+}
+function saveGlobalWorkspaceRegistry(registry) {
+  writeJsonAtomic(getGlobalRegistryPath(), registry);
+}
+function buildRegisteredWorkspace(workspaceRoot, source) {
+  const resolvedRoot = normalizeWorkspaceRootPath(workspaceRoot);
+  const config = loadWorkspaceConfig(resolvedRoot);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    workspaceId: config.workspaceId,
+    path: resolvedRoot,
+    label: import_node_path4.default.basename(resolvedRoot),
+    registeredAt: now,
+    lastUsedAt: now,
+    source
+  };
+}
+function registerWorkspaceGlobally(workspaceRoot, options3) {
+  const resolvedRoot = import_node_path4.default.resolve(workspaceRoot);
+  const nextEntry = buildRegisteredWorkspace(resolvedRoot, options3?.source || "manual");
+  const registry = loadGlobalWorkspaceRegistry();
+  const existing = registry.workspaces.find((item) => item.path === resolvedRoot);
+  if (existing) {
+    existing.workspaceId = nextEntry.workspaceId;
+    existing.label = nextEntry.label;
+    existing.lastUsedAt = nextEntry.lastUsedAt;
+    existing.source = nextEntry.source;
+  } else {
+    registry.workspaces.push(nextEntry);
+  }
+  if (options3?.setDefault || !registry.defaultWorkspace) {
+    registry.defaultWorkspace = resolvedRoot;
+  }
+  registry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  saveGlobalWorkspaceRegistry(registry);
+  return registry.workspaces.find((item) => item.path === resolvedRoot) || nextEntry;
+}
+function rememberWorkspaceGlobally(workspaceRoot, options3) {
+  const configPath = resolveWorkspacePaths(workspaceRoot).configPath;
+  if (!fileExists(configPath)) {
+    return void 0;
+  }
+  try {
+    return registerWorkspaceGlobally(workspaceRoot, options3);
+  } catch {
+    return void 0;
+  }
+}
+function listRegisteredWorkspaces() {
+  const registry = loadGlobalWorkspaceRegistry();
+  return {
+    registryPath: getGlobalRegistryPath(),
+    defaultWorkspace: registry.defaultWorkspace,
+    workspaces: registry.workspaces.map((item) => ({
+      ...item,
+      exists: fileExists(resolveWorkspacePaths(item.path).configPath)
+    }))
+  };
+}
+function resolveWorkspaceSelection(startDir = process.cwd()) {
+  const registryPath = getGlobalRegistryPath();
+  const cwdWorkspace = detectWorkspaceRoot(startDir);
+  if (cwdWorkspace) {
+    rememberWorkspaceGlobally(cwdWorkspace, { setDefault: true, source: "detected" });
+    return {
+      workspaceRoot: cwdWorkspace,
+      source: "cwd",
+      registryPath,
+      defaultWorkspace: loadGlobalWorkspaceRegistry().defaultWorkspace
+    };
+  }
+  const registry = loadGlobalWorkspaceRegistry();
+  const existingWorkspaces = registry.workspaces.filter((item) => fileExists(resolveWorkspacePaths(item.path).configPath));
+  const defaultWorkspace = registry.defaultWorkspace;
+  if (defaultWorkspace && fileExists(resolveWorkspacePaths(defaultWorkspace).configPath)) {
+    rememberWorkspaceGlobally(defaultWorkspace, { setDefault: true, source: "runtime" });
+    return {
+      workspaceRoot: defaultWorkspace,
+      source: "global-default",
+      registryPath,
+      defaultWorkspace
+    };
+  }
+  if (existingWorkspaces.length === 1) {
+    const onlyWorkspace = existingWorkspaces[0].path;
+    rememberWorkspaceGlobally(onlyWorkspace, { setDefault: true, source: "runtime" });
+    return {
+      workspaceRoot: onlyWorkspace,
+      source: "single-registered",
+      registryPath,
+      defaultWorkspace: onlyWorkspace
+    };
+  }
+  return {
+    registryPath,
+    defaultWorkspace
+  };
+}
 function templateWorkspaceReadme() {
   return `# Private Company Knowledge Workspace
 
@@ -7734,6 +7913,7 @@ function setupWorkspace(options3) {
       }
     }
   }
+  registerWorkspaceGlobally(paths.workspaceRoot, { setDefault: true, source: "setup" });
   return {
     workspaceRoot: paths.workspaceRoot,
     configPath: paths.configPath,
@@ -7743,7 +7923,8 @@ function setupWorkspace(options3) {
       `company-agent-wiki-cli doctor --workspace ${paths.workspaceRoot} --json`,
       `company-agent-wiki-cli index rebuild --workspace ${paths.workspaceRoot} --json`,
       `company-agent-wiki-cli verify --workspace ${paths.workspaceRoot} --json`,
-      `company-agent-wiki-cli serve --workspace ${paths.workspaceRoot} --port 4187`
+      `company-agent-wiki-cli serve --workspace ${paths.workspaceRoot} --port 4187`,
+      "Other agents can now discover this workspace automatically via the global workspace registry."
     ]
   };
 }
@@ -7776,6 +7957,7 @@ function addRoot(workspaceRoot, rootDefinition) {
   };
   config.roots.push(root);
   saveWorkspaceConfig(workspaceRoot, config);
+  rememberWorkspaceGlobally(workspaceRoot, { setDefault: true, source: "runtime" });
   return root;
 }
 function listRoots(workspaceRoot) {
@@ -7797,6 +7979,8 @@ function doctor(workspaceRoot) {
   const codexBinDir = import_node_path4.default.join(codexHome, "bin");
   const codexShimPath = import_node_path4.default.join(codexBinDir, CLI_NAME);
   const pathEntries = (process.env.PATH || "").split(import_node_path4.default.delimiter).filter(Boolean);
+  const registryPath = getGlobalRegistryPath();
+  const registry = loadGlobalWorkspaceRegistry();
   checks.push({
     name: "workspace-root",
     ok: isDirectory(paths.workspaceRoot),
@@ -7822,6 +8006,16 @@ function doctor(workspaceRoot) {
     ok: pathEntries.includes(codexBinDir),
     message: pathEntries.includes(codexBinDir) ? `Codex bin directory is available in PATH: ${codexBinDir}` : `Codex bin directory is not in PATH: ${codexBinDir}`
   });
+  checks.push({
+    name: "global-workspace-registry",
+    ok: fileExists(registryPath),
+    message: fileExists(registryPath) ? `Global workspace registry found: ${registryPath}` : `Global workspace registry missing: ${registryPath}`
+  });
+  checks.push({
+    name: "global-default-workspace",
+    ok: typeof registry.defaultWorkspace === "string" && fileExists(resolveWorkspacePaths(registry.defaultWorkspace).configPath),
+    message: typeof registry.defaultWorkspace === "string" ? `Global default workspace: ${registry.defaultWorkspace}` : "No global default workspace registered yet."
+  });
   if (fileExists(paths.configPath)) {
     const config = loadWorkspaceConfig(workspaceRoot);
     for (const root of config.roots) {
@@ -7849,6 +8043,121 @@ function doctor(workspaceRoot) {
   };
 }
 
+// src/lib/write-lock.ts
+var import_node_fs4 = __toESM(require("node:fs"));
+var import_node_path5 = __toESM(require("node:path"));
+var LOCK_FILE_NAME = "write.lock";
+var LOCK_WAIT_TIMEOUT_MS = 6e4;
+var LOCK_POLL_INTERVAL_MS = 125;
+var LOCK_STALE_AFTER_MS = 10 * 6e4;
+function sleepMs(durationMs) {
+  const shared = new SharedArrayBuffer(4);
+  const array = new Int32Array(shared);
+  Atomics.wait(array, 0, 0, durationMs);
+}
+function getLockPath(workspaceRoot) {
+  return import_node_path5.default.join(import_node_path5.default.resolve(workspaceRoot), WORKSPACE_INTERNAL_DIR, LOCK_FILE_NAME);
+}
+function readLockPayload(lockPath) {
+  if (!fileExists(lockPath)) {
+    return void 0;
+  }
+  try {
+    return readJsonFile(lockPath);
+  } catch {
+    return void 0;
+  }
+}
+function isProcessAlive(pid) {
+  if (!pid || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    return code !== "ESRCH";
+  }
+}
+function canBreakLock(payload) {
+  if (!payload) {
+    return true;
+  }
+  const acquiredAt = Date.parse(payload.acquiredAt);
+  const ageMs = Number.isNaN(acquiredAt) ? Number.POSITIVE_INFINITY : Date.now() - acquiredAt;
+  if (ageMs > LOCK_STALE_AFTER_MS) {
+    return true;
+  }
+  return !isProcessAlive(payload.pid);
+}
+function writeLockPayload(lockPath, payload) {
+  const tempPath = `${lockPath}.${payload.token}.tmp`;
+  writeJsonAtomic(tempPath, payload);
+  import_node_fs4.default.renameSync(tempPath, lockPath);
+}
+function createLockPayload(workspaceRoot, reason) {
+  return {
+    token: newBuildId(),
+    pid: process.pid,
+    reason,
+    workspaceRoot: import_node_path5.default.resolve(workspaceRoot),
+    acquiredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function withWorkspaceWriteLock(workspaceRoot, reason, callback, options3) {
+  const lockPath = getLockPath(workspaceRoot);
+  const timeoutMs = options3?.timeoutMs ?? LOCK_WAIT_TIMEOUT_MS;
+  const deadline = Date.now() + timeoutMs;
+  const payload = createLockPayload(workspaceRoot, reason);
+  ensureDir(import_node_path5.default.dirname(lockPath));
+  while (true) {
+    try {
+      const fileDescriptor = import_node_fs4.default.openSync(lockPath, "wx");
+      import_node_fs4.default.closeSync(fileDescriptor);
+      writeLockPayload(lockPath, payload);
+      break;
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST") {
+        throw error;
+      }
+      const existing = readLockPayload(lockPath);
+      if (canBreakLock(existing)) {
+        import_node_fs4.default.rmSync(lockPath, { force: true });
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        throw new CliError(
+          "WORKSPACE_BUSY",
+          "Another write operation is already running for this workspace.",
+          EXIT_CODES.workspaceBusy,
+          {
+            hint: "Parallel reads should continue to work. For writes or auto-rebuilds, wait for the active write to finish and retry.",
+            details: {
+              lockPath,
+              holder: existing
+            }
+          }
+        );
+      }
+      sleepMs(LOCK_POLL_INTERVAL_MS);
+    }
+  }
+  const artificialDelay = Number(process.env.COMPANY_AGENT_WIKI_TEST_WRITE_LOCK_DELAY_MS || "0");
+  if (Number.isFinite(artificialDelay) && artificialDelay > 0) {
+    sleepMs(artificialDelay);
+  }
+  try {
+    return callback();
+  } finally {
+    const current = readLockPayload(lockPath);
+    if (current && current.token === payload.token) {
+      import_node_fs4.default.rmSync(lockPath, { force: true });
+    }
+  }
+}
+
 // src/lib/indexer.ts
 function openDatabase(databasePath, options3) {
   try {
@@ -7857,6 +8166,12 @@ function openDatabase(databasePath, options3) {
       options3?.readonly ? { readonly: true, fileMustExist: true } : void 0
     );
     database.pragma("busy_timeout = 5000");
+    if (options3?.readonly) {
+      database.pragma("query_only = 1");
+    } else {
+      database.pragma("journal_mode = WAL");
+      database.pragma("synchronous = NORMAL");
+    }
     return database;
   } catch (error) {
     throw coerceCliError(error, {
@@ -7875,11 +8190,11 @@ function closeDatabaseQuietly(database) {
 }
 function throwKnownDatabaseError(error, workspaceRoot) {
   const cliError = coerceCliError(error, {
-    sqliteLockHint: `Retry in a moment, serialize parallel CLI reads against ${import_node_path5.default.resolve(
+    sqliteLockHint: `Retry in a moment, serialize parallel CLI reads against ${import_node_path6.default.resolve(
       workspaceRoot
     )}, or rerun with --auto-rebuild after the current write finishes.`,
     sqliteLockDetails: {
-      workspaceRoot: import_node_path5.default.resolve(workspaceRoot)
+      workspaceRoot: import_node_path6.default.resolve(workspaceRoot)
     }
   });
   if (cliError) {
@@ -7961,8 +8276,8 @@ function collectRootSnapshot(rootId, rootPath, kind) {
   const entries = [];
   let latestMtimeMs = 0;
   for (const filePath of markdownFiles) {
-    const stats = import_node_fs4.default.statSync(filePath);
-    const relPath = import_node_path5.default.relative(rootPath, filePath);
+    const stats = import_node_fs5.default.statSync(filePath);
+    const relPath = import_node_path6.default.relative(rootPath, filePath);
     latestMtimeMs = Math.max(latestMtimeMs, Math.trunc(stats.mtimeMs));
     entries.push(`${relPath}|${stats.size}|${Math.trunc(stats.mtimeMs)}`);
   }
@@ -8150,13 +8465,13 @@ function matchesFilters(metadata, filters) {
   }
   return true;
 }
-function rebuildIndex(workspaceRoot) {
+function rebuildIndexUnlocked(workspaceRoot) {
   const config = loadWorkspaceConfig(workspaceRoot);
   const paths = resolveWorkspacePaths(workspaceRoot);
-  const tempDbPath = `${paths.indexDbPath}.next`;
+  const tempDbPath = `${paths.indexDbPath}.${process.pid}.${Date.now()}.${newBuildId()}.next`;
   const indexedAt = (/* @__PURE__ */ new Date()).toISOString();
   if (fileExists(tempDbPath)) {
-    import_node_fs4.default.unlinkSync(tempDbPath);
+    import_node_fs5.default.unlinkSync(tempDbPath);
   }
   let database;
   try {
@@ -8186,9 +8501,9 @@ function rebuildIndex(workspaceRoot) {
       insertRoot(database, snapshot, indexedAt);
       const markdownFiles = walkMarkdownFiles(rootPath);
       for (const filePath of markdownFiles) {
-        const rawContent = import_node_fs4.default.readFileSync(filePath, "utf8");
-        const stats = import_node_fs4.default.statSync(filePath);
-        const relPath = import_node_path5.default.relative(rootPath, filePath);
+        const rawContent = import_node_fs5.default.readFileSync(filePath, "utf8");
+        const stats = import_node_fs5.default.statSync(filePath);
+        const relPath = import_node_path6.default.relative(rootPath, filePath);
         const parsed = parseMarkdownDocument(filePath, relPath, root.id, rawContent, Math.trunc(stats.mtimeMs));
         insertDocument(database, parsed.document);
         insertSections(database, parsed.document, parsed.sections);
@@ -8199,8 +8514,8 @@ function rebuildIndex(workspaceRoot) {
     database.exec("INSERT INTO sections_fts(sections_fts) VALUES('optimize');");
     closeDatabaseQuietly(database);
     database = void 0;
-    replaceFileAtomic(paths.indexDbPath, import_node_fs4.default.readFileSync(tempDbPath));
-    import_node_fs4.default.unlinkSync(tempDbPath);
+    replaceFileAtomic(paths.indexDbPath, import_node_fs5.default.readFileSync(tempDbPath));
+    import_node_fs5.default.unlinkSync(tempDbPath);
     const manifest = {
       buildId,
       schemaVersion: INDEX_SCHEMA_VERSION,
@@ -8215,11 +8530,14 @@ function rebuildIndex(workspaceRoot) {
   } catch (error) {
     closeDatabaseQuietly(database);
     if (fileExists(tempDbPath)) {
-      import_node_fs4.default.rmSync(tempDbPath, { force: true });
+      import_node_fs5.default.rmSync(tempDbPath, { force: true });
     }
     throwKnownDatabaseError(error, workspaceRoot);
   }
 }
+function rebuildIndex(workspaceRoot) {
+  return withWorkspaceWriteLock(workspaceRoot, "index-rebuild", () => rebuildIndexUnlocked(workspaceRoot));
+}
 function readManifest(workspaceRoot) {
   const paths = resolveWorkspacePaths(workspaceRoot);
   if (!fileExists(paths.indexManifestPath)) {
@@ -8297,7 +8615,7 @@ function requireFreshIndex(workspaceRoot, options3) {
       "The workspace has not been indexed yet.",
       EXIT_CODES.indexMissing,
       {
-        hint: verification.hint || `Run: company-agent-wiki-cli index rebuild --workspace ${import_node_path5.default.resolve(workspaceRoot)}`
+        hint: verification.hint || `Run: company-agent-wiki-cli index rebuild --workspace ${import_node_path6.default.resolve(workspaceRoot)}`
       }
     );
   }
@@ -8310,7 +8628,7 @@ function requireFreshIndex(workspaceRoot, options3) {
       "The indexed snapshot no longer matches the current roots.",
       EXIT_CODES.indexStale,
       {
-        hint: `Run: company-agent-wiki-cli index rebuild --workspace ${import_node_path5.default.resolve(workspaceRoot)}`,
+        hint: `Run: company-agent-wiki-cli index rebuild --workspace ${import_node_path6.default.resolve(workspaceRoot)}`,
         details: verification.roots.filter((root) => !root.ok)
       }
     );
@@ -8619,8 +8937,8 @@ function getDocumentHeadings(workspaceRoot, docId, options3) {
 }
 
 // src/lib/onboarding.ts
-var import_node_fs5 = __toESM(require("node:fs"));
-var import_node_path6 = __toESM(require("node:path"));
+var import_node_fs6 = __toESM(require("node:fs"));
+var import_node_path7 = __toESM(require("node:path"));
 var COMPANY_ONBOARDING_DE_V1 = {
   profileId: "de-company-v1",
   locale: "de-DE",
@@ -9212,8 +9530,8 @@ function ensureKnownAnswerKeys(payload) {
   }
 }
 function isPathInsideWorkspace2(workspaceRoot, candidatePath) {
-  const relative = import_node_path6.default.relative(import_node_path6.default.resolve(workspaceRoot), import_node_path6.default.resolve(candidatePath));
-  return relative === "" || !relative.startsWith("..") && !import_node_path6.default.isAbsolute(relative);
+  const relative = import_node_path7.default.relative(import_node_path7.default.resolve(workspaceRoot), import_node_path7.default.resolve(candidatePath));
+  return relative === "" || !relative.startsWith("..") && !import_node_path7.default.isAbsolute(relative);
 }
 function resolveManagedRoot(workspaceRoot) {
   const config = loadWorkspaceConfig(workspaceRoot);
@@ -9236,12 +9554,12 @@ function resolveManagedRoot(workspaceRoot) {
   return resolvedPath;
 }
 function createDocument(workspaceRoot, managedRoot, relPath, id, title, type, tags, body, answeredAt, answeredBy) {
-  const absPath = import_node_path6.default.join(managedRoot, relPath);
+  const absPath = import_node_path7.default.join(managedRoot, relPath);
   return {
     docId: id,
     title,
     absPath,
-    relPath: import_node_path6.default.relative(workspaceRoot, absPath),
+    relPath: import_node_path7.default.relative(workspaceRoot, absPath),
     existed: false,
     content: `${renderFrontmatter({ id, title, type, tags, answeredAt, answeredBy })}${body.trimEnd()}
 `
@@ -9440,7 +9758,7 @@ function buildCompanyDocuments(workspaceRoot, normalized) {
 function loadCompanyOnboardingAnswers(answerFile) {
   const payload = readJsonFile(answerFile);
   ensureKnownAnswerKeys(payload);
-  const stats = import_node_fs5.default.statSync(answerFile);
+  const stats = import_node_fs6.default.statSync(answerFile);
   const normalized = normalizeAnswers(payload, stats.mtime.toISOString());
   if (normalized.profileId !== COMPANY_ONBOARDING_DE_V1.profileId) {
     throw new CliError(
@@ -9464,7 +9782,7 @@ function previewCompanyOnboarding(workspaceRoot, answerFile) {
     );
   }
   for (const document of materialized.documents) {
-    document.existed = import_node_fs5.default.existsSync(document.absPath);
+    document.existed = import_node_fs6.default.existsSync(document.absPath);
   }
   return {
     documents: materialized.documents,
@@ -9473,39 +9791,41 @@ function previewCompanyOnboarding(workspaceRoot, answerFile) {
   };
 }
 function applyCompanyOnboarding(options3) {
-  const workspaceRoot = import_node_path6.default.resolve(options3.workspaceRoot);
-  const answerFile = import_node_path6.default.resolve(options3.answerFile);
+  const workspaceRoot = import_node_path7.default.resolve(options3.workspaceRoot);
+  const answerFile = import_node_path7.default.resolve(options3.answerFile);
   const preview = previewCompanyOnboarding(workspaceRoot, answerFile);
   const warnings = [...preview.warnings];
   let indexBuildId;
   if (options3.execute) {
-    const seenPaths = /* @__PURE__ */ new Set();
-    for (const document of preview.documents) {
-      if (seenPaths.has(document.absPath)) {
-        throw new CliError(
-          "ONBOARDING_TARGET_CONFLICT",
-          `Multiple onboarding documents resolve to the same target path: ${document.relPath}`,
-          EXIT_CODES.validation
-        );
-      }
-      seenPaths.add(document.absPath);
-      if (document.existed && !options3.force) {
-        throw new CliError(
-          "ONBOARDING_TARGET_EXISTS",
-          `Target file already exists: ${document.relPath}`,
-          EXIT_CODES.validation,
-          { hint: "Use --force to overwrite generated onboarding files." }
-        );
+    const manifest = withWorkspaceWriteLock(workspaceRoot, "onboarding-apply", () => {
+      const seenPaths = /* @__PURE__ */ new Set();
+      for (const document of preview.documents) {
+        if (seenPaths.has(document.absPath)) {
+          throw new CliError(
+            "ONBOARDING_TARGET_CONFLICT",
+            `Multiple onboarding documents resolve to the same target path: ${document.relPath}`,
+            EXIT_CODES.validation
+          );
+        }
+        seenPaths.add(document.absPath);
+        if (document.existed && !options3.force) {
+          throw new CliError(
+            "ONBOARDING_TARGET_EXISTS",
+            `Target file already exists: ${document.relPath}`,
+            EXIT_CODES.validation,
+            { hint: "Use --force to overwrite generated onboarding files." }
+          );
+        }
       }
-    }
-    for (const document of preview.documents) {
-      ensureDir(import_node_path6.default.dirname(document.absPath));
-      if (document.existed) {
-        warnings.push(`Overwriting existing file: ${document.relPath}`);
+      for (const document of preview.documents) {
+        ensureDir(import_node_path7.default.dirname(document.absPath));
+        if (document.existed) {
+          warnings.push(`Overwriting existing file: ${document.relPath}`);
+        }
+        replaceFileAtomic(document.absPath, document.content);
       }
-      replaceFileAtomic(document.absPath, document.content);
-    }
-    const manifest = rebuildIndex(workspaceRoot);
+      return rebuildIndexUnlocked(workspaceRoot);
+    });
     indexBuildId = manifest.buildId;
   }
   return {
@@ -9568,7 +9888,7 @@ function printJson(value) {
 }
 
 // src/lib/server.ts
-var import_node_fs6 = __toESM(require("node:fs"));
+var import_node_fs7 = __toESM(require("node:fs"));
 var import_node_http = __toESM(require("node:http"));
 var import_node_url = require("node:url");
 
@@ -12027,6 +12347,7 @@ function getHttpStatusCode(error) {
     case "INDEX_STALE":
       return 409;
     case "SQLITE_LOCKED":
+    case "WORKSPACE_BUSY":
       return 423;
     default:
       return 500;
@@ -12133,7 +12454,7 @@ function startServer(workspaceRoot, port, options3) {
           return;
         }
         const resolved = resolveDocumentById(workspaceRoot, docId, { autoRebuild: options3?.autoRebuild });
-        const rawMarkdown = import_node_fs6.default.readFileSync(resolved.absPath, "utf8");
+        const rawMarkdown = import_node_fs7.default.readFileSync(resolved.absPath, "utf8");
         sendJson(response, {
           ok: true,
           data: {
@@ -12189,14 +12510,16 @@ function startServer(workspaceRoot, port, options3) {
 // src/index.ts
 function assertWorkspace(workspacePath) {
   if (workspacePath?.trim()) {
-    return import_node_path7.default.resolve(workspacePath);
+    const resolved = import_node_path8.default.resolve(workspacePath);
+    rememberWorkspaceGlobally(resolved, { setDefault: true, source: "runtime" });
+    return resolved;
   }
-  const detected = detectWorkspaceRoot(process.cwd());
-  if (detected) {
-    return detected;
+  const selection = resolveWorkspaceSelection(process.cwd());
+  if (selection.workspaceRoot) {
+    return selection.workspaceRoot;
   }
   throw new CliError("WORKSPACE_REQUIRED", "Missing --workspace option and no workspace was detected from the current directory.", EXIT_CODES.usage, {
-    hint: "Pass --workspace /absolute/path or run the command from a directory inside the private workspace."
+    hint: `Pass --workspace /absolute/path, run the command from a directory inside the private workspace, or register one globally in ${getGlobalRegistryPath()}.`
   });
 }
 function printHumanChecks(checks) {
@@ -12281,8 +12604,10 @@ program2.command("about").description("Show CLI runtime metadata and common Code
     cliName: CLI_NAME,
     schemaVersion: CLI_SCHEMA_VERSION,
     codexHome,
-    codexShimPath: import_node_path7.default.join(codexHome, "bin", CLI_NAME),
-    cwdWorkspace: detectWorkspaceRoot(process.cwd()) || null
+    codexShimPath: import_node_path8.default.join(codexHome, "bin", CLI_NAME),
+    cwdWorkspace: detectWorkspaceRoot(process.cwd()) || null,
+    globalRegistryPath: getGlobalRegistryPath(),
+    resolvedWorkspace: resolveWorkspaceSelection(process.cwd())
   };
   if (options3.json) {
     printJson(envelope("about", data));
@@ -12298,10 +12623,101 @@ program2.command("about").description("Show CLI runtime metadata and common Code
     process.stdout.write(`  detected workspace: ${data.cwdWorkspace}
 `);
   }
+  if (data.resolvedWorkspace.workspaceRoot && data.resolvedWorkspace.source !== "cwd") {
+    process.stdout.write(`  resolved workspace: ${data.resolvedWorkspace.workspaceRoot} (${data.resolvedWorkspace.source})
+`);
+  }
+  process.stdout.write(`  global registry: ${data.globalRegistryPath}
+`);
+});
+var workspace = new Command("workspace").description("Manage global workspace discovery");
+workspace.command("current").description("Show the currently resolved workspace and discovery source").option("--json", "Emit JSON output", false).action((options3) => {
+  const selection = resolveWorkspaceSelection(process.cwd());
+  const data = {
+    workspaceRoot: selection.workspaceRoot || null,
+    source: selection.source || null,
+    registryPath: selection.registryPath,
+    defaultWorkspace: selection.defaultWorkspace || null
+  };
+  if (options3.json) {
+    printJson(envelope("workspace current", data));
+    return;
+  }
+  if (data.workspaceRoot) {
+    process.stdout.write(`Resolved workspace: ${data.workspaceRoot}
+`);
+    process.stdout.write(`Source: ${data.source}
+`);
+  } else {
+    process.stdout.write("No workspace resolved.\n");
+  }
+  process.stdout.write(`Global registry: ${data.registryPath}
+`);
+  if (data.defaultWorkspace) {
+    process.stdout.write(`Default workspace: ${data.defaultWorkspace}
+`);
+  }
+});
+workspace.command("list").description("List globally registered workspaces").option("--json", "Emit JSON output", false).action((options3) => {
+  const result = listRegisteredWorkspaces();
+  if (options3.json) {
+    printJson(envelope("workspace list", result));
+    return;
+  }
+  process.stdout.write(`Global registry: ${result.registryPath}
+`);
+  if (result.workspaces.length === 0) {
+    process.stdout.write("No registered workspaces.\n");
+    return;
+  }
+  for (const item of result.workspaces) {
+    const defaultMarker = result.defaultWorkspace === item.path ? " [default]" : "";
+    const existsMarker = item.exists ? "" : " [missing]";
+    process.stdout.write(`- ${item.label}${defaultMarker}${existsMarker}
+`);
+    process.stdout.write(`  ${item.path}
+`);
+  }
+});
+workspace.command("register").description("Register an existing workspace globally for other agents").requiredOption("--workspace <path>", "Absolute or relative workspace path").option("--default", "Also mark this workspace as the global default", false).option("--json", "Emit JSON output", false).action((options3) => {
+  const entry = registerWorkspaceGlobally(import_node_path8.default.resolve(options3.workspace), {
+    setDefault: Boolean(options3.default),
+    source: "manual"
+  });
+  const result = {
+    registryPath: getGlobalRegistryPath(),
+    entry
+  };
+  if (options3.json) {
+    printJson(envelope("workspace register", result));
+    return;
+  }
+  process.stdout.write(`Registered workspace: ${entry.path}
+`);
+  if (options3.default) {
+    process.stdout.write("This workspace is now the global default.\n");
+  }
+});
+workspace.command("use").description("Set a registered workspace as the global default").requiredOption("--workspace <path>", "Absolute or relative workspace path").option("--json", "Emit JSON output", false).action((options3) => {
+  const entry = registerWorkspaceGlobally(import_node_path8.default.resolve(options3.workspace), {
+    setDefault: true,
+    source: "manual"
+  });
+  const result = {
+    registryPath: getGlobalRegistryPath(),
+    defaultWorkspace: entry.path
+  };
+  if (options3.json) {
+    printJson(envelope("workspace use", result));
+    return;
+  }
+  process.stdout.write(`Global default workspace: ${entry.path}
+`);
 });
+program2.addCommand(workspace);
 program2.command("setup").description("Workspace setup commands").addCommand(
   new Command("workspace").requiredOption("--workspace <path>", "Absolute or relative workspace path").option("--git-init", "Initialize a local Git repository", false).option("--git-remote <url>", "Configure a Git remote URL").option("--no-starter-docs", "Skip creation of starter Markdown documents").option("--force", "Rewrite an existing scaffold", false).option("--json", "Emit JSON output", false).action((options3) => {
-    const workspaceRoot = import_node_path7.default.resolve(options3.workspace);
+    const workspaceRoot = import_node_path8.default.resolve(options3.workspace);
     const result = setupWorkspace({
       workspaceRoot,
       gitInit: Boolean(options3.gitInit),
@@ -12555,8 +12971,8 @@ program2.command("read").option("--workspace <path>", "Workspace path. Optional
   const metadataResult = options3.docId ? getDocumentMetadataById(workspaceRoot, options3.docId, {
     autoRebuild: Boolean(options3.autoRebuild)
   }) : (() => {
-    const candidatePath = import_node_path7.default.isAbsolute(options3.path) ? options3.path : import_node_path7.default.join(workspaceRoot, options3.path);
-    return getDocumentMetadataByPath(workspaceRoot, import_node_path7.default.resolve(candidatePath), {
+    const candidatePath = import_node_path8.default.isAbsolute(options3.path) ? options3.path : import_node_path8.default.join(workspaceRoot, options3.path);
+    return getDocumentMetadataByPath(workspaceRoot, import_node_path8.default.resolve(candidatePath), {
       autoRebuild: Boolean(options3.autoRebuild)
     });
   })();
@@ -12584,7 +13000,7 @@ program2.command("read").option("--workspace <path>", "Workspace path. Optional
     }
     return;
   }
-  const rawMarkdown = import_node_fs7.default.readFileSync(metadataResult.metadata.absPath, "utf8");
+  const rawMarkdown = import_node_fs8.default.readFileSync(metadataResult.metadata.absPath, "utf8");
   if (options3.json) {
     printJson(
       envelope(
@@ -12606,7 +13022,7 @@ program2.command("read").option("--workspace <path>", "Workspace path. Optional
 });
 program2.command("history").option("--workspace <path>", "Workspace path. Optional when current directory is already inside a workspace.").option("--doc-id <id>", "Indexed document identifier").option("--path <path>", "Absolute or workspace-relative document path").option("--limit <number>", "Maximum number of commits", "20").option("--json", "Emit JSON output", false).action((options3) => {
   const workspaceRoot = assertWorkspace(options3.workspace);
-  const resolvedPath = options3.docId ? resolveDocumentById(workspaceRoot, options3.docId).absPath : import_node_path7.default.resolve(import_node_path7.default.isAbsolute(options3.path) ? options3.path : import_node_path7.default.join(workspaceRoot, options3.path));
+  const resolvedPath = options3.docId ? resolveDocumentById(workspaceRoot, options3.docId).absPath : import_node_path8.default.resolve(import_node_path8.default.isAbsolute(options3.path) ? options3.path : import_node_path8.default.join(workspaceRoot, options3.path));
   const history = getGitHistory(resolvedPath, Number(options3.limit));
   if (options3.json) {
     printJson(envelope("history", { path: resolvedPath, history }));
@@ -12619,7 +13035,7 @@ program2.command("history").option("--workspace <path>", "Workspace path. Option
 });
 program2.command("diff").option("--workspace <path>", "Workspace path. Optional when current directory is already inside a workspace.").option("--doc-id <id>", "Indexed document identifier").option("--path <path>", "Absolute or workspace-relative document path").option("--base <ref>", "Base Git ref", "HEAD").option("--compare <ref>", "Optional compare ref").option("--json", "Emit JSON output", false).action((options3) => {
   const workspaceRoot = assertWorkspace(options3.workspace);
-  const resolvedPath = options3.docId ? resolveDocumentById(workspaceRoot, options3.docId).absPath : import_node_path7.default.resolve(import_node_path7.default.isAbsolute(options3.path) ? options3.path : import_node_path7.default.join(workspaceRoot, options3.path));
+  const resolvedPath = options3.docId ? resolveDocumentById(workspaceRoot, options3.docId).absPath : import_node_path8.default.resolve(import_node_path8.default.isAbsolute(options3.path) ? options3.path : import_node_path8.default.join(workspaceRoot, options3.path));
   const diff = getGitDiff(resolvedPath, options3.base, options3.compare);
   if (options3.json) {
     printJson(envelope("diff", { path: resolvedPath, diff }));