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

package/dist/index.js

@@ -1189,7 +1189,7 @@ var require_command = __commonJS({
   "node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter = require("node:events").EventEmitter;
     var childProcess = require("node:child_process");
-    var path9 = require("node:path");
+    var path10 = require("node:path");
     var fs9 = require("node:fs");
     var process2 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -2202,9 +2202,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path9.resolve(baseDir, baseName);
+          const localBin = path10.resolve(baseDir, baseName);
           if (fs9.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path9.extname(baseName))) return void 0;
+          if (sourceExt.includes(path10.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs9.existsSync(`${localBin}${ext}`)
           );
@@ -2222,17 +2222,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path9.resolve(
-            path9.dirname(resolvedScriptPath),
+          executableDir = path10.resolve(
+            path10.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path9.basename(
+            const legacyName = path10.basename(
               this._scriptPath,
-              path9.extname(this._scriptPath)
+              path10.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2243,7 +2243,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path9.extname(executableFile));
+        launchWithNode = sourceExt.includes(path10.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 = path9.basename(filename, path9.extname(filename));
+        this._name = path10.basename(filename, path10.extname(filename));
         return this;
       }
       /**
@@ -3172,9 +3172,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path10) {
-        if (path10 === void 0) return this._executableDir;
-        this._executableDir = path10;
+      executableDir(path11) {
+        if (path11 === void 0) return this._executableDir;
+        this._executableDir = path11;
         return this;
       }
       /**
@@ -6937,7 +6937,7 @@ var require_gray_matter = __commonJS({
 
 // src/index.ts
 var import_node_fs8 = __toESM(require("node:fs"));
-var import_node_path8 = __toESM(require("node:path"));
+var import_node_path9 = __toESM(require("node:path"));
 
 // node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
@@ -6959,6 +6959,7 @@ var {
 // src/lib/constants.ts
 var PACKAGE_NAME = "@codecell-germany/company-agent-wiki-skill";
 var CLI_NAME = "company-agent-wiki-cli";
+var SKILL_NAME = "company-agent-wiki-cli";
 var WORKSPACE_INTERNAL_DIR = ".company-agent-wiki";
 var WORKSPACE_CONFIG_FILE = "workspace.json";
 var INDEX_DB_FILE = "index.sqlite";
@@ -7141,10 +7142,8 @@ function getGitDiff(filePath, baseRef, compareRef) {
   return runGit(args, resolved.repoRoot, true);
 }
 
-// src/lib/indexer.ts
-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/install.ts
+var import_node_path3 = __toESM(require("node:path"));
 
 // src/lib/fs-utils.ts
 var import_node_fs2 = __toESM(require("node:fs"));
@@ -7161,12 +7160,13 @@ function writeJsonFile(targetPath, value) {
 `);
 }
 function writeJsonAtomic(targetPath, value) {
-  const tempPath = `${targetPath}.tmp`;
+  const tempPath = `${targetPath}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
+  ensureDir(import_node_path2.default.dirname(targetPath));
   writeJsonFile(tempPath, value);
   import_node_fs2.default.renameSync(tempPath, targetPath);
 }
 function replaceFileAtomic(targetPath, content) {
-  const tempPath = `${targetPath}.tmp`;
+  const tempPath = `${targetPath}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
   ensureDir(import_node_path2.default.dirname(targetPath));
   import_node_fs2.default.writeFileSync(tempPath, content);
   import_node_fs2.default.renameSync(tempPath, targetPath);
@@ -7203,6 +7203,25 @@ function walkMarkdownFiles(rootPath) {
   return files.sort();
 }
 
+// src/lib/install.ts
+function detectInstalledRuntimeHome(runtimeDir) {
+  const normalized = import_node_path3.default.resolve(runtimeDir);
+  const skillDir = import_node_path3.default.dirname(normalized);
+  const toolsDir = import_node_path3.default.dirname(skillDir);
+  if (import_node_path3.default.basename(normalized) !== "dist") {
+    return void 0;
+  }
+  if (import_node_path3.default.basename(skillDir) !== SKILL_NAME || import_node_path3.default.basename(toolsDir) !== "tools") {
+    return void 0;
+  }
+  return import_node_path3.default.dirname(toolsDir);
+}
+
+// src/lib/indexer.ts
+var import_node_fs5 = __toESM(require("node:fs"));
+var import_node_path7 = __toESM(require("node:path"));
+var import_better_sqlite3 = __toESM(require("better-sqlite3"));
+
 // src/lib/hash.ts
 var import_node_crypto = require("node:crypto");
 function sha256(input) {
@@ -7213,7 +7232,7 @@ function newBuildId() {
 }
 
 // src/lib/markdown.ts
-var import_node_path3 = __toESM(require("node:path"));
+var import_node_path4 = __toESM(require("node:path"));
 var import_gray_matter = __toESM(require_gray_matter());
 function slugify(value) {
   return value.normalize("NFKD").replace(/[^\w\s-]/g, "").trim().toLowerCase().replace(/[\s_]+/g, "-").replace(/-+/g, "-");
@@ -7263,7 +7282,7 @@ function parseMarkdownDocument(absPath, relPath, rootId, rawContent, mtimeMs) {
     });
   };
   const titleFromFirstHeading = lines.find((line) => line.startsWith("# "))?.replace(/^#\s+/u, "").trim();
-  const title = typeof parsed.data.title === "string" && parsed.data.title.trim() || titleFromFirstHeading || import_node_path3.default.basename(relPath, ".md");
+  const title = typeof parsed.data.title === "string" && parsed.data.title.trim() || titleFromFirstHeading || import_node_path4.default.basename(relPath, ".md");
   const documentId = typeof parsed.data.id === "string" && parsed.data.id.trim() || deriveDocId(rootId, relPath);
   for (const line of lines) {
     const match = line.match(headingPattern);
@@ -7339,52 +7358,55 @@ function parseMarkdownDocument(absPath, relPath, rootId, rawContent, mtimeMs) {
 // src/lib/workspace.ts
 var import_node_fs3 = __toESM(require("node:fs"));
 var import_node_os = __toESM(require("node:os"));
-var import_node_path4 = __toESM(require("node:path"));
+var import_node_path5 = __toESM(require("node:path"));
 function getDefaultCodexHome() {
-  return process.env.CODEX_HOME || import_node_path4.default.join(import_node_os.default.homedir(), ".codex");
+  return process.env.CODEX_HOME || import_node_path5.default.join(import_node_os.default.homedir(), ".codex");
+}
+function getDefaultAgentsHome() {
+  return process.env.AGENTS_HOME || import_node_path5.default.join(import_node_os.default.homedir(), ".agents");
 }
 function getGlobalRegistryDir() {
   const explicit = process.env.COMPANY_AGENT_WIKI_CONFIG_HOME;
   if (explicit?.trim()) {
-    return import_node_path4.default.resolve(explicit);
+    return import_node_path5.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");
+    return import_node_path5.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);
+    return import_node_path5.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 roaming = process.env.APPDATA || import_node_path5.default.join(import_node_os.default.homedir(), "AppData", "Roaming");
+    return import_node_path5.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);
+  const xdgConfig = process.env.XDG_CONFIG_HOME || import_node_path5.default.join(import_node_os.default.homedir(), ".config");
+  return import_node_path5.default.join(xdgConfig, GLOBAL_REGISTRY_DIR_NAME);
 }
 function getGlobalRegistryPath() {
-  return import_node_path4.default.join(getGlobalRegistryDir(), GLOBAL_REGISTRY_FILE);
+  return import_node_path5.default.join(getGlobalRegistryDir(), GLOBAL_REGISTRY_FILE);
 }
 function resolveWorkspacePaths(workspaceRoot) {
   const absoluteRoot = normalizeWorkspaceRootPath(workspaceRoot);
-  const internalDir = import_node_path4.default.join(absoluteRoot, WORKSPACE_INTERNAL_DIR);
+  const internalDir = import_node_path5.default.join(absoluteRoot, WORKSPACE_INTERNAL_DIR);
   return {
     workspaceRoot: absoluteRoot,
     internalDir,
-    configPath: import_node_path4.default.join(internalDir, WORKSPACE_CONFIG_FILE),
-    indexDbPath: import_node_path4.default.join(internalDir, INDEX_DB_FILE),
-    indexManifestPath: import_node_path4.default.join(internalDir, INDEX_MANIFEST_FILE),
-    managedRootPath: import_node_path4.default.join(absoluteRoot, DEFAULT_MANAGED_ROOT_PATH),
-    archiveRootPath: import_node_path4.default.join(absoluteRoot, DEFAULT_ARCHIVE_ROOT_PATH)
+    configPath: import_node_path5.default.join(internalDir, WORKSPACE_CONFIG_FILE),
+    indexDbPath: import_node_path5.default.join(internalDir, INDEX_DB_FILE),
+    indexManifestPath: import_node_path5.default.join(internalDir, INDEX_MANIFEST_FILE),
+    managedRootPath: import_node_path5.default.join(absoluteRoot, DEFAULT_MANAGED_ROOT_PATH),
+    archiveRootPath: import_node_path5.default.join(absoluteRoot, DEFAULT_ARCHIVE_ROOT_PATH)
   };
 }
 function detectWorkspaceRoot(startDir = process.cwd()) {
-  let current = import_node_path4.default.resolve(startDir);
+  let current = import_node_path5.default.resolve(startDir);
   while (true) {
-    const candidate = import_node_path4.default.join(current, WORKSPACE_INTERNAL_DIR, WORKSPACE_CONFIG_FILE);
+    const candidate = import_node_path5.default.join(current, WORKSPACE_INTERNAL_DIR, WORKSPACE_CONFIG_FILE);
     if (fileExists(candidate)) {
       return current;
     }
-    const parent = import_node_path4.default.dirname(current);
+    const parent = import_node_path5.default.dirname(current);
     if (parent === current) {
       return void 0;
     }
@@ -7399,7 +7421,7 @@ function createDefaultGlobalRegistry() {
   };
 }
 function normalizeWorkspaceRootPath(candidatePath) {
-  const resolved = import_node_path4.default.resolve(candidatePath);
+  const resolved = import_node_path5.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 {
@@ -7424,7 +7446,7 @@ function loadGlobalWorkspaceRegistry() {
     const normalizedEntry = {
       workspaceId: entry.workspaceId,
       path: normalizedPath,
-      label: entry.label || import_node_path4.default.basename(normalizedPath),
+      label: entry.label || import_node_path5.default.basename(normalizedPath),
       registeredAt: entry.registeredAt,
       lastUsedAt: entry.lastUsedAt,
       source: entry.source
@@ -7458,14 +7480,14 @@ function buildRegisteredWorkspace(workspaceRoot, source) {
   return {
     workspaceId: config.workspaceId,
     path: resolvedRoot,
-    label: import_node_path4.default.basename(resolvedRoot),
+    label: import_node_path5.default.basename(resolvedRoot),
     registeredAt: now,
     lastUsedAt: now,
     source
   };
 }
 function registerWorkspaceGlobally(workspaceRoot, options3) {
-  const resolvedRoot = import_node_path4.default.resolve(workspaceRoot);
+  const resolvedRoot = import_node_path5.default.resolve(workspaceRoot);
   const nextEntry = buildRegisteredWorkspace(resolvedRoot, options3?.source || "manual");
   const registry = loadGlobalWorkspaceRegistry();
   const existing = registry.workspaces.find((item) => item.path === resolvedRoot);
@@ -7817,8 +7839,8 @@ function createDefaultConfig() {
       }
     ],
     index: {
-      databasePath: import_node_path4.default.join(WORKSPACE_INTERNAL_DIR, INDEX_DB_FILE),
-      manifestPath: import_node_path4.default.join(WORKSPACE_INTERNAL_DIR, INDEX_MANIFEST_FILE)
+      databasePath: import_node_path5.default.join(WORKSPACE_INTERNAL_DIR, INDEX_DB_FILE),
+      manifestPath: import_node_path5.default.join(WORKSPACE_INTERNAL_DIR, INDEX_MANIFEST_FILE)
     },
     git: {
       enabled: true,
@@ -7846,22 +7868,22 @@ function saveWorkspaceConfig(workspaceRoot, config) {
   writeJsonFile(paths.configPath, config);
 }
 function normalizeStoredRootPath(workspaceRoot, candidatePath) {
-  const absoluteCandidate = import_node_path4.default.resolve(candidatePath);
-  const relative = import_node_path4.default.relative(workspaceRoot, absoluteCandidate);
-  if (!relative.startsWith("..") && !import_node_path4.default.isAbsolute(relative)) {
+  const absoluteCandidate = import_node_path5.default.resolve(candidatePath);
+  const relative = import_node_path5.default.relative(workspaceRoot, absoluteCandidate);
+  if (!relative.startsWith("..") && !import_node_path5.default.isAbsolute(relative)) {
     return relative || ".";
   }
   return absoluteCandidate;
 }
 function isPathInsideWorkspace(workspaceRoot, candidatePath) {
-  const relative = import_node_path4.default.relative(import_node_path4.default.resolve(workspaceRoot), import_node_path4.default.resolve(candidatePath));
-  return relative === "" || !relative.startsWith("..") && !import_node_path4.default.isAbsolute(relative);
+  const relative = import_node_path5.default.relative(import_node_path5.default.resolve(workspaceRoot), import_node_path5.default.resolve(candidatePath));
+  return relative === "" || !relative.startsWith("..") && !import_node_path5.default.isAbsolute(relative);
 }
 function resolveRootPath(workspaceRoot, root) {
-  if (import_node_path4.default.isAbsolute(root.path)) {
+  if (import_node_path5.default.isAbsolute(root.path)) {
     return root.path;
   }
-  return import_node_path4.default.join(workspaceRoot, root.path);
+  return import_node_path5.default.join(workspaceRoot, root.path);
 }
 function setupWorkspace(options3) {
   const paths = resolveWorkspacePaths(options3.workspaceRoot);
@@ -7883,20 +7905,20 @@ function setupWorkspace(options3) {
     config.git.remoteConfigured = true;
   }
   saveWorkspaceConfig(paths.workspaceRoot, config);
-  writeTextFile(import_node_path4.default.join(paths.workspaceRoot, "README.md"), templateWorkspaceReadme());
-  writeTextFile(import_node_path4.default.join(paths.workspaceRoot, ".gitignore"), templateWorkspaceGitignore());
-  writeTextFile(import_node_path4.default.join(paths.managedRootPath, "README.md"), templateKnowledgeReadme());
-  writeTextFile(import_node_path4.default.join(paths.archiveRootPath, "README.md"), "# Archive\n");
+  writeTextFile(import_node_path5.default.join(paths.workspaceRoot, "README.md"), templateWorkspaceReadme());
+  writeTextFile(import_node_path5.default.join(paths.workspaceRoot, ".gitignore"), templateWorkspaceGitignore());
+  writeTextFile(import_node_path5.default.join(paths.managedRootPath, "README.md"), templateKnowledgeReadme());
+  writeTextFile(import_node_path5.default.join(paths.archiveRootPath, "README.md"), "# Archive\n");
   const created = [
     paths.configPath,
-    import_node_path4.default.join(paths.workspaceRoot, "README.md"),
-    import_node_path4.default.join(paths.workspaceRoot, ".gitignore"),
-    import_node_path4.default.join(paths.managedRootPath, "README.md"),
-    import_node_path4.default.join(paths.archiveRootPath, "README.md")
+    import_node_path5.default.join(paths.workspaceRoot, "README.md"),
+    import_node_path5.default.join(paths.workspaceRoot, ".gitignore"),
+    import_node_path5.default.join(paths.managedRootPath, "README.md"),
+    import_node_path5.default.join(paths.archiveRootPath, "README.md")
   ];
   if (options3.starterDocs !== false) {
     for (const document of createStarterDocuments()) {
-      const absPath = import_node_path4.default.join(paths.managedRootPath, document.relPath);
+      const absPath = import_node_path5.default.join(paths.managedRootPath, document.relPath);
       writeTextFile(absPath, document.content);
       created.push(absPath);
     }
@@ -7932,7 +7954,7 @@ function addRoot(workspaceRoot, rootDefinition) {
   if (config.roots.some((root2) => root2.id === rootDefinition.id)) {
     throw new CliError("ROOT_EXISTS", `Root '${rootDefinition.id}' already exists.`, EXIT_CODES.validation);
   }
-  const absoluteRoot = import_node_path4.default.resolve(rootDefinition.rootPath);
+  const absoluteRoot = import_node_path5.default.resolve(rootDefinition.rootPath);
   if (!isDirectory(absoluteRoot)) {
     throw new CliError(
       "ROOT_NOT_FOUND",
@@ -7974,10 +7996,13 @@ function listRoots(workspaceRoot) {
 function doctor(workspaceRoot) {
   const paths = resolveWorkspacePaths(workspaceRoot);
   const checks = [];
+  const agentsHome = getDefaultAgentsHome();
+  const agentsBinDir = import_node_path5.default.join(agentsHome, "bin");
+  const agentsShimPath = import_node_path5.default.join(agentsBinDir, CLI_NAME);
   const codexHome = getDefaultCodexHome();
-  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 codexBinDir = import_node_path5.default.join(codexHome, "bin");
+  const codexShimPath = import_node_path5.default.join(codexBinDir, CLI_NAME);
+  const pathEntries = (process.env.PATH || "").split(import_node_path5.default.delimiter).filter(Boolean);
   const registryPath = getGlobalRegistryPath();
   const registry = loadGlobalWorkspaceRegistry();
   checks.push({
@@ -7995,10 +8020,20 @@ function doctor(workspaceRoot) {
     ok: isGitAvailable(),
     message: isGitAvailable() ? "Git is available in PATH." : "Git is not available in PATH."
   });
+  checks.push({
+    name: "agents-cli-shim",
+    ok: fileExists(agentsShimPath),
+    message: fileExists(agentsShimPath) ? `Shared agent CLI shim found: ${agentsShimPath}` : `Shared agent CLI shim missing: ${agentsShimPath}`
+  });
+  checks.push({
+    name: "agents-bin-in-path",
+    ok: pathEntries.includes(agentsBinDir),
+    message: pathEntries.includes(agentsBinDir) ? `Shared agent bin directory is available in PATH: ${agentsBinDir}` : `Shared agent bin directory is not in PATH: ${agentsBinDir}`
+  });
   checks.push({
     name: "codex-cli-shim",
     ok: fileExists(codexShimPath),
-    message: fileExists(codexShimPath) ? `Codex CLI shim found: ${codexShimPath}` : `Codex CLI shim missing: ${codexShimPath}`
+    message: fileExists(codexShimPath) ? `Codex compatibility shim found: ${codexShimPath}` : `Codex compatibility shim missing: ${codexShimPath}`
   });
   checks.push({
     name: "codex-bin-in-path",
@@ -8044,7 +8079,7 @@ 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 import_node_path6 = __toESM(require("node:path"));
 var LOCK_FILE_NAME = "write.lock";
 var LOCK_WAIT_TIMEOUT_MS = 6e4;
 var LOCK_POLL_INTERVAL_MS = 125;
@@ -8055,7 +8090,7 @@ function sleepMs(durationMs) {
   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);
+  return import_node_path6.default.join(import_node_path6.default.resolve(workspaceRoot), WORKSPACE_INTERNAL_DIR, LOCK_FILE_NAME);
 }
 function readLockPayload(lockPath) {
   if (!fileExists(lockPath)) {
@@ -8100,7 +8135,7 @@ function createLockPayload(workspaceRoot, reason) {
     token: newBuildId(),
     pid: process.pid,
     reason,
-    workspaceRoot: import_node_path5.default.resolve(workspaceRoot),
+    workspaceRoot: import_node_path6.default.resolve(workspaceRoot),
     acquiredAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
@@ -8109,7 +8144,7 @@ function withWorkspaceWriteLock(workspaceRoot, reason, callback, options3) {
   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));
+  ensureDir(import_node_path6.default.dirname(lockPath));
   while (true) {
     try {
       const fileDescriptor = import_node_fs4.default.openSync(lockPath, "wx");
@@ -8189,11 +8224,11 @@ function closeDatabaseQuietly(database) {
 }
 function throwKnownDatabaseError(error, workspaceRoot) {
   const cliError = coerceCliError(error, {
-    sqliteLockHint: `Retry in a moment, serialize parallel CLI reads against ${import_node_path6.default.resolve(
+    sqliteLockHint: `Retry in a moment, serialize parallel CLI reads against ${import_node_path7.default.resolve(
       workspaceRoot
     )}, or rerun with --auto-rebuild after the current write finishes.`,
     sqliteLockDetails: {
-      workspaceRoot: import_node_path6.default.resolve(workspaceRoot)
+      workspaceRoot: import_node_path7.default.resolve(workspaceRoot)
     }
   });
   if (cliError) {
@@ -8276,7 +8311,7 @@ function collectRootSnapshot(rootId, rootPath, kind) {
   let latestMtimeMs = 0;
   for (const filePath of markdownFiles) {
     const stats = import_node_fs5.default.statSync(filePath);
-    const relPath = import_node_path6.default.relative(rootPath, filePath);
+    const relPath = import_node_path7.default.relative(rootPath, filePath);
     latestMtimeMs = Math.max(latestMtimeMs, Math.trunc(stats.mtimeMs));
     entries.push(`${relPath}|${stats.size}|${Math.trunc(stats.mtimeMs)}`);
   }
@@ -8502,7 +8537,7 @@ function rebuildIndexUnlocked(workspaceRoot) {
       for (const filePath of markdownFiles) {
         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 relPath = import_node_path7.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);
@@ -8614,7 +8649,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_path6.default.resolve(workspaceRoot)}`
+        hint: verification.hint || `Run: company-agent-wiki-cli index rebuild --workspace ${import_node_path7.default.resolve(workspaceRoot)}`
       }
     );
   }
@@ -8627,7 +8662,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_path6.default.resolve(workspaceRoot)}`,
+        hint: `Run: company-agent-wiki-cli index rebuild --workspace ${import_node_path7.default.resolve(workspaceRoot)}`,
         details: verification.roots.filter((root) => !root.ok)
       }
     );
@@ -8937,7 +8972,7 @@ function getDocumentHeadings(workspaceRoot, docId, options3) {
 
 // src/lib/onboarding.ts
 var import_node_fs6 = __toESM(require("node:fs"));
-var import_node_path7 = __toESM(require("node:path"));
+var import_node_path8 = __toESM(require("node:path"));
 var COMPANY_ONBOARDING_DE_V1 = {
   profileId: "de-company-v1",
   locale: "de-DE",
@@ -9529,8 +9564,8 @@ function ensureKnownAnswerKeys(payload) {
   }
 }
 function isPathInsideWorkspace2(workspaceRoot, candidatePath) {
-  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);
+  const relative = import_node_path8.default.relative(import_node_path8.default.resolve(workspaceRoot), import_node_path8.default.resolve(candidatePath));
+  return relative === "" || !relative.startsWith("..") && !import_node_path8.default.isAbsolute(relative);
 }
 function resolveManagedRoot(workspaceRoot) {
   const config = loadWorkspaceConfig(workspaceRoot);
@@ -9553,12 +9588,12 @@ function resolveManagedRoot(workspaceRoot) {
   return resolvedPath;
 }
 function createDocument(workspaceRoot, managedRoot, relPath, id, title, type, tags, body, answeredAt, answeredBy) {
-  const absPath = import_node_path7.default.join(managedRoot, relPath);
+  const absPath = import_node_path8.default.join(managedRoot, relPath);
   return {
     docId: id,
     title,
     absPath,
-    relPath: import_node_path7.default.relative(workspaceRoot, absPath),
+    relPath: import_node_path8.default.relative(workspaceRoot, absPath),
     existed: false,
     content: `${renderFrontmatter({ id, title, type, tags, answeredAt, answeredBy })}${body.trimEnd()}
 `
@@ -9790,8 +9825,8 @@ function previewCompanyOnboarding(workspaceRoot, answerFile) {
   };
 }
 function applyCompanyOnboarding(options3) {
-  const workspaceRoot = import_node_path7.default.resolve(options3.workspaceRoot);
-  const answerFile = import_node_path7.default.resolve(options3.answerFile);
+  const workspaceRoot = import_node_path8.default.resolve(options3.workspaceRoot);
+  const answerFile = import_node_path8.default.resolve(options3.answerFile);
   const preview = previewCompanyOnboarding(workspaceRoot, answerFile);
   const warnings = [...preview.warnings];
   let indexBuildId;
@@ -9817,7 +9852,7 @@ function applyCompanyOnboarding(options3) {
         }
       }
       for (const document of preview.documents) {
-        ensureDir(import_node_path7.default.dirname(document.absPath));
+        ensureDir(import_node_path8.default.dirname(document.absPath));
         if (document.existed) {
           warnings.push(`Overwriting existing file: ${document.relPath}`);
         }
@@ -12509,7 +12544,7 @@ function startServer(workspaceRoot, port, options3) {
 // src/index.ts
 function assertWorkspace(workspacePath) {
   if (workspacePath?.trim()) {
-    const resolved = import_node_path8.default.resolve(workspacePath);
+    const resolved = import_node_path9.default.resolve(workspacePath);
     rememberWorkspaceGlobally(resolved, { setDefault: true, source: "runtime" });
     return resolved;
   }
@@ -12596,14 +12631,20 @@ function printHeadings(headings) {
 }
 var program2 = new Command();
 program2.name(CLI_NAME).description("Agent-first local company knowledge CLI").version(CLI_SCHEMA_VERSION);
-program2.command("about").description("Show CLI runtime metadata and common Codex paths").option("--json", "Emit JSON output", false).action((options3) => {
+program2.command("about").description("Show CLI runtime metadata and common shared-agent paths").option("--json", "Emit JSON output", false).action((options3) => {
+  const agentsHome = getDefaultAgentsHome();
   const codexHome = getDefaultCodexHome();
+  const runtimeHome = detectInstalledRuntimeHome(__dirname) || null;
   const data = {
     packageName: PACKAGE_NAME,
     cliName: CLI_NAME,
     schemaVersion: CLI_SCHEMA_VERSION,
+    runtimeHome,
+    runtimeShimPath: runtimeHome ? import_node_path9.default.join(runtimeHome, "bin", CLI_NAME) : null,
+    agentsHome,
+    agentsShimPath: import_node_path9.default.join(agentsHome, "bin", CLI_NAME),
     codexHome,
-    codexShimPath: import_node_path8.default.join(codexHome, "bin", CLI_NAME),
+    codexShimPath: import_node_path9.default.join(codexHome, "bin", CLI_NAME),
     cwdWorkspace: detectWorkspaceRoot(process.cwd()) || null,
     globalRegistryPath: getGlobalRegistryPath(),
     resolvedWorkspace: resolveWorkspaceSelection(process.cwd())
@@ -12615,6 +12656,12 @@ program2.command("about").description("Show CLI runtime metadata and common Code
   process.stdout.write(`${CLI_NAME}
 `);
   process.stdout.write(`  schema version: ${CLI_SCHEMA_VERSION}
+`);
+  if (data.runtimeShimPath) {
+    process.stdout.write(`  runtime shim: ${data.runtimeShimPath}
+`);
+  }
+  process.stdout.write(`  shared agent shim: ${data.agentsShimPath}
 `);
   process.stdout.write(`  codex shim: ${data.codexShimPath}
 `);
@@ -12679,7 +12726,7 @@ workspace.command("list").description("List globally registered workspaces").opt
   }
 });
 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), {
+  const entry = registerWorkspaceGlobally(import_node_path9.default.resolve(options3.workspace), {
     setDefault: Boolean(options3.default),
     source: "manual"
   });
@@ -12698,7 +12745,7 @@ workspace.command("register").description("Register an existing workspace global
   }
 });
 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), {
+  const entry = registerWorkspaceGlobally(import_node_path9.default.resolve(options3.workspace), {
     setDefault: true,
     source: "manual"
   });
@@ -12716,7 +12763,7 @@ workspace.command("use").description("Set a registered workspace as the global d
 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_path8.default.resolve(options3.workspace);
+    const workspaceRoot = import_node_path9.default.resolve(options3.workspace);
     const result = setupWorkspace({
       workspaceRoot,
       gitInit: Boolean(options3.gitInit),
@@ -12970,8 +13017,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_path8.default.isAbsolute(options3.path) ? options3.path : import_node_path8.default.join(workspaceRoot, options3.path);
-    return getDocumentMetadataByPath(workspaceRoot, import_node_path8.default.resolve(candidatePath), {
+    const candidatePath = import_node_path9.default.isAbsolute(options3.path) ? options3.path : import_node_path9.default.join(workspaceRoot, options3.path);
+    return getDocumentMetadataByPath(workspaceRoot, import_node_path9.default.resolve(candidatePath), {
       autoRebuild: Boolean(options3.autoRebuild)
     });
   })();
@@ -13021,7 +13068,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_path8.default.resolve(import_node_path8.default.isAbsolute(options3.path) ? options3.path : import_node_path8.default.join(workspaceRoot, options3.path));
+  const resolvedPath = options3.docId ? resolveDocumentById(workspaceRoot, options3.docId).absPath : import_node_path9.default.resolve(import_node_path9.default.isAbsolute(options3.path) ? options3.path : import_node_path9.default.join(workspaceRoot, options3.path));
   const history = getGitHistory(resolvedPath, Number(options3.limit));
   if (options3.json) {
     printJson(envelope("history", { path: resolvedPath, history }));
@@ -13034,7 +13081,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_path8.default.resolve(import_node_path8.default.isAbsolute(options3.path) ? options3.path : import_node_path8.default.join(workspaceRoot, options3.path));
+  const resolvedPath = options3.docId ? resolveDocumentById(workspaceRoot, options3.docId).absPath : import_node_path9.default.resolve(import_node_path9.default.isAbsolute(options3.path) ? options3.path : import_node_path9.default.join(workspaceRoot, options3.path));
   const diff = getGitDiff(resolvedPath, options3.base, options3.compare);
   if (options3.json) {
     printJson(envelope("diff", { path: resolvedPath, diff }));