oh-my-opencode 4.11.0 → 4.12.0

package/packages/omo-codex/scripts/install-git-bash-mcp-env.test.mjs

@@ -62,6 +62,30 @@ test("#given a non-Windows install #when stamping #then the manifest stays byte-
 	assert.equal(await readFile(join(pluginRoot, ".mcp.json"), "utf8"), MANIFEST);
 });
 
+test("#given a package-relative CodeGraph MCP path #when stamping on non-Windows #then codegraph server arg becomes absolute", async (t) => {
+	const pluginRoot = await mkdtemp(join(tmpdir(), "git-bash-mcp-env-"));
+	t.after(() => rm(pluginRoot, { recursive: true, force: true }));
+	await writeFile(
+		join(pluginRoot, ".mcp.json"),
+		`${JSON.stringify(
+			{
+				mcpServers: {
+					codegraph: { args: ["components/codegraph/dist/serve.js"], command: "node" },
+					git_bash: { command: "node", args: ["../../git-bash-mcp/dist/cli.js", "mcp"] },
+				},
+			},
+			null,
+			"\t",
+		)}\n`,
+	);
+
+	const changed = await stampGitBashMcpEnv({ pluginRoot, env: {}, platform: "darwin" });
+
+	assert.equal(changed, true);
+	const parsed = JSON.parse(await readFile(join(pluginRoot, ".mcp.json"), "utf8"));
+	assert.deepEqual(parsed.mcpServers.codegraph.args, [join(pluginRoot, "components", "codegraph", "dist", "serve.js")]);
+});
+
 test("#given the override already stamped #when stamping again #then nothing changes", async (t) => {
 	const pluginRoot = await createPluginRoot();
 	t.after(() => rm(pluginRoot, { recursive: true, force: true }));

package/packages/omo-codex/scripts/install-hook-targets.test.mjs

@@ -56,6 +56,67 @@ async function createPluginRoot({ withGitBashDist }) {
 	return pluginRoot;
 }
 
+async function createPluginRootWithHookArray({ withGitBashDist }) {
+	const pluginRoot = await mkdtemp(join(tmpdir(), "hook-targets-array-"));
+	await mkdir(join(pluginRoot, ".codex-plugin"), { recursive: true });
+	await mkdir(join(pluginRoot, "hooks"), { recursive: true });
+	await writeFile(
+		join(pluginRoot, ".codex-plugin", "plugin.json"),
+		JSON.stringify({ name: "omo", hooks: ["./hooks/session-start.json", "./hooks/stop.json"] }, null, "\t"),
+	);
+	await writeFile(
+		join(pluginRoot, "hooks", "session-start.json"),
+		JSON.stringify({ hooks: { SessionStart: HOOKS_MANIFEST.hooks.SessionStart } }, null, "\t"),
+	);
+	await writeFile(
+		join(pluginRoot, "hooks", "stop.json"),
+		JSON.stringify({ hooks: { Stop: HOOKS_MANIFEST.hooks.Stop } }, null, "\t"),
+	);
+	const targets = [
+		"scripts/auto-update.mjs",
+		"components/ulw-loop/dist/cli.js",
+		...(withGitBashDist ? ["components/git-bash/dist/cli.js"] : []),
+	];
+	for (const target of targets) {
+		await mkdir(dirname(join(pluginRoot, target)), { recursive: true });
+		await writeFile(join(pluginRoot, target), "");
+	}
+	return pluginRoot;
+}
+
+async function createPluginRootWithWindowsHook({ withBootstrapScript }) {
+	const pluginRoot = await mkdtemp(join(tmpdir(), "hook-targets-windows-"));
+	await mkdir(join(pluginRoot, "hooks"), { recursive: true });
+	await writeFile(
+		join(pluginRoot, "hooks", "hooks.json"),
+		JSON.stringify(
+			{
+				hooks: {
+					SessionStart: [
+						{
+							hooks: [
+								{
+									type: "command",
+									commandWindows:
+										'powershell -NoProfile -ExecutionPolicy Bypass -File "${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\bootstrap.ps1"',
+								},
+							],
+						},
+					],
+				},
+			},
+			null,
+			"\t",
+		),
+	);
+	if (withBootstrapScript) {
+		const target = join(pluginRoot, "components", "bootstrap", "scripts", "bootstrap.ps1");
+		await mkdir(dirname(target), { recursive: true });
+		await writeFile(target, "");
+	}
+	return pluginRoot;
+}
+
 test("#given a hook command target missing from the payload #when scanning #then exactly that path is reported", async (t) => {
 	const pluginRoot = await createPluginRoot({ withGitBashDist: false });
 	t.after(() => rm(pluginRoot, { recursive: true, force: true }));
@@ -65,6 +126,22 @@ test("#given a hook command target missing from the payload #when scanning #then
 	assert.deepEqual(missing, [join(pluginRoot, "components/git-bash/dist/cli.js")]);
 });
 
+test("#given a Windows hook command target missing from the payload #when scanning #then the backslash path is reported", async (t) => {
+	const pluginRoot = await createPluginRootWithWindowsHook({ withBootstrapScript: false });
+	t.after(() => rm(pluginRoot, { recursive: true, force: true }));
+
+	const missing = await findMissingHookCommandTargets(pluginRoot);
+
+	assert.deepEqual(missing, [join(pluginRoot, "components", "bootstrap", "scripts", "bootstrap.ps1")]);
+});
+
+test("#given a Windows hook command target exists in the payload #when scanning #then nothing is missing", async (t) => {
+	const pluginRoot = await createPluginRootWithWindowsHook({ withBootstrapScript: true });
+	t.after(() => rm(pluginRoot, { recursive: true, force: true }));
+
+	assert.deepEqual(await findMissingHookCommandTargets(pluginRoot), []);
+});
+
 test("#given a complete payload #when scanning #then nothing is missing", async (t) => {
 	const pluginRoot = await createPluginRoot({ withGitBashDist: true });
 	t.after(() => rm(pluginRoot, { recursive: true, force: true }));
@@ -72,6 +149,22 @@ test("#given a complete payload #when scanning #then nothing is missing", async
 	assert.deepEqual(await findMissingHookCommandTargets(pluginRoot), []);
 });
 
+test("#given hook manifests declared as an array #when scanning #then missing targets are reported", async (t) => {
+	const pluginRoot = await createPluginRootWithHookArray({ withGitBashDist: false });
+	t.after(() => rm(pluginRoot, { recursive: true, force: true }));
+
+	const missing = await findMissingHookCommandTargets(pluginRoot);
+
+	assert.deepEqual(missing, [join(pluginRoot, "components/git-bash/dist/cli.js")]);
+});
+
+test("#given hook manifests declared as an array and complete payload #when scanning #then nothing is missing", async (t) => {
+	const pluginRoot = await createPluginRootWithHookArray({ withGitBashDist: true });
+	t.after(() => rm(pluginRoot, { recursive: true, force: true }));
+
+	assert.deepEqual(await findMissingHookCommandTargets(pluginRoot), []);
+});
+
 test("#given no hooks manifest #when scanning #then nothing is missing", async (t) => {
 	const pluginRoot = await mkdtemp(join(tmpdir(), "hook-targets-"));
 	t.after(() => rm(pluginRoot, { recursive: true, force: true }));

package/packages/omo-codex/scripts/install-lazycodex-version-stamp.test.mjs

@@ -77,8 +77,8 @@ test("#given sisyphuslabs lazycodex install #when installing locally #then stamp
 	assert.equal(manifest.version, "4.7.6");
 	assert.equal(packageJson.version, "4.7.6");
 	assert.equal(componentPackageJson.version, "4.7.6");
-	assert.equal(hooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(4.7.6): Checking Comments");
-	assert.equal(componentHooks.hooks.UserPromptSubmit[0].hooks[0].statusMessage, "LazyCodex(4.7.6): Checking Ulw-Loop Steering");
+	assert.equal(hooks.hooks.PostToolUse[0].hooks[0].statusMessage, "(OmO) Checking Comments");
+	assert.equal(componentHooks.hooks.UserPromptSubmit[0].hooks[0].statusMessage, "(OmO) Checking Ulw-Loop Steering");
 	assert.deepEqual(snapshot, {
 		packageName: "lazycodex-ai",
 		version: "4.7.6",

package/packages/omo-codex/scripts/install-local-bun-global-update.test.mjs

@@ -0,0 +1,63 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+test("#given direct bun global lazycodex bin #when running update dry-run #then prints bun global update command", { skip: process.platform === "win32" }, () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+	const tempHome = mkdtempSync(join(tmpdir(), "lazycodex-bun-global-bin-"));
+	const binDir = join(tempHome, ".bun", "bin");
+	const binPath = join(binDir, "lazycodex-ai");
+	mkdirSync(binDir, { recursive: true });
+
+	try {
+		writeDirectBunGlobalLazyCodexBin(binPath, scriptPath);
+
+		// when
+		const output = execFileSync(process.execPath, [binPath, "--dry-run", "update"], {
+			encoding: "utf8",
+			env: {
+				...process.env,
+				HOME: tempHome,
+				LAZYCODEX_CURRENT_VERSION: "1.0.0",
+				LAZYCODEX_LATEST_VERSION: "1.0.1",
+			},
+		}).trim();
+
+		// then
+		assert.equal(output, "bun update -g lazycodex-ai@latest\nnpx --yes lazycodex-ai@latest install --no-tui --codex-autonomous");
+	} finally {
+		rmSync(tempHome, { recursive: true, force: true });
+	}
+});
+
+function writeDirectBunGlobalLazyCodexBin(binPath, scriptPath) {
+	const generatedInstallerUrl = pathToFileURL(fileURLToPath(new URL("./install-dist/install-local.mjs", import.meta.url))).href;
+	const repoRoot = join(dirname(scriptPath), "..", "..", "..");
+	writeFileSync(
+		binPath,
+		`#!/usr/bin/env node
+import { runLazyCodexInstallLocalCli } from ${JSON.stringify(generatedInstallerUrl)};
+
+runLazyCodexInstallLocalCli({
+	argv: process.argv.slice(2),
+	defaultRepoRoot: ${JSON.stringify(repoRoot)},
+	entrypointPath: ${JSON.stringify(scriptPath)},
+	invokedPath: process.argv[1] ?? "",
+	cwd: process.cwd(),
+	env: process.env,
+	log: console.log,
+}).then((exitCode) => {
+	process.exitCode = exitCode;
+}).catch((error) => {
+	console.error(error instanceof Error ? error.message : error);
+	process.exitCode = 1;
+});
+`,
+	);
+	chmodSync(binPath, 0o755);
+}

package/packages/omo-codex/scripts/install-local-entrypoint.test.mjs

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
-import { mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import test from "node:test";
@@ -148,6 +148,69 @@ test("#given stale lazycodex version #when running update dry-run #then prints t
 	assert.equal(output, "npx --yes lazycodex-ai@latest install --no-tui --codex-autonomous");
 });
 
+test("#given bun global lazycodex wrapper #when running update dry-run #then prints bun global update command", { skip: process.platform === "win32" }, () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+	const tempHome = mkdtempSync(join(tmpdir(), "lazycodex-bun-global-dry-run-"));
+	const binPath = createBunGlobalLazyCodexSymlink(tempHome, scriptPath);
+
+	try {
+		// when
+		const output = execFileSync(process.execPath, [binPath, "--dry-run", "update"], {
+			encoding: "utf8",
+			env: {
+				...process.env,
+				HOME: tempHome,
+				LAZYCODEX_CURRENT_VERSION: "1.0.0",
+				LAZYCODEX_LATEST_VERSION: "1.0.1",
+			},
+		}).trim();
+
+		// then
+		assert.equal(output, "bun update -g lazycodex-ai@latest\nnpx --yes lazycodex-ai@latest install --no-tui --codex-autonomous");
+	} finally {
+		rmSync(tempHome, { recursive: true, force: true });
+	}
+});
+
+test("#given bun global lazycodex wrapper and untrusted known scripts #when update runs noninteractively #then prints manual scoped trust command", { skip: process.platform === "win32" }, () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+	const tempHome = mkdtempSync(join(tmpdir(), "lazycodex-bun-global-trust-"));
+	const tempBin = mkdtempSync(join(tmpdir(), "lazycodex-bun-bin-"));
+	const commandLogPath = join(tempHome, "commands.log");
+	const binPath = createBunGlobalLazyCodexSymlink(tempHome, scriptPath);
+	writeFakeBunCommand(tempBin);
+	writeFakeNpxCommand(tempBin);
+
+	try {
+		// when
+		const output = execFileSync(process.execPath, [binPath, "update"], {
+			encoding: "utf8",
+			env: {
+				...process.env,
+				HOME: tempHome,
+				LAZYCODEX_CURRENT_VERSION: "1.0.0",
+				LAZYCODEX_LATEST_VERSION: "1.0.1",
+				LAZYCODEX_TEST_COMMAND_LOG: commandLogPath,
+				PATH: `${tempBin}:${process.env.PATH ?? ""}`,
+			},
+		});
+		const commandLog = readFileSync(commandLogPath, "utf8");
+
+		// then
+		assert.match(commandLog, /^bun update -g lazycodex-ai@latest$/m);
+		assert.match(commandLog, /^bun pm -g untrusted$/m);
+		assert.match(commandLog, /^npx --yes lazycodex-ai@latest install --no-tui --codex-autonomous$/m);
+		assert.doesNotMatch(commandLog, /^bun pm -g trust/m);
+		assert.match(output, /bun pm -g trust oh-my-openagent @code-yeongyu\/comment-checker/);
+		assert.doesNotMatch(output, /left-pad/);
+	} finally {
+		rmSync(tempHome, { recursive: true, force: true });
+		rmSync(tempBin, { recursive: true, force: true });
+	}
+});
+
 test("#given current lazycodex version #when running update dry-run #then reports already current", () => {
 	// given
 	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
@@ -166,6 +229,51 @@ test("#given current lazycodex version #when running update dry-run #then report
 	assert.equal(output, "lazycodex-ai 1.0.1 is already up to date.");
 });
 
+function createBunGlobalLazyCodexSymlink(homeDir, scriptPath) {
+	const packageBinDir = join(homeDir, ".bun", "install", "global", "node_modules", "lazycodex-ai", "bin");
+	mkdirSync(packageBinDir, { recursive: true });
+	const binPath = join(packageBinDir, "lazycodex-ai");
+	symlinkSync(scriptPath, binPath);
+	return binPath;
+}
+
+function writeExecutable(path, source) {
+	writeFileSync(path, source);
+	chmodSync(path, 0o755);
+}
+
+function writeFakeBunCommand(binDir) {
+	writeExecutable(
+		join(binDir, "bun"),
+		`#!/bin/sh
+printf '%s\\n' "bun $*" >> "$LAZYCODEX_TEST_COMMAND_LOG"
+if [ "$1" = "pm" ] && [ "$2" = "-g" ] && [ "$3" = "untrusted" ]; then
+  cat <<'EOF'
+./node_modules/oh-my-openagent @4.9.2
+ » [postinstall]: node postinstall.mjs
+
+./node_modules/left-pad @1.0.0
+ » [postinstall]: node postinstall.js
+
+./node_modules/@code-yeongyu/comment-checker @0.8.0
+ » [postinstall]: node postinstall.js
+EOF
+fi
+exit 0
+`,
+	);
+}
+
+function writeFakeNpxCommand(binDir) {
+	writeExecutable(
+		join(binDir, "npx"),
+		`#!/bin/sh
+printf '%s\\n' "npx $*" >> "$LAZYCODEX_TEST_COMMAND_LOG"
+exit 0
+`,
+	);
+}
+
 test("#given dry-run ulw-loop #when running the Node installer entrypoint #then prints delegated ulw-loop command", () => {
 	// given
 	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));

package/packages/omo-codex/scripts/install-local.mjs

@@ -70,6 +70,7 @@ if (isEntrypointInvocation(process.argv[1] ?? "")) {
 			argv: process.argv.slice(2),
 			defaultRepoRoot: resolveDefaultRepoRoot(),
 			entrypointPath,
+			invokedPath: process.argv[1] ?? "",
 			cwd: process.cwd(),
 			env: process.env,
 			log: console.log,

package/packages/omo-codex/scripts/install-mcp-runtime.test.mjs

@@ -104,6 +104,42 @@ test("#given plugin-local MCP runtime #when installing cached plugin #then manif
 	assert.deepEqual(cachedMcp.mcpServers.omo.args, [join(result.path, "dist", "cli.js")]);
 });
 
+test("#given CodeGraph MCP runtime in plugin cache #when installing cached plugin #then manifest points at cached plugin before bootstrap", async () => {
+	const repoRoot = await makeTempDir();
+	const codexHome = await makeTempDir();
+	const sourceRoot = join(repoRoot, "packages", "omo-codex", "plugin");
+
+	await writeJson(join(sourceRoot, "package.json"), {
+		name: "@example/omo",
+		version: "0.1.0",
+	});
+	await writeJson(join(sourceRoot, ".mcp.json"), {
+		mcpServers: {
+			codegraph: {
+				command: "node",
+				args: ["components/codegraph/dist/serve.js"],
+				cwd: ".",
+				required: false,
+			},
+		},
+	});
+	await writeJson(join(sourceRoot, "components", "codegraph", "dist", "serve.js"), { executable: true });
+
+	const result = await installCachedPlugin({
+		codexHome,
+		marketplaceName: "sisyphuslabs",
+		name: "omo",
+		runCommand: async () => {},
+		sourcePath: sourceRoot,
+		version: "0.1.0",
+	});
+
+	const cachedMcp = JSON.parse(await readFile(join(result.path, ".mcp.json"), "utf8"));
+
+	assert.deepEqual(cachedMcp.mcpServers.codegraph.args, [join(result.path, "components", "codegraph", "dist", "serve.js")]);
+	assert.equal(Object.hasOwn(cachedMcp.mcpServers.codegraph, "cwd"), false);
+});
+
 test("#given external MCP package not in the generated bundled runtime set #when installing cached plugin #then manifest args point at source", async () => {
 	const repoRoot = await makeTempDir();
 	const codexHome = await makeTempDir();

package/packages/shared-skills/skills/init-deep/SKILL.md

@@ -20,7 +20,7 @@ Generate hierarchical AGENTS.md files. Root + complexity-scored subdirectories.
 
 1. **Discovery + Analysis** (concurrent)
    - Fire background explore agents immediately
-   - Main session: bash structure + LSP codemap + read existing AGENTS.md
+   - Main session: bash structure + LSP/codegraph code map + read existing AGENTS.md
 2. **Score & Decide** - Determine AGENTS.md locations from merged findings
 3. **Generate** - Root first, then subdirs in parallel
 4. **Review** - Deduplicate, trim, validate
@@ -29,7 +29,7 @@ Generate hierarchical AGENTS.md files. Root + complexity-scored subdirectories.
 **TodoWrite ALL phases. Mark in_progress → completed in real-time.**
 ```
 TodoWrite([
-  { id: "discovery", content: "Fire explore agents + LSP codemap + read existing", status: "pending", priority: "high" },
+  { id: "discovery", content: "Fire explore agents + LSP/codegraph map + read existing", status: "pending", priority: "high" },
   { id: "scoring", content: "Score directories, determine locations", status: "pending", priority: "high" },
   { id: "generate", content: "Generate AGENTS.md files (root + subdirs)", status: "pending", priority: "high" },
   { id: "review", content: "Deduplicate, validate, trim", status: "pending", priority: "medium" }
@@ -45,16 +45,16 @@ TodoWrite([
 
 ### Fire Background Explore Agents IMMEDIATELY
 
-Don't wait-these run async while main session works.
+Don't wait-these run async while main session works. **Equip every agent with the code graph**: any task touching structure, entry points, dependencies, or hotspots MUST query `codegraph_*` (explore/search/callers/callees/impact) and `lsp_symbols` when present, and ground its claims in that data instead of guessing from conventions. Richer real-graph context per agent = a more accurate project map.
 
 ```
 // Fire all at once, collect results later
-task(subagent_type="explore", load_skills=[], description="Explore project structure", run_in_background=true, prompt="Project structure: PREDICT standard patterns for detected language → REPORT deviations only")
-task(subagent_type="explore", load_skills=[], description="Find entry points", run_in_background=true, prompt="Entry points: FIND main files → REPORT non-standard organization")
+task(subagent_type="explore", load_skills=[], description="Explore project structure", run_in_background=true, prompt="Project structure: map real layout via codegraph_explore/codegraph_files → REPORT deviations from standard patterns")
+task(subagent_type="explore", load_skills=[], description="Find entry points", run_in_background=true, prompt="Entry points: FIND main files, trace reach via codegraph_callees + lsp_symbols → REPORT non-standard organization")
 task(subagent_type="explore", load_skills=[], description="Find conventions", run_in_background=true, prompt="Conventions: FIND config files (.eslintrc, pyproject.toml, .editorconfig) → REPORT project-specific rules")
 task(subagent_type="explore", load_skills=[], description="Find anti-patterns", run_in_background=true, prompt="Anti-patterns: FIND 'DO NOT', 'NEVER', 'ALWAYS', 'DEPRECATED' comments → LIST forbidden patterns")
 task(subagent_type="explore", load_skills=[], description="Explore build/CI", run_in_background=true, prompt="Build/CI: FIND .github/workflows, Makefile → REPORT non-standard patterns")
-task(subagent_type="explore", load_skills=[], description="Find test patterns", run_in_background=true, prompt="Test patterns: FIND test configs, test structure → REPORT unique conventions")
+task(subagent_type="explore", load_skills=[], description="Find test patterns", run_in_background=true, prompt="Test patterns: FIND test configs/structure; codegraph_callers on core modules to see what is covered → REPORT unique conventions")
 ```
 
 <dynamic-agents>
@@ -116,24 +116,19 @@ For each existing file found:
 
 If `--create-new`: Read all existing first (preserve context) → then delete all → regenerate.
 
-#### 3. LSP Codemap (if available)
-```
-LspServers()  # Check availability
+#### 3. Code Map - drive LSP AND codegraph (do NOT skip)
 
-# Entry points (parallel)
-LspDocumentSymbols(filePath="src/index.ts")
-LspDocumentSymbols(filePath="main.py")
+Highest-signal source for the CODE MAP and the Symbol/Export/Reference scoring rows. Complementary, not alternatives - run BOTH when present, alongside the explore agents.
 
-# Key symbols (parallel)
-LspWorkspaceSymbols(filePath=".", query="class")
-LspWorkspaceSymbols(filePath=".", query="interface")
-LspWorkspaceSymbols(filePath=".", query="function")
+**LSP** - check `lsp_status`; model-facing names are `lsp_status`/`lsp_symbols`/`lsp_find_references`/`lsp_goto_definition` (some harnesses drop the `lsp_` prefix):
+- `lsp_symbols` scope="document" on each entry point -> file outline.
+- `lsp_symbols` scope="workspace", query by kind (class/interface/function) -> symbol inventory.
+- `lsp_find_references` on top exports (line/character from the symbols result) -> reference centrality.
 
-# Centrality for top exports
-LspFindReferences(filePath="...", line=X, character=Y)
-```
+**codegraph** - when `codegraph_*` tools exist (check `codegraph_status`); a first-class peer to LSP, NOT a last resort:
+- `codegraph_explore` -> overview; `codegraph_callers`/`codegraph_callees`/`codegraph_impact` -> centrality + blast radius for the scoring matrix; `codegraph_search`/`codegraph_files` -> symbol/file inventory.
 
-**LSP Fallback**: If unavailable, use `codegraph_explore` first when codegraph_* tools exist; otherwise rely on explore agents + the ast-grep skill (`sg` CLI).
+Only if NEITHER exists: explore agents + the ast-grep skill (`sg`), and mark centrality unmeasured in the CODE MAP.
 
 ### Collect Background Results
 
@@ -142,7 +137,7 @@ LspFindReferences(filePath="...", line=X, character=Y)
 for each background task ID (`bg_...`): background_output(task_id="bg_...")
 ```
 
-**Merge: bash + LSP + existing + explore findings. Mark "discovery" as completed.**
+**Merge: bash + LSP/codegraph + existing + explore findings. Mark "discovery" as completed.**
 
 ---
 
@@ -159,9 +154,9 @@ for each background task ID (`bg_...`): background_output(task_id="bg_...")
 | Code ratio | 2x | >70% | bash |
 | Unique patterns | 1x | Has own config | explore |
 | Module boundary | 2x | Has index.ts/__init__.py | bash |
-| Symbol density | 2x | >30 symbols | LSP |
-| Export count | 2x | >10 exports | LSP |
-| Reference centrality | 3x | >20 refs | LSP |
+| Symbol density | 2x | >30 symbols | LSP/cg |
+| Export count | 2x | >10 exports | LSP/cg |
+| Reference centrality | 3x | >20 refs | LSP/cg |
 
 ### Decision Rules
 
@@ -218,7 +213,7 @@ NEVER use Write to overwrite an existing file. ALWAYS check existence first via
 |------|----------|-------|
 
 ## CODE MAP
-{From LSP - skip if unavailable or project <10 files}
+{From LSP/codegraph - skip only if neither exists or project <10 files}
 
 | Symbol | Type | Location | Refs | Role |
 |--------|------|----------|------|------|
@@ -301,7 +296,7 @@ Hierarchy:
 ## Anti-Patterns
 
 - **Static agent count**: MUST vary agents based on project size/depth
-- **Sequential execution**: MUST parallel (explore + LSP concurrent)
+- **Sequential execution**: MUST parallel (explore + LSP + codegraph concurrent)
 - **Ignoring existing**: ALWAYS read existing first, even with --create-new
 - **Over-documenting**: Not every dir needs AGENTS.md
 - **Redundancy**: Child never repeats parent