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

package/README.md

@@ -59,6 +59,12 @@ The private knowledge workspace lives outside this public code repository. It ma
 The SQLite index is local and derived. It is rebuilt by the CLI and must not be treated as the source of truth.
 It lives inside the private workspace under `.company-agent-wiki/index.sqlite`, but it is intentionally kept out of Git by default because it is rebuildable, binary and noisy in diffs.
 
+The workspace path can also be stored globally for other agents. Phase 1 now keeps a per-user workspace registry:
+
+- macOS: `~/Library/Application Support/company-agent-wiki/workspaces.json`
+- Windows: `%APPDATA%\\company-agent-wiki\\workspaces.json`
+- Linux: `${XDG_CONFIG_HOME:-~/.config}/company-agent-wiki/workspaces.json`
+
 ## Install
 
 ```bash
@@ -107,6 +113,8 @@ company-agent-wiki-cli setup workspace \
   --git-remote git@github.com:your-org/private-company-knowledge.git
 ```
 
+This now also registers the workspace globally and marks it as the default for later agents.
+
 3. Inspect the local state:
 
 ```bash
@@ -138,6 +146,16 @@ company-agent-wiki-cli serve --workspace /absolute/path/to/private-company-knowl
 The read-only web view is served by the installed CLI process. The private workspace itself contains Markdown, metadata and the local derived index, but no standalone frontend application.
 
 If the current shell is already inside a private workspace, runtime commands such as `doctor`, `verify`, `search`, `route`, `read`, `history`, `diff` and `serve` may omit `--workspace`.
+If not, the CLI can now also fall back to the globally registered default workspace.
+
+Useful discovery commands:
+
+```bash
+company-agent-wiki-cli workspace current --json
+company-agent-wiki-cli workspace list --json
+company-agent-wiki-cli workspace register --workspace /absolute/path/to/private-company-knowledge --default --json
+company-agent-wiki-cli workspace use --workspace /absolute/path/to/private-company-knowledge --json
+```
 
 By default `setup workspace` also creates starter Markdown documents such as `wiki-start-here.md`, `company-profile.md`, `organisation-und-rollen.md`, `systeme-und-tools.md`, `kernprozesse.md`, `projekte-und-roadmap.md` and `glossar.md`. Use `--no-starter-docs` only if you intentionally want an almost empty scaffold.
 
@@ -169,15 +187,16 @@ This repository is publishable code only. It must never contain:
 
 The actual knowledge workspace is separate and private. The human must provide:
 
-- the private workspace path
+- the private workspace path at least once
 - if desired, the private Git remote URL
 - access rights to that remote
 
-The agent can handle local scaffolding, root registration and index rebuilds, but it should not invent remotes or inject private data into this repository.
+The agent can handle local scaffolding, root registration, global workspace registration and index rebuilds, but it should not invent remotes or inject private data into this repository.
 
 ## Phase 1 Commands
 
 - `setup workspace`: scaffold a private workspace and optionally initialize Git
+- `workspace current|list|register|use`: inspect or manage the global workspace registry for other agents
 - `doctor`: inspect the local runtime and workspace state
 - `verify`: check whether the current roots still match the indexed snapshot
 - `roots add`: register another local Markdown root
@@ -247,7 +266,7 @@ Then:
 
 ## Concurrency Note
 
-The SQLite index is intentionally local and rebuildable. For the same workspace, avoid running multiple `search`, `route`, `read`, `history` and `diff` calls in parallel when possible. The CLI now uses a busy timeout and a lock-specific error, but agent-side serialization is still the safer Phase-1 operating mode.
+The SQLite index is intentionally local and rebuildable. Parallel reads such as `search`, `route`, `read`, `history` and `diff` are now an explicit Phase-1 goal and should work across multiple agents. Write paths such as `index rebuild` and onboarding apply are serialized per workspace through a local write lock, so concurrent writes queue behind the active writer instead of colliding.
 
 ## What Phase 1 Does Not Do
 

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
@@ -7340,8 +7343,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 +7391,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 +7912,7 @@ function setupWorkspace(options3) {
       }
     }
   }
+  registerWorkspaceGlobally(paths.workspaceRoot, { setDefault: true, source: "setup" });
   return {
     workspaceRoot: paths.workspaceRoot,
     configPath: paths.configPath,
@@ -7743,7 +7922,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 +7956,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 +7978,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 +8005,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 +8042,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 +8165,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 +8189,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 +8275,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 +8464,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 +8500,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 +8513,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 +8529,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 +8614,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 +8627,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 +8936,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 +9529,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 +9553,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 +9757,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 +9781,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 +9790,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 +9887,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 +12346,7 @@ function getHttpStatusCode(error) {
     case "INDEX_STALE":
       return 409;
     case "SQLITE_LOCKED":
+    case "WORKSPACE_BUSY":
       return 423;
     default:
       return 500;
@@ -12133,7 +12453,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 +12509,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 +12603,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 +12622,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 +12970,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 +12999,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 +13021,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 +13034,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 }));

package/dist/installer.js

@@ -3473,7 +3473,7 @@ var {
 var CLI_NAME = "company-agent-wiki-cli";
 var INSTALLER_NAME = "company-agent-wiki-skill";
 var SKILL_NAME = "company-agent-wiki-cli";
-var CLI_SCHEMA_VERSION = "2026-04-12";
+var CLI_SCHEMA_VERSION = "2026-04-13";
 var EXIT_CODES = {
   ok: 0,
   usage: 1,
@@ -3484,6 +3484,7 @@ var EXIT_CODES = {
   notFound: 6,
   git: 7,
   sqliteLocked: 8,
+  workspaceBusy: 9,
   runtime: 10
 };
 

package/knowledge/ARCHITECTURE.md

@@ -45,7 +45,8 @@ The index and manifest are derived artifacts and should stay ignored in the priv
 7. `read --metadata --headings` supports a metadata-first retrieval pass before the full Markdown is loaded.
 8. `search`, `route` and `read` either enforce a fresh index or can explicitly auto-rebuild when `--auto-rebuild` is set.
 9. Runtime commands may detect the current workspace automatically when the shell is already inside a private workspace.
-10. `serve` exposes the same read-only data through a local web view and now distinguishes `missing`, `stale` and `ok` states with a rebuild action.
+10. A global per-user workspace registry stores known workspace paths and a default workspace so other agents can resolve the knowledge location automatically on macOS, Windows and Linux.
+11. `serve` exposes the same read-only data through a local web view and now distinguishes `missing`, `stale` and `ok` states with a rebuild action.
 
 ## Onboarding Model
 
@@ -73,6 +74,8 @@ Reads are pinned to the latest successful `build_id`. If current root snapshots
 
 The SQLite runtime also uses a busy timeout and returns a specific `SQLITE_LOCKED` error for transient contention instead of surfacing a generic runtime failure.
 
+Phase 1 now also adds a workspace-local write lock. The lock serializes rebuilds and other write flows per workspace, while parallel readers continue against the current derived index.
+
 ## Metadata-First Retrieval
 
 Phase 1 now explicitly supports a two-step retrieval model:
@@ -82,6 +85,21 @@ Phase 1 now explicitly supports a two-step retrieval model:
 
 This keeps the agent loop lighter and encourages stronger filenames plus front matter without forcing a rigid folder taxonomy.
 
+## Global Workspace Discovery
+
+Phase 1 now persists workspace discovery outside the private workspace itself:
+
+- macOS: `~/Library/Application Support/company-agent-wiki/workspaces.json`
+- Windows: `%APPDATA%\\company-agent-wiki\\workspaces.json`
+- Linux: `${XDG_CONFIG_HOME:-~/.config}/company-agent-wiki/workspaces.json`
+
+The registry stores known workspace paths plus a default workspace. `setup workspace` registers the workspace automatically. Runtime commands prefer:
+
+1. explicit `--workspace`
+2. current-directory detection
+3. global default workspace
+4. the single registered workspace, if exactly one exists
+
 ## Git Model
 
 Phase 1 uses Git for:

package/knowledge/KNOWN_LIMITATIONS.md

@@ -15,7 +15,8 @@
 - Auto-rebuild is opt-in. Without `--auto-rebuild`, stale or missing indexes still block retrieval on purpose.
 - Search quality depends on document structure and heading hygiene in the source Markdown.
 - Front-matter filters are currently focused on common fields such as `type`, `status`, `tags`, `project`, `department`, `owners` and `systems`; there is not yet a generic arbitrary-field query language.
-- The SQLite runtime is more tolerant of transient contention now, but the same workspace should still not be hammered by multiple parallel agent reads if that can be avoided.
+- Parallel reads are supported, but there is still only one active write path per workspace at a time.
+- Long-running rebuilds can delay later auto-rebuild requests because they queue behind the same workspace lock.
 - Search JSON now exposes a normalized `score` plus `rawScore`; the normalized value is better for agents, but it is still only a ranking aid, not a calibrated relevance percentage.
 
 ## Git Model
@@ -28,3 +29,4 @@
 
 - The CLI can initialize a private Git remote URL, but it does not validate remote policy or access controls.
 - The package does not enforce OS-level filesystem permissions; the workspace owner must place the private workspace in a properly protected location.
+- The global workspace registry is only a discovery layer, not an access-control boundary. Any agent running as the same local user can read the registered workspace path.

package/knowledge/RELEASE_CHECKLIST.md

@@ -118,6 +118,25 @@ npm_config_cache="$CACHE" npx -y @codecell-germany/company-agent-wiki-skill@0.1.
 "$TMP/codex/bin/company-agent-wiki-cli" --help
 ```
 
+Falls `npm view` direkt nach dem Publish kurzfristig noch `404` liefert, zusätzlich die Registry-Tarball-URL prüfen und daraus den Install-Smoke fahren:
+
+```bash
+curl -I https://registry.npmjs.org/@codecell-germany/company-agent-wiki-skill/-/company-agent-wiki-skill-0.1.0.tgz
+TMP="$(mktemp -d)"
+cd "$TMP"
+npx -y -p https://registry.npmjs.org/@codecell-germany/company-agent-wiki-skill/-/company-agent-wiki-skill-0.1.0.tgz company-agent-wiki-cli --help
+```
+
+Praktisches Learning aus diesem Release:
+
+- `npm dist-tag ls` und die direkte Tarball-URL können bereits korrekt funktionieren, während `npm view` bzw. die Packument-Auflösung noch kurz hinterherhinkt.
+- Für die Veröffentlichungsfreigabe reicht deshalb im Zweifel:
+  - erfolgreicher `npm publish`
+  - `npm access get status <package>` = `public`
+  - `npm dist-tag ls <package>` zeigt `latest`
+  - Tarball-URL liefert `200`
+  - CLI-/Installer-Smoke direkt von der Tarball-URL funktioniert
+
 ## skills.sh Verification
 
 Nach GitHub-Publish:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codecell-germany/company-agent-wiki-skill",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Context is king: agent-first local company knowledge workspace with metadata-first retrieval, Markdown as truth, SQLite-indexed front matter, Git-aware verification, and a Codex skill installer.",
   "private": false,
   "license": "MIT",

package/skills/company-agent-wiki-cli/SKILL.md

@@ -17,7 +17,7 @@ Use this skill when the task is about a private company knowledge workspace buil
 - The public CLI binary is `company-agent-wiki-cli`.
 - The actual company knowledge workspace is private and lives outside the public code repository.
 - The private workspace may be the current dedicated local folder; it just must not be the public skill/CLI repo.
-- The human should provide the workspace path and, if desired, the private Git remote URL. If the current folder is already inside a private workspace, the CLI may detect it automatically.
+- The human should provide the workspace path at least once and, if desired, the private Git remote URL. After setup or manual registration, the CLI stores the workspace path in a global per-user registry so later agents can resolve it automatically.
 - Runtime discovery matters. Before relying on the CLI, verify which path is actually available.
 - In Codex, the most reliable fallback is usually the installed shim under `$CODEX_HOME/bin` or `~/.codex/bin`.
 - The `npx -p @codecell-germany/company-agent-wiki-skill ...` path only works after the npm package is really published.
@@ -58,7 +58,15 @@ npx -p @codecell-germany/company-agent-wiki-skill company-agent-wiki-cli --help
 company-agent-wiki-cli setup workspace --workspace /absolute/path/to/private-company-knowledge --git-init
 ```
 
-This creates starter Markdown documents by default. Use `--no-starter-docs` only when you explicitly want a nearly empty workspace.
+This creates starter Markdown documents by default and registers the workspace globally for future agents. Use `--no-starter-docs` only when you explicitly want a nearly empty workspace.
+
+If the workspace already exists, inspect or register it explicitly:
+
+```bash
+company-agent-wiki-cli workspace current --json
+company-agent-wiki-cli workspace list --json
+company-agent-wiki-cli workspace register --workspace /absolute/path/to/private-company-knowledge --default --json
+```
 
 3. Run health checks:
 
@@ -234,13 +242,19 @@ company-agent-wiki-cli onboarding company \
 - The local SQLite file lives in the workspace, but should stay out of Git by default.
 - If the CLI reports `INDEX_STALE`, do not ignore it. Run `index rebuild` or use an explicit `--auto-rebuild` path.
 - For agent workflows, prefer `--auto-rebuild` on `search`, `route`, `read` and `serve` unless you explicitly want strict stale-index failures.
-- Avoid parallel `search`, `route`, `read`, `history` and `diff` calls against the same workspace when possible. SQLite contention is now surfaced clearly, but agent-side serialization is still the safer Phase-1 pattern.
+- Parallel `search`, `route`, `read`, `history` and `diff` calls against the same workspace are now intended to work.
+- Write paths are serialized per workspace. If one agent is rebuilding the index or applying onboarding writes, other write paths wait behind that workspace lock instead of colliding.
 - Do not put private company knowledge into the public code repository.
 - Use the read-only web view only for browsing, not editing.
 - The company onboarding questionnaire is optional. Every answer may be skipped, answered with “nein” or marked as unknown.
 - Onboarding writes are explicit. Do not assume preview mode changes files; only `--execute` writes draft onboarding Markdown and rebuilds the derived index.
 - If CLI discovery fails, do not pretend the documented command works. First resolve a real executable path.
 - If the current folder already contains `.company-agent-wiki/workspace.json`, you may omit `--workspace` and let the CLI detect the workspace root automatically.
+- If the current folder is not inside the workspace, the CLI may still resolve the globally registered default workspace.
+- The global workspace registry lives per user:
+  - macOS: `~/Library/Application Support/company-agent-wiki/workspaces.json`
+  - Windows: `%APPDATA%\\company-agent-wiki\\workspaces.json`
+  - Linux: `${XDG_CONFIG_HOME:-~/.config}/company-agent-wiki/workspaces.json`
 
 ## References
 

package/skills/company-agent-wiki-cli/references/agent-onboarding.md

@@ -7,6 +7,8 @@
 "$HOME/.codex/bin/company-agent-wiki-cli" --help
 company-agent-wiki-cli --help
 company-agent-wiki-cli setup workspace --workspace /absolute/path --git-init
+company-agent-wiki-cli workspace current --json
+company-agent-wiki-cli workspace list --json
 company-agent-wiki-cli onboarding company
 company-agent-wiki-cli onboarding company --workspace /absolute/path --answers-file /absolute/path/to/answers.json
 company-agent-wiki-cli onboarding company --workspace /absolute/path --answers-file /absolute/path/to/answers.json --execute
@@ -24,6 +26,8 @@ Only after the company profile is clear enough and these checks succeed should y
 company-agent-wiki-cli setup workspace --workspace /absolute/path --git-init
 ```
 
+This setup step also registers the workspace globally so later agents can find it without asking for the same path again.
+
 If the human has a private Git remote ready:
 
 ```bash
@@ -49,6 +53,8 @@ For frequent edits, the authoring loop can also use the guarded auto-rebuild pat
 company-agent-wiki-cli search "KI-Telefonassistent" --workspace /absolute/path --auto-rebuild --json
 ```
 
+Parallel reads are allowed. If a write path such as `index rebuild` is already running, later writes wait behind the same workspace lock.
+
 After candidate routing, prefer metadata-first reading:
 
 ```bash

package/skills/company-agent-wiki-cli/references/command-cheatsheet.md

@@ -7,6 +7,10 @@
 "$HOME/.codex/bin/company-agent-wiki-cli" --help
 company-agent-wiki-cli about --json
 company-agent-wiki-cli setup workspace --workspace /absolute/path --git-init
+company-agent-wiki-cli workspace current --json
+company-agent-wiki-cli workspace list --json
+company-agent-wiki-cli workspace register --workspace /absolute/path --default --json
+company-agent-wiki-cli workspace use --workspace /absolute/path --json
 company-agent-wiki-cli onboarding company
 company-agent-wiki-cli onboarding company --workspace /absolute/path --answers-file /absolute/path/to/answers.json
 company-agent-wiki-cli onboarding company --workspace /absolute/path --answers-file /absolute/path/to/answers.json --execute
@@ -23,6 +27,7 @@ company-agent-wiki-cli verify --workspace /absolute/path --json
 ```
 
 If you are already inside the private workspace, `doctor`, `verify`, `search`, `route`, `read`, `history`, `diff` and `serve` may omit `--workspace`.
+If not, the CLI can also use the globally registered default workspace.
 
 ## Retrieval
 

package/skills/company-agent-wiki-cli/references/overview.md

@@ -16,6 +16,7 @@
 ## Main Commands
 
 - `setup workspace`
+- `workspace current|list|register|use`
 - `onboarding company`
 - `doctor`
 - `verify`
@@ -32,10 +33,13 @@
 ## Expected Workflow
 
 1. Set up the private workspace.
-2. Use the starter documents or run `onboarding company`, then preview or apply the generated onboarding Markdown from an answers file.
-3. Register any additional Markdown roots.
-4. Rebuild the index.
-5. Verify that the snapshot is fresh. On a brand-new workspace `verify` reports `missing` instead of failing hard.
-6. Search or route to the right document. For active authoring loops, prefer `--auto-rebuild` and front-matter filters such as `--type`, `--project` or `--department`.
-7. Inspect metadata and headings with `read --metadata --headings --auto-rebuild`.
-8. Read the full source document or use the read-only web view.
+2. The workspace is registered globally so other agents can discover it automatically.
+3. Use the starter documents or run `onboarding company`, then preview or apply the generated onboarding Markdown from an answers file.
+4. Register any additional Markdown roots.
+5. Rebuild the index.
+6. Verify that the snapshot is fresh. On a brand-new workspace `verify` reports `missing` instead of failing hard.
+7. Search or route to the right document. For active authoring loops, prefer `--auto-rebuild` and front-matter filters such as `--type`, `--project` or `--department`.
+8. Inspect metadata and headings with `read --metadata --headings --auto-rebuild`.
+9. Read the full source document or use the read-only web view.
+
+Parallel reads are supported. Writes are serialized per workspace.

package/skills/company-agent-wiki-cli/references/workspace-first-run.md

@@ -5,6 +5,8 @@
 - a private workspace folder path
 - if desired, a private Git remote URL
 
+The workspace path only has to be provided once. After setup or manual registration, the CLI stores it in a per-user global registry for later agents.
+
 ## What the Agent Can Safely Do
 
 - scaffold the local workspace
@@ -13,6 +15,7 @@
 - create the default starter documents for the first useful company knowledge
 - preview or apply onboarding-generated starter Markdown from an answers file
 - register Markdown roots
+- register the workspace globally for later agents
 - rebuild the derived index
 - verify freshness or a still-missing first index
 - run the read-only web view via `company-agent-wiki-cli serve --workspace /absolute/path --port 4187`
@@ -30,6 +33,13 @@ company-agent-wiki-cli --help
 The package-based `npx` path is only valid once the npm package is published.
 
 If the current folder is already inside a private workspace, runtime commands may omit `--workspace`.
+If not, inspect or update the global registry:
+
+```bash
+company-agent-wiki-cli workspace current --json
+company-agent-wiki-cli workspace list --json
+company-agent-wiki-cli workspace register --workspace /absolute/path --default --json
+```
 
 ## What Must Stay Out of This Public Repo