oh-my-opencode 4.12.0 → 4.12.1

package/packages/omo-codex/plugin/components/codegraph/dist/cli.js

@@ -8,13 +8,205 @@ import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // components/codegraph/src/hook.ts
 import { spawn } from "node:child_process";
-import { homedir as homedir7 } from "node:os";
+import { homedir as homedir8 } from "node:os";
 import { cwd as processCwd2, env as processEnv2, stdin as processStdin, stdout as processStdout } from "node:process";
 import { fileURLToPath } from "node:url";
 
-// ../../utils/src/omo-config/loader.ts
-import { existsSync as existsSync2, readFileSync } from "node:fs";
+// ../../utils/src/codegraph/guidance.ts
+import { homedir as homedir2 } from "node:os";
+
+// ../../utils/src/codegraph/workspace.ts
+import { createHash } from "node:crypto";
+import {
+  appendFileSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  realpathSync,
+  rmSync,
+  statSync,
+  symlinkSync
+} from "node:fs";
 import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+function sanitizeBase(value) {
+  const sanitized = value.replace(/[^A-Za-z0-9._-]/g, "-").replace(/-+/g, "-");
+  return sanitized.length > 0 ? sanitized : "workspace";
+}
+function codegraphDataRoot(homeDir) {
+  return join(homeDir, ".omo", "codegraph");
+}
+function workspaceStorageName(workspace) {
+  const resolved = resolve(workspace);
+  const hash = createHash("sha256").update(resolved).digest("hex").slice(0, 16);
+  return `${sanitizeBase(basename(resolved))}-${hash}`;
+}
+function resolveCodegraphWorkspacePaths(workspace, options = {}) {
+  const resolvedWorkspace = resolve(workspace);
+  const dataRoot = codegraphDataRoot(options.homeDir ?? homedir());
+  return {
+    dataDir: join(dataRoot, "projects", workspaceStorageName(resolvedWorkspace)),
+    dataRoot,
+    projectLink: join(resolvedWorkspace, ".codegraph")
+  };
+}
+function fallbackResult(dataRoot, projectLink, reason) {
+  return { dataDir: projectLink, dataRoot, linked: false, mode: "in-place-fallback", projectLink, reason };
+}
+function isSameFilesystem(workspace, dataRoot, override) {
+  if (override !== undefined)
+    return override;
+  return statSync(workspace).dev === statSync(dataRoot).dev;
+}
+function ensureInPlaceFallback(projectLink) {
+  if (!existsSync(projectLink))
+    mkdirSync(projectLink, { recursive: true });
+}
+function prepareCodegraphWorkspace(workspace, options = {}) {
+  const resolvedWorkspace = resolve(workspace);
+  const { dataDir, dataRoot, projectLink } = resolveCodegraphWorkspacePaths(resolvedWorkspace, options);
+  try {
+    mkdirSync(dataDir, { recursive: true });
+    if (existsSync(projectLink)) {
+      const linkStat = lstatSync(projectLink);
+      if (!linkStat.isSymbolicLink()) {
+        return { dataDir: projectLink, dataRoot, linked: false, mode: "in-project", projectLink };
+      }
+      if (realpathSync(projectLink) === realpathSync(dataDir)) {
+        return { dataDir, dataRoot, linked: true, mode: "global-linked", projectLink };
+      }
+      return fallbackResult(dataRoot, projectLink, "existing .codegraph symlink points outside OMO store");
+    }
+    if (!isSameFilesystem(resolvedWorkspace, dataRoot, options.sameFilesystem)) {
+      ensureInPlaceFallback(projectLink);
+      return fallbackResult(dataRoot, projectLink, "workspace and OMO store are on different filesystems");
+    }
+    const symlink = options.symlink ?? symlinkSync;
+    symlink(dataDir, projectLink, (options.platform ?? process.platform) === "win32" ? "junction" : "dir");
+    return { dataDir, dataRoot, linked: true, mode: "global-linked", projectLink };
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    try {
+      ensureInPlaceFallback(projectLink);
+    } catch (fallbackError) {
+      return fallbackResult(dataRoot, projectLink, `${reason}; fallback failed: ${String(fallbackError)}`);
+    }
+    return fallbackResult(dataRoot, projectLink, reason);
+  }
+}
+function ensureCodegraphGitignored(workspace) {
+  const gitDir = join(workspace, ".git");
+  if (!existsSync(gitDir))
+    return false;
+  const excludePath = join(gitDir, "info", "exclude");
+  try {
+    mkdirSync(join(gitDir, "info"), { recursive: true });
+    const existing = existsSync(excludePath) ? readFileSync(excludePath, "utf8") : "";
+    if (existing.split(/\r?\n/).includes(".codegraph"))
+      return true;
+    appendFileSync(excludePath, `${existing.endsWith(`
+`) || existing.length === 0 ? "" : `
+`}.codegraph
+`);
+    return true;
+  } catch (error) {
+    if (error instanceof Error)
+      return false;
+    throw error;
+  }
+}
+
+// ../../utils/src/codegraph/guidance.ts
+var CODEGRAPH_UNINITIALIZED_PATTERN = /CodeGraph not initialized in ([\s\S]*?)\.\s*Run ['`]codegraph init['`] in that project first\./i;
+var ANSI_ESCAPE_PATTERN = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+var CODEGRAPH_STATUS_PROJECT_PATTERN = /^.*?\bProject:\s*(.+?)\s*$/im;
+var CODEGRAPH_STATUS_UNINITIALIZED_PATTERN = /^.*?\bNot initialized\s*$/im;
+var CODEGRAPH_INIT_HINT_PATTERN = /Run\s+["'`]codegraph init["'`]\s+(?:in that project first|to initialize)\.?/i;
+function getCodegraphUninitializedProject(input) {
+  const output = textFromUnknown(input.toolOutput);
+  if (!isCodegraphTool(input.toolName))
+    return null;
+  const projectPath = extractProjectPath(output);
+  if (projectPath !== null)
+    return projectPath;
+  if (!looksLikeCodegraphUninitializedOutput(output))
+    return null;
+  return typeof input.cwd === "string" && input.cwd.trim().length > 0 ? input.cwd.trim() : null;
+}
+function buildCodegraphInitGuidance(projectPath, options = {}) {
+  const { dataDir, dataRoot, projectLink } = resolveCodegraphWorkspacePaths(projectPath, {
+    homeDir: options.homeDir ?? homedir2()
+  });
+  const displayProjectPath = formatDisplayPath(projectPath);
+  const displayProjectLink = formatDisplayPath(projectLink);
+  const displayDataDir = formatDisplayPath(dataDir);
+  const displayDataRoot = formatDisplayPath(dataRoot);
+  return [
+    "OMO CodeGraph initialization guidance:",
+    "",
+    `CodeGraph is not initialized for ${displayProjectPath}. Initialize it through OMO's global local store instead of leaving a standalone project-local index.`,
+    "",
+    `- Link or create ${displayProjectLink} so it points at ${displayDataDir} under the OMO store ${displayDataRoot}.`,
+    `- Then run \`codegraph init\` from ${displayProjectPath} and retry the CodeGraph tool.`,
+    "- OMO's CodeGraph bootstrap does this automatically on session start; if bootstrap just ran, wait for it to finish and retry."
+  ].join(`
+`);
+}
+function buildCodegraphInitGuidanceForToolResult(input, options = {}) {
+  const projectPath = getCodegraphUninitializedProject(input);
+  return projectPath === null ? null : buildCodegraphInitGuidance(projectPath, options);
+}
+function extractProjectPath(output) {
+  const normalizedOutput = normalizeCodegraphOutput(output);
+  const uninitializedMatch = normalizedOutput.match(CODEGRAPH_UNINITIALIZED_PATTERN);
+  const uninitializedProject = uninitializedMatch?.[1]?.trim();
+  if (uninitializedProject && uninitializedProject.length > 0)
+    return uninitializedProject;
+  if (!looksLikeCodegraphUninitializedOutput(normalizedOutput))
+    return null;
+  const statusMatch = normalizedOutput.match(CODEGRAPH_STATUS_PROJECT_PATTERN);
+  const statusProject = statusMatch?.[1]?.trim();
+  return statusProject && statusProject.length > 0 ? statusProject : null;
+}
+function looksLikeCodegraphUninitializedOutput(output) {
+  const normalizedOutput = normalizeCodegraphOutput(output);
+  if (normalizedOutput.match(CODEGRAPH_UNINITIALIZED_PATTERN) !== null)
+    return true;
+  return CODEGRAPH_STATUS_UNINITIALIZED_PATTERN.test(normalizedOutput) && CODEGRAPH_INIT_HINT_PATTERN.test(normalizedOutput);
+}
+function normalizeCodegraphOutput(output) {
+  return output.replace(ANSI_ESCAPE_PATTERN, "");
+}
+function isCodegraphTool(toolName) {
+  if (typeof toolName !== "string")
+    return false;
+  return toolName.startsWith("codegraph.") || toolName.startsWith("codegraph_") || toolName.startsWith("mcp__codegraph__");
+}
+function formatDisplayPath(value) {
+  return JSON.stringify(value);
+}
+function textFromUnknown(value) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint")
+    return String(value);
+  if (Array.isArray(value))
+    return value.map(textFromUnknown).filter(Boolean).join(`
+`);
+  if (!isRecord(value))
+    return "";
+  return Object.entries(value).map(([key, nested]) => `${key}: ${textFromUnknown(nested)}`).filter((line) => line.trim().length > 0).join(`
+`);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../../utils/src/omo-config/loader.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
 
 // ../../utils/src/deep-merge.ts
 var DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
@@ -970,22 +1162,22 @@ function buildEnvOverrides(harness, env, warnings, merge) {
 }
 
 // ../../utils/src/omo-config/resolve.ts
-import { existsSync } from "node:fs";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname, isAbsolute, join as join2, relative, resolve as resolve2 } from "node:path";
 function containsPath(parent, child) {
   const pathToChild = relative(parent, child);
   return pathToChild === "" || !pathToChild.startsWith("..") && !isAbsolute(pathToChild);
 }
 function findProjectConfigPathsNearestFirst(cwd, homeDir) {
-  const startDir = resolve(cwd);
-  const stopBeforeDir = containsPath(resolve(homeDir), startDir) ? resolve(homeDir) : null;
+  const startDir = resolve2(cwd);
+  const stopBeforeDir = containsPath(resolve2(homeDir), startDir) ? resolve2(homeDir) : null;
   const paths = [];
   let currentDir = startDir;
   while (true) {
     if (stopBeforeDir !== null && currentDir === stopBeforeDir)
       break;
-    const configPath = join(currentDir, ".omo", "config.jsonc");
-    if (existsSync(configPath)) {
+    const configPath = join2(currentDir, ".omo", "config.jsonc");
+    if (existsSync2(configPath)) {
       paths.push(configPath);
     }
     const parentDir = dirname(currentDir);
@@ -996,7 +1188,7 @@ function findProjectConfigPathsNearestFirst(cwd, homeDir) {
   return paths;
 }
 function resolveOmoConfigPaths(options) {
-  const globalPath = join(resolve(options.homeDir), ".omo", "config.jsonc");
+  const globalPath = join2(resolve2(options.homeDir), ".omo", "config.jsonc");
   const projectPathsFarthestFirst = findProjectConfigPathsNearestFirst(options.cwd, options.homeDir).reverse();
   return [
     { path: globalPath, scope: "global" },
@@ -1028,7 +1220,7 @@ var CODEGRAPH_SETTING_KEYS = [
   "telemetry",
   "watch_debounce_ms"
 ];
-function isRecord(value) {
+function isRecord2(value) {
   return isPlainObject(value);
 }
 function hasOwn(record, key) {
@@ -1056,7 +1248,7 @@ function mergeValues(base, override) {
 }
 function mergeCodegraphConfig(base, override) {
   const merged = mergeValues(base, override);
-  if (!isRecord(merged))
+  if (!isRecord2(merged))
     return;
   const codegraph = {};
   for (const key of CODEGRAPH_SETTING_KEYS) {
@@ -1111,7 +1303,7 @@ function setCodegraphSetting2(config, key, value) {
   }
 }
 function normalizeCodegraphSection(section, pathPrefix, warnings) {
-  if (!isRecord(section)) {
+  if (!isRecord2(section)) {
     warnings.push(`${pathPrefix} must be an object`);
     return {};
   }
@@ -1131,7 +1323,7 @@ function normalizeCodegraphSection(section, pathPrefix, warnings) {
   return codegraph;
 }
 function normalizeConfigBody(value, pathPrefix, warnings) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     warnings.push(`${pathPrefix} must be an object`);
     return {};
   }
@@ -1152,7 +1344,7 @@ function normalizeConfigBody(value, pathPrefix, warnings) {
   return config;
 }
 function normalizeActiveHarnessBlock(value, harness, pathPrefix, warnings) {
-  if (!isRecord(value))
+  if (!isRecord2(value))
     return {};
   const blockKey = `[${harness}]`;
   if (!hasOwn(value, blockKey))
@@ -1161,7 +1353,7 @@ function normalizeActiveHarnessBlock(value, harness, pathPrefix, warnings) {
 }
 function loadConfigFile(path, harness) {
   try {
-    const content = readFileSync(path, "utf-8");
+    const content = readFileSync2(path, "utf-8");
     const parsed = parseJsoncSafe(content);
     if (parsed.errors.length > 0) {
       return {
@@ -1207,13 +1399,13 @@ function validateHarnessApplicability(config, harness) {
 }
 function loadOmoConfig(options) {
   const cwd = options.cwd ?? process.cwd();
-  const homeDir = options.homeDir ?? process.env["HOME"] ?? process.env["USERPROFILE"] ?? homedir();
+  const homeDir = options.homeDir ?? process.env["HOME"] ?? process.env["USERPROFILE"] ?? homedir3();
   const env = options.env ?? process.env;
   let config = BUILT_IN_DEFAULTS;
   const sources = [];
   const warnings = [];
   for (const candidate of resolveOmoConfigPaths({ cwd, homeDir })) {
-    if (!existsSync2(candidate.path)) {
+    if (!existsSync3(candidate.path)) {
       if (candidate.scope === "global") {
         sources.push(toMissingSource(candidate));
       }
@@ -1253,21 +1445,21 @@ function getCodexOmoConfig(options = {}) {
 // components/codegraph/src/session-start-worker.ts
 import { execFile as execFile2 } from "node:child_process";
 import { appendFileSync as appendFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync2 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
+import { homedir as homedir7 } from "node:os";
 import { extname, join as join7 } from "node:path";
 import { cwd as processCwd, env as processEnv, stderr as processStderr } from "node:process";
 
 // ../../utils/src/codegraph/env.ts
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { join as join3 } from "node:path";
 var CODEGRAPH_INSTALL_DIR_ENV = "CODEGRAPH_INSTALL_DIR";
 var CODEGRAPH_NO_DOWNLOAD_ENV = "CODEGRAPH_NO_DOWNLOAD";
 var CODEGRAPH_TELEMETRY_ENV = "CODEGRAPH_TELEMETRY";
 var DO_NOT_TRACK_ENV = "DO_NOT_TRACK";
 function buildCodegraphEnv(options = {}) {
-  const homeDir = options.homeDir ?? homedir2();
+  const homeDir = options.homeDir ?? homedir4();
   return {
-    [CODEGRAPH_INSTALL_DIR_ENV]: join2(homeDir, ".omo", "codegraph"),
+    [CODEGRAPH_INSTALL_DIR_ENV]: join3(homeDir, ".omo", "codegraph"),
     [CODEGRAPH_NO_DOWNLOAD_ENV]: "1",
     [CODEGRAPH_TELEMETRY_ENV]: "0",
     [DO_NOT_TRACK_ENV]: "1"
@@ -1304,12 +1496,12 @@ function parseNodeMajor(version) {
 }
 
 // ../../utils/src/codegraph/provision.ts
-import { createHash, randomUUID } from "node:crypto";
+import { createHash as createHash2, randomUUID } from "node:crypto";
 import { execFile } from "node:child_process";
 import { chmod, mkdir, readdir, readFile, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
-import { existsSync as existsSync3 } from "node:fs";
-import { homedir as homedir3, hostname } from "node:os";
-import { basename, join as join3 } from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
+import { homedir as homedir5, hostname } from "node:os";
+import { basename as basename2, join as join4 } from "node:path";
 import { promisify } from "node:util";
 
 // ../../utils/src/codegraph/manifest.ts
@@ -1358,13 +1550,13 @@ function platformKey() {
   return `${process.platform}-${process.arch}`;
 }
 function markerPath(installDir, version) {
-  return join3(installDir, ".provisioned", `codegraph-${version}.json`);
+  return join4(installDir, ".provisioned", `codegraph-${version}.json`);
 }
 function defaultInstallDir() {
-  return join3(homedir3(), ".omo", "codegraph");
+  return join4(homedir5(), ".omo", "codegraph");
 }
 function sha256(bytes) {
-  return createHash("sha256").update(bytes).digest("hex");
+  return createHash2("sha256").update(bytes).digest("hex");
 }
 function isErrnoException(error) {
   return error instanceof Error && "code" in error;
@@ -1381,7 +1573,7 @@ async function removeEmptyDirectory(path) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function defaultDownloader(asset, timeoutMs = DEFAULT_DOWNLOAD_TIMEOUT_MS) {
   const response = await fetch(asset.url, { signal: AbortSignal.timeout(timeoutMs) });
@@ -1395,7 +1587,7 @@ function forcedBadChecksumOptions(options) {
   const key = options.platformKey ?? platformKey();
   return {
     downloader: async () => new TextEncoder().encode("checksum mismatch"),
-    installDir: options.installDir ?? join3(options.lockDir, "codegraph-force-bad-checksum"),
+    installDir: options.installDir ?? join4(options.lockDir, "codegraph-force-bad-checksum"),
     manifest: {
       assets: {
         [key]: { executableName: process.platform === "win32" ? "codegraph.cmd" : "codegraph", sha256: "0000", url: "memory://bad" }
@@ -1406,13 +1598,13 @@ function forcedBadChecksumOptions(options) {
   };
 }
 async function readMarker(path) {
-  if (!existsSync3(path))
+  if (!existsSync4(path))
     return null;
   try {
     const raw = JSON.parse(await readFile(path, "utf8"));
     if (typeof raw === "object" && raw !== null && "binPath" in raw) {
       const value = raw.binPath;
-      return typeof value === "string" && existsSync3(value) ? value : null;
+      return typeof value === "string" && existsSync4(value) ? value : null;
     }
     return null;
   } catch (error) {
@@ -1423,7 +1615,7 @@ async function readMarker(path) {
 }
 async function acquireLock(lockPath, waitMs, staleMs) {
   const startedAt = Date.now();
-  await mkdir(join3(lockPath, ".."), { recursive: true });
+  await mkdir(join4(lockPath, ".."), { recursive: true });
   while (Date.now() - startedAt <= waitMs) {
     try {
       await mkdir(lockPath);
@@ -1448,44 +1640,44 @@ async function installExtractedBundle(extractDir, installDir, executableName) {
   const roots = await readdir(extractDir);
   if (roots.length !== 1)
     throw new Error(`CodeGraph archive should contain one root directory, found ${roots.length}`);
-  const bundleDir = join3(extractDir, roots[0] ?? "");
+  const bundleDir = join4(extractDir, roots[0] ?? "");
   const bundleEntries = await readdir(bundleDir);
   await mkdir(installDir, { recursive: true });
   for (const entry of bundleEntries) {
-    await rm(join3(installDir, entry), { force: true, recursive: true });
-    await rename(join3(bundleDir, entry), join3(installDir, entry));
+    await rm(join4(installDir, entry), { force: true, recursive: true });
+    await rename(join4(bundleDir, entry), join4(installDir, entry));
   }
-  const destination = join3(installDir, "bin", executableName);
-  if (!existsSync3(destination))
+  const destination = join4(installDir, "bin", executableName);
+  if (!existsSync4(destination))
     throw new Error(`CodeGraph archive did not contain bin/${executableName}`);
   await chmod(destination, 493);
   return destination;
 }
 async function installAsset(layout) {
   const { asset, downloader, installDir, version } = layout;
-  const stagingDir = join3(installDir, ".staging", randomUUID());
-  const archivePath = join3(stagingDir, basename(asset.url));
-  const extractDir = join3(stagingDir, "extract");
+  const stagingDir = join4(installDir, ".staging", randomUUID());
+  const archivePath = join4(stagingDir, basename2(asset.url));
+  const extractDir = join4(stagingDir, "extract");
   try {
     await mkdir(extractDir, { recursive: true });
     const bytes = await downloader(asset);
     const actualChecksum = sha256(bytes);
     if (actualChecksum !== asset.sha256) {
-      throw new Error(`checksum mismatch for ${basename(asset.url)}: expected ${asset.sha256}, got ${actualChecksum}`);
+      throw new Error(`checksum mismatch for ${basename2(asset.url)}: expected ${asset.sha256}, got ${actualChecksum}`);
     }
     if (!asset.url.endsWith(".tar.gz") && !asset.url.endsWith(".tgz")) {
-      throw new Error(`unsupported CodeGraph archive type for ${basename(asset.url)}`);
+      throw new Error(`unsupported CodeGraph archive type for ${basename2(asset.url)}`);
     }
     await writeFile(archivePath, bytes);
     await extractTarGz(archivePath, extractDir);
     const destination = await installExtractedBundle(extractDir, installDir, asset.executableName);
-    await mkdir(join3(installDir, ".provisioned"), { recursive: true });
+    await mkdir(join4(installDir, ".provisioned"), { recursive: true });
     await writeFile(markerPath(installDir, version), `${JSON.stringify({ binPath: destination, version })}
 `);
     return destination;
   } finally {
     await rm(stagingDir, { force: true, recursive: true });
-    await removeEmptyDirectory(join3(installDir, ".staging"));
+    await removeEmptyDirectory(join4(installDir, ".staging"));
   }
 }
 async function ensureCodegraphProvisioned(options) {
@@ -1498,7 +1690,7 @@ async function ensureCodegraphProvisioned(options) {
   const existing = await readMarker(marker);
   if (existing !== null)
     return { binPath: existing, provisioned: true };
-  const lockPath = join3(options.lockDir, `codegraph-${hostname()}.lock`);
+  const lockPath = join4(options.lockDir, `codegraph-${hostname()}.lock`);
   const release = await acquireLock(lockPath, options.lockWaitMs ?? DEFAULT_LOCK_WAIT_MS, options.lockStaleMs ?? DEFAULT_LOCK_STALE_MS);
   if (release === null)
     return { error: "timed out waiting for codegraph provisioning lock", provisioned: false };
@@ -1523,15 +1715,15 @@ async function ensureCodegraphProvisioned(options) {
 }
 
 // ../../utils/src/codegraph/resolve.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
+import { existsSync as existsSync5 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
 import { spawnSync } from "node:child_process";
-import { basename as basename2, dirname as dirname2, join as join5 } from "node:path";
+import { basename as basename3, dirname as dirname2, join as join6 } from "node:path";
 import { createRequire } from "node:module";
 
 // ../../utils/src/runtime/which.ts
 import { accessSync, constants } from "node:fs";
-import { delimiter, join as join4 } from "node:path";
+import { delimiter, join as join5 } from "node:path";
 var runtime = globalThis;
 function isUnsafeCommandName(commandName) {
   if (commandName.includes("/") || commandName.includes("\\"))
@@ -1586,7 +1778,7 @@ function bunWhich(commandName) {
     return null;
   for (const pathEntry of pathEntries) {
     for (const candidateName of candidateNames) {
-      const candidatePath = join4(pathEntry, candidateName);
+      const candidatePath = join5(pathEntry, candidateName);
       if (isExecutable(candidatePath))
         return candidatePath;
     }
@@ -1627,7 +1819,7 @@ ${result.stderr}`.trim().split(/\s+/)[0];
   }
 }
 function isNodeExecutableName(filePath) {
-  const executable = basename2(filePath).toLowerCase();
+  const executable = basename3(filePath).toLowerCase();
   return executable === "node" || executable === "node.exe" || /^node\d+(\.exe)?$/.test(executable);
 }
 function looksLikePath(command) {
@@ -1667,8 +1859,8 @@ function defaultNodeRuntime(env, fileExists, which, nodeVersion) {
 function defaultProvisionedBin(homeDir, fileExists) {
   const binaryName = process.platform === "win32" ? "codegraph.cmd" : "codegraph";
   const candidates = [
-    join5(homeDir, ".omo", "codegraph", "bin", binaryName),
-    join5(homeDir, ".omo", "codegraph", "node-servers", "node_modules", ".bin", binaryName)
+    join6(homeDir, ".omo", "codegraph", "bin", binaryName),
+    join6(homeDir, ".omo", "codegraph", "node-servers", "node_modules", ".bin", binaryName)
   ];
   return candidates.find((candidate) => fileExists(candidate)) ?? null;
 }
@@ -1676,7 +1868,7 @@ function resolveBundledShim(requireResolve, fileExists) {
   try {
     const packageJson = requireResolve(`${CODEGRAPH_PACKAGE}/package.json`);
     const packageRoot = dirname2(packageJson);
-    const candidates = [join5(packageRoot, "bin", "codegraph.js"), join5(packageRoot, "npm-shim.js")];
+    const candidates = [join6(packageRoot, "bin", "codegraph.js"), join6(packageRoot, "npm-shim.js")];
     return candidates.find((candidate) => fileExists(candidate)) ?? null;
   } catch (error) {
     if (error instanceof Error)
@@ -1692,7 +1884,7 @@ function resolveBundledShim(requireResolve, fileExists) {
 }
 function resolveCodegraphCommand(options = {}) {
   const env = options.env ?? process.env;
-  const fileExists = options.fileExists ?? existsSync4;
+  const fileExists = options.fileExists ?? existsSync5;
   const configuredBin = env[CODEGRAPH_ENV_BIN]?.trim() || env[CODEGRAPH_LEGACY_ENV_BIN]?.trim();
   if (configuredBin !== undefined && configuredBin.length > 0) {
     return { argsPrefix: [], command: configuredBin, exists: fileExists(configuredBin), source: "env" };
@@ -1704,7 +1896,7 @@ function resolveCodegraphCommand(options = {}) {
   if (bundled !== null && runtime2 !== null) {
     return { argsPrefix: [bundled], command: runtime2, exists: true, source: "bundled" };
   }
-  const provisioned = options.provisioned?.() ?? defaultProvisionedBin(options.homeDir ?? homedir4(), fileExists);
+  const provisioned = options.provisioned?.() ?? defaultProvisionedBin(options.homeDir ?? homedir6(), fileExists);
   if (provisioned !== null && fileExists(provisioned)) {
     return { argsPrefix: [], command: provisioned, exists: true, source: "provisioned" };
   }
@@ -1717,102 +1909,6 @@ function resolveCodegraphCommand(options = {}) {
   };
 }
 
-// ../../utils/src/codegraph/workspace.ts
-import { createHash as createHash2 } from "node:crypto";
-import {
-  appendFileSync,
-  existsSync as existsSync5,
-  lstatSync,
-  mkdirSync,
-  readFileSync as readFileSync2,
-  readdirSync,
-  realpathSync,
-  rmSync,
-  statSync,
-  symlinkSync
-} from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { basename as basename3, join as join6, resolve as resolve2 } from "node:path";
-function sanitizeBase(value) {
-  const sanitized = value.replace(/[^A-Za-z0-9._-]/g, "-").replace(/-+/g, "-");
-  return sanitized.length > 0 ? sanitized : "workspace";
-}
-function codegraphDataRoot(homeDir) {
-  return join6(homeDir, ".omo", "codegraph");
-}
-function workspaceStorageName(workspace) {
-  const resolved = resolve2(workspace);
-  const hash = createHash2("sha256").update(resolved).digest("hex").slice(0, 16);
-  return `${sanitizeBase(basename3(resolved))}-${hash}`;
-}
-function fallbackResult(dataRoot, projectLink, reason) {
-  return { dataDir: projectLink, dataRoot, linked: false, mode: "in-place-fallback", projectLink, reason };
-}
-function isSameFilesystem(workspace, dataRoot, override) {
-  if (override !== undefined)
-    return override;
-  return statSync(workspace).dev === statSync(dataRoot).dev;
-}
-function ensureInPlaceFallback(projectLink) {
-  if (!existsSync5(projectLink))
-    mkdirSync(projectLink, { recursive: true });
-}
-function prepareCodegraphWorkspace(workspace, options = {}) {
-  const resolvedWorkspace = resolve2(workspace);
-  const dataRoot = codegraphDataRoot(options.homeDir ?? homedir5());
-  const dataDir = join6(dataRoot, "projects", workspaceStorageName(resolvedWorkspace));
-  const projectLink = join6(resolvedWorkspace, ".codegraph");
-  try {
-    mkdirSync(dataDir, { recursive: true });
-    if (existsSync5(projectLink)) {
-      const linkStat = lstatSync(projectLink);
-      if (!linkStat.isSymbolicLink()) {
-        return { dataDir: projectLink, dataRoot, linked: false, mode: "in-project", projectLink };
-      }
-      if (realpathSync(projectLink) === realpathSync(dataDir)) {
-        return { dataDir, dataRoot, linked: true, mode: "global-linked", projectLink };
-      }
-      return fallbackResult(dataRoot, projectLink, "existing .codegraph symlink points outside OMO store");
-    }
-    if (!isSameFilesystem(resolvedWorkspace, dataRoot, options.sameFilesystem)) {
-      ensureInPlaceFallback(projectLink);
-      return fallbackResult(dataRoot, projectLink, "workspace and OMO store are on different filesystems");
-    }
-    const symlink = options.symlink ?? symlinkSync;
-    symlink(dataDir, projectLink, (options.platform ?? process.platform) === "win32" ? "junction" : "dir");
-    return { dataDir, dataRoot, linked: true, mode: "global-linked", projectLink };
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    try {
-      ensureInPlaceFallback(projectLink);
-    } catch (fallbackError) {
-      return fallbackResult(dataRoot, projectLink, `${reason}; fallback failed: ${String(fallbackError)}`);
-    }
-    return fallbackResult(dataRoot, projectLink, reason);
-  }
-}
-function ensureCodegraphGitignored(workspace) {
-  const gitDir = join6(workspace, ".git");
-  if (!existsSync5(gitDir))
-    return false;
-  const excludePath = join6(gitDir, "info", "exclude");
-  try {
-    mkdirSync(join6(gitDir, "info"), { recursive: true });
-    const existing = existsSync5(excludePath) ? readFileSync2(excludePath, "utf8") : "";
-    if (existing.split(/\r?\n/).includes(".codegraph"))
-      return true;
-    appendFileSync(excludePath, `${existing.endsWith(`
-`) || existing.length === 0 ? "" : `
-`}.codegraph
-`);
-    return true;
-  } catch (error) {
-    if (error instanceof Error)
-      return false;
-    throw error;
-  }
-}
-
 // components/codegraph/src/session-start-worker.ts
 var SESSION_START_CWD_ENV = "OMO_CODEGRAPH_SESSION_START_CWD";
 var CODEGRAPH_VERSION = "1.0.1";
@@ -1866,13 +1962,10 @@ function finish(action, detail, logOutcome) {
 }
 async function resolveOrProvisionCommand(deps, config, env, homeDir, nodeSupport) {
   const resolved = deps.resolveCommand({ env, homeDir, provisioned: () => provisionedBinFromInstallDir(config.install_dir) });
-  if (resolved.exists) {
-    if (codegraphCommandRequiresSupportedLocalNode(resolved) && !nodeSupport.supported) {
-      return { kind: "unsupported-node" };
-    }
+  if (resolved.exists && canUseResolvedCommand(resolved, nodeSupport)) {
     return { kind: "resolved", resolution: resolved };
   }
-  if (!nodeSupport.supported)
+  if (resolved.exists && config.auto_provision === false)
     return { kind: "unsupported-node" };
   if (config.auto_provision === false)
     return { error: "codegraph binary unavailable and auto_provision is disabled", kind: "unavailable", source: resolved.source };
@@ -1883,6 +1976,9 @@ async function resolveOrProvisionCommand(deps, config, env, homeDir, nodeSupport
   }
   return { kind: "resolved", resolution: { argsPrefix: [], command: provisioned.binPath, exists: true, source: "provisioned" } };
 }
+function canUseResolvedCommand(resolved, nodeSupport) {
+  return !codegraphCommandRequiresSupportedLocalNode(resolved) || nodeSupport.supported;
+}
 function decideStartupAction(status) {
   if (status.timedOut)
     return { kind: "skip", reason: "status timed out" };
@@ -1900,7 +1996,7 @@ ${status.stderr ?? ""}`.toLowerCase();
   return { kind: "sync" };
 }
 function jsonSaysInitialized(value) {
-  if (!isRecord2(value))
+  if (!isRecord3(value))
     return;
   const initialized = value["initialized"] ?? value["isInitialized"] ?? value["ready"];
   if (typeof initialized === "boolean")
@@ -1966,7 +2062,7 @@ function toOutputText(value) {
   return Buffer.isBuffer(value) ? value.toString("utf8") : value;
 }
 function resolveHomeDir(env) {
-  return env["HOME"] ?? env["USERPROFILE"] ?? homedir6();
+  return env["HOME"] ?? env["USERPROFILE"] ?? homedir7();
 }
 function parseJson(text) {
   try {
@@ -1977,7 +2073,7 @@ function parseJson(text) {
     throw error;
   }
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -1986,6 +2082,9 @@ var CODEGRAPH_SESSION_START_NOTICE = "LazyCodex CodeGraph bootstrap scheduled in
 async function runCodegraphSessionStartHook(options = {}) {
   return (await executeCodegraphSessionStartHook(options)).exitCode;
 }
+async function runCodegraphPostToolUseHookCli(options = {}) {
+  return (await executeCodegraphPostToolUseHook(options)).exitCode;
+}
 async function executeCodegraphSessionStartHook(options = {}) {
   const env = options.env ?? processEnv2;
   const input = await readHookInput(options.stdin ?? processStdin);
@@ -2003,6 +2102,30 @@ async function executeCodegraphSessionStartHook(options = {}) {
   writeHookJson(options.stdout ?? processStdout);
   return { action: "spawned", exitCode: 0 };
 }
+async function executeCodegraphPostToolUseHook(options = {}) {
+  const env = options.env ?? processEnv2;
+  const input = await readHookInput(options.stdin ?? processStdin);
+  const output = runCodegraphPostToolUseHook(input, { homeDir: resolveHomeDir2(env) });
+  if (output.length === 0)
+    return { action: "skipped", exitCode: 0 };
+  (options.stdout ?? processStdout).write(output);
+  return { action: "emitted-guidance", exitCode: 0 };
+}
+function runCodegraphPostToolUseHook(input, options = {}) {
+  const toolName = isRecord4(input) ? input["tool_name"] : undefined;
+  const cwd = isRecord4(input) ? input["cwd"] : undefined;
+  const toolOutput = isRecord4(input) ? input["tool_response"] ?? input["tool_output"] ?? input["response"] : input;
+  const guidance = buildCodegraphInitGuidanceForToolResult({ cwd, toolName, toolOutput }, options);
+  if (guidance === null)
+    return "";
+  return `${JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PostToolUse",
+      additionalContext: guidance
+    }
+  })}
+`;
+}
 function writeHookJson(stdout) {
   const output = {
     hookSpecificOutput: {
@@ -2018,10 +2141,10 @@ function spawnDetachedWorker(invocation) {
   child.unref();
 }
 function resolveHomeDir2(env) {
-  return env["HOME"] ?? env["USERPROFILE"] ?? homedir7();
+  return env["HOME"] ?? env["USERPROFILE"] ?? homedir8();
 }
 function resolveProjectRoot(input, fallback) {
-  if (!isRecord3(input))
+  if (!isRecord4(input))
     return fallback;
   const cwd = input["cwd"];
   return typeof cwd === "string" && cwd.trim().length > 0 ? cwd : fallback;
@@ -2045,7 +2168,7 @@ function parseJson2(text) {
     throw error;
   }
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 function defaultWorkerCliPath() {
@@ -2055,7 +2178,7 @@ function defaultWorkerCliPath() {
 // components/codegraph/src/serve.ts
 import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync7, realpathSync as realpathSync2 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
+import { homedir as homedir9 } from "node:os";
 import { basename as basename4, extname as extname2, join as join8, resolve as resolve3 } from "node:path";
 import {
   cwd as processCwd3,
@@ -2068,11 +2191,12 @@ var CODEGRAPH_SKIP_HINT = `CodeGraph MCP skipped: codegraph binary not found. In
 `;
 var CODEGRAPH_DISABLED_HINT = `CodeGraph MCP skipped: disabled by OMO SOT config. Set [codex].codegraph.enabled=true to enable it.
 `;
+var CODEGRAPH_VERSION2 = "1.0.1";
 var WINDOWS_CMD_EXTENSIONS2 = new Set([".bat", ".cmd"]);
 var WINDOWS_NODE_SCRIPT_EXTENSIONS = new Set([".cjs", ".js", ".mjs"]);
 async function runCodegraphServe(options = {}) {
   const env = options.env ?? processEnv3;
-  const homeDir = options.homeDir ?? homedir8();
+  const homeDir = options.homeDir ?? homedir9();
   const config = options.config ?? getCodexOmoConfig({ cwd: options.cwd ?? processCwd3(), env, homeDir });
   const codegraphConfig = config.codegraph ?? {};
   if (codegraphConfig.enabled === false) {
@@ -2084,15 +2208,24 @@ async function runCodegraphServe(options = {}) {
     homeDir,
     provisioned: () => provisionedBinFromInstallDir2(codegraphConfig.install_dir)
   };
-  const resolution = options.resolve?.(resolutionOptions) ?? resolveCodegraphCommand(resolutionOptions);
+  let resolution = options.resolve?.(resolutionOptions) ?? resolveCodegraphCommand(resolutionOptions);
   const nodeSupport = evaluateCodegraphNodeSupport({ env, nodeVersion: options.nodeVersion });
   if (!resolution.exists || shouldSkipResolvedCommand(resolution, options.commandExists ?? existsSync7)) {
     if (resolution.source === "path" && !nodeSupport.supported) {
       (options.stderr ?? processStderr2).write(buildCodegraphNodeSkipHint(nodeSupport));
       return 1;
     }
-    (options.stderr ?? processStderr2).write(CODEGRAPH_SKIP_HINT);
-    return 1;
+    const provisioned = await provisionMissingCodegraph({
+      config: codegraphConfig,
+      ensureProvisioned: options.ensureProvisioned ?? ensureCodegraphProvisioned,
+      homeDir,
+      resolution
+    });
+    if (provisioned === null) {
+      (options.stderr ?? processStderr2).write(CODEGRAPH_SKIP_HINT);
+      return 1;
+    }
+    resolution = provisioned;
   }
   if (codegraphCommandRequiresSupportedLocalNode(resolution) && !nodeSupport.supported) {
     (options.stderr ?? processStderr2).write(buildCodegraphNodeSkipHint(nodeSupport));
@@ -2109,6 +2242,21 @@ async function runCodegraphServe(options = {}) {
     stdio: "inherit"
   });
 }
+async function provisionMissingCodegraph(options) {
+  if (options.resolution.source === "env")
+    return null;
+  if (options.config.auto_provision === false)
+    return null;
+  const installDir = options.config.install_dir ?? join8(options.homeDir, ".omo", "codegraph");
+  const result = await options.ensureProvisioned({
+    installDir,
+    lockDir: join8(installDir, ".locks"),
+    version: CODEGRAPH_VERSION2
+  });
+  if (!result.provisioned || result.binPath === undefined)
+    return null;
+  return { argsPrefix: [], command: result.binPath, exists: true, source: "provisioned" };
+}
 function shouldSkipResolvedCommand(resolution, commandExists) {
   if (resolution.source !== "env")
     return false;
@@ -2183,6 +2331,14 @@ async function runCodegraphCli(options = {}) {
   if (command === "hook" && subcommand === "session-start") {
     return runCodegraphSessionStartHook(options);
   }
+  if (command === "hook" && subcommand === "post-tool-use") {
+    const hookOptions = {
+      ...options.env === undefined ? {} : { env: options.env },
+      ...options.stdin === undefined ? {} : { stdin: options.stdin },
+      ...options.stdout === undefined ? {} : { stdout: options.stdout }
+    };
+    return runCodegraphPostToolUseHookCli(hookOptions);
+  }
   if (command === "hook" && subcommand === "session-start-worker") {
     const workerOptions = {
       ...options.workerOptions,