oh-my-opencode 4.9.2 → 4.11.0

package/packages/omo-codex/plugin/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@sisyphuslabs/omo-codex-plugin",
-  "version": "4.9.2",
+  "version": "4.11.0",
   "description": "Aggregate Codex plugin root for OMO components.",
   "type": "module",
   "packageManager": "npm@11.12.1",
   "private": true,
   "workspaces": [
+    "components/codegraph",
     "components/comment-checker",
     "components/git-bash",
+    "components/lazycodex-executor-verify",
     "components/rules",
     "components/lsp",
     "components/telemetry",
@@ -19,7 +21,7 @@
     "@oh-my-opencode/shared-skills": "file:../../shared-skills"
   },
   "scripts": {
-    "build": "node scripts/sync-version.mjs && node scripts/sync-hook-status-messages.mjs && node scripts/build-bundled-mcp-runtimes.mjs && node scripts/sync-skills.mjs && node ../scripts/sync-telemetry-component.mjs && node scripts/build-components.mjs",
+    "build": "node scripts/sync-version.mjs && node scripts/sync-hook-status-messages.mjs && node scripts/build-bundled-mcp-runtimes.mjs && node scripts/sync-skills.mjs && node scripts/build-components.mjs",
     "sync:version": "node scripts/sync-version.mjs",
     "check": "npm run build && npm test",
     "sync:hooks": "node scripts/sync-hook-status-messages.mjs",

package/packages/omo-codex/plugin/scripts/auto-update-state.d.mts

@@ -0,0 +1,20 @@
+export type AutoUpdateEnv = Record<string, string | undefined>;
+
+export declare const DEFAULT_LOCK_STALE_MS: number;
+
+export interface AcquiredLock {
+	release(): Promise<void>;
+}
+
+export declare function resolveStatePath(env: AutoUpdateEnv): string;
+export declare function resolveLogPath(env: AutoUpdateEnv): string;
+export declare function resolveLockPath(env: AutoUpdateEnv, statePath: string): string;
+export declare function acquireLock(lockPath: string, now: number, staleMs?: number): Promise<AcquiredLock | null>;
+export declare function readState(statePath: string): Promise<Record<string, unknown>>;
+export declare function writeState(statePath: string, state: unknown): Promise<void>;
+export declare function appendUpdateLog(
+	env: AutoUpdateEnv,
+	now: number,
+	event: string,
+	details?: Record<string, unknown>,
+): Promise<void>;

package/packages/omo-codex/plugin/scripts/auto-update.mjs

@@ -13,16 +13,19 @@ import {
 	resolveStatePath,
 	writeState,
 } from "./auto-update-state.mjs";
+import { detectInstallFlow, resolveInstallSnapshotPath } from "./install-flow.mjs";
 import { migrateCodexConfig } from "./migrate-codex-config.mjs";
+import { migrateOmoSotConfig } from "./migrate-omo-sot.mjs";
 import { resolveSpawnInvocation } from "./spawn-command.mjs";
 
 const DEFAULT_INTERVAL_MS = 24 * 60 * 60 * 1_000;
 const DEFAULT_RETRY_INTERVAL_MS = 30 * 60 * 1_000;
 const DEFAULT_UPDATE_COMMAND = "npx";
 const DEFAULT_UPDATE_ARGS = ["--yes", "lazycodex-ai@latest", "install", "--no-tui", "--codex-autonomous"];
-const INSTALLED_VERSION_FILE = "lazycodex-install.json";
+const MARKETPLACE_FLOW_NOTICE =
+	"[LazyCodex] Auto-update skipped: this LazyCodex install is managed by the Codex plugin marketplace, so the npx self-update was not started. Tell the user to upgrade with `codex plugin marketplace upgrade sisyphuslabs`, and that Codex will ask them to re-approve hooks after the upgrade.";
 
-export function resolveAutoUpdatePlan({ env = process.env, now = Date.now(), lastCheckedAt, lastAttemptedAt, lastStatus } = {}) {
+export function resolveAutoUpdatePlan({ env = process.env, now = Date.now(), lastCheckedAt, lastAttemptedAt, lastStatus, installFlow } = {}) {
 	if (env.LAZYCODEX_AUTO_UPDATE_DISABLED === "1" || env.OMO_CODEX_AUTO_UPDATE_DISABLED === "1") {
 		return { shouldRun: false, reason: "disabled" };
 	}
@@ -37,6 +40,9 @@ export function resolveAutoUpdatePlan({ env = process.env, now = Date.now(), las
 		return { shouldRun: false, reason: "retry-throttled" };
 	}
 
+	const flow = installFlow ?? detectAutoUpdateInstallFlow(env).flow;
+	if (flow === "marketplace") return { shouldRun: false, reason: "marketplace-flow" };
+
 	const currentVersion = resolveCurrentVersion(env);
 	const latestVersion = resolveLatestVersion(env);
 	const updatePlan = resolveLazyCodexUpdatePlan({
@@ -100,14 +106,25 @@ export async function runAutoUpdateCheck({ env = process.env, now = Date.now() }
 	const statePath = resolveStatePath(env);
 	const notices = [];
 	const state = await settlePendingNotice({ env, now, statePath, state: await readState(statePath), notices });
+	const installFlow = detectAutoUpdateInstallFlow(env);
+	if (installFlow.flow === "unknown") {
+		await appendUpdateLog(env, now, "install-flow-unknown", { reason: installFlow.reason });
+	}
 	const plan = resolveAutoUpdatePlan({
 		env,
 		now,
 		lastCheckedAt: state.lastCheckedAt,
 		lastAttemptedAt: state.lastAttemptedAt,
 		lastStatus: state.lastStatus,
+		installFlow: installFlow.flow,
 	});
 	if (!plan.shouldRun) {
+		if (plan.reason === "marketplace-flow") {
+			await appendUpdateLog(env, now, "skipped", { kind: "marketplace-flow" });
+			await writeState(statePath, { ...state, lastCheckedAt: now, lastStatus: "success" });
+			notices.push(MARKETPLACE_FLOW_NOTICE);
+			return { started: false, reason: plan.reason, notices };
+		}
 		await appendUpdateLog(env, now, "skipped", { reason: plan.reason });
 		if (plan.reason === "up-to-date") {
 			await writeState(statePath, { ...state, lastCheckedAt: now, lastStatus: "success" });
@@ -188,6 +205,7 @@ async function recordUpdateStartedNotice({ env, now, notices, pendingNotice }) {
 async function runConfigMigration({ env }) {
 	if (env.LAZYCODEX_CONFIG_MIGRATION_DISABLED === "1" || env.OMO_CODEX_CONFIG_MIGRATION_DISABLED === "1") return;
 	try {
+		await migrateOmoSotConfig({ env, seed: true });
 		await migrateCodexConfig({ env });
 	} catch (error) {
 		if (!(error instanceof Error)) throw error;
@@ -210,11 +228,20 @@ function resolveArgs(env) {
 	return DEFAULT_UPDATE_ARGS;
 }
 
+function detectAutoUpdateInstallFlow(env) {
+	return detectInstallFlow({ pluginRoot: resolveAutoUpdatePluginRoot(env), env });
+}
+
+function resolveAutoUpdatePluginRoot(env) {
+	if (env.PLUGIN_ROOT?.trim()) return env.PLUGIN_ROOT.trim();
+	return dirname(dirname(fileURLToPath(import.meta.url)));
+}
+
 function resolveCurrentVersion(env) {
 	if (env.LAZYCODEX_CURRENT_VERSION?.trim()) return env.LAZYCODEX_CURRENT_VERSION.trim();
 	const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
 	return (
-		readVersionManifest(resolveInstalledVersionPath(env, pluginRoot)) ??
+		readVersionManifest(resolveInstallSnapshotPath(env, pluginRoot)) ??
 		readVersionManifest(join(pluginRoot, "..", "..", "..", "package.json")) ??
 		readVersionManifest(join(pluginRoot, ".codex-plugin", "plugin.json"))
 	);
@@ -279,11 +306,6 @@ function compareVersions(left, right) {
 	return 0;
 }
 
-function resolveInstalledVersionPath(env, pluginRoot) {
-	if (env.LAZYCODEX_INSTALLED_VERSION_PATH?.trim()) return env.LAZYCODEX_INSTALLED_VERSION_PATH;
-	return join(pluginRoot, INSTALLED_VERSION_FILE);
-}
-
 function readVersionManifest(path) {
 	try {
 		const parsed = JSON.parse(readFileSync(path, "utf8"));

package/packages/omo-codex/plugin/scripts/build-bundled-mcp-runtimes.mjs

@@ -19,11 +19,6 @@ const runtimes = [
 		requiredOutputs: ["dist/cli.js", "dist/index.js", "dist/index.d.ts"],
 		install: true,
 	},
-	{
-		label: "ast-grep-mcp",
-		packageRoot: join(repoPackagesRoot, "ast-grep-mcp"),
-		requiredOutputs: ["dist/cli.js"],
-	},
 	{
 		label: "git-bash-mcp",
 		packageRoot: join(repoPackagesRoot, "git-bash-mcp"),

package/packages/omo-codex/plugin/scripts/build-components.mjs

@@ -1,24 +1,79 @@
 #!/usr/bin/env node
 import { spawnSync } from "node:child_process";
-import { readFile } from "node:fs/promises";
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { builtinModules } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
 const packageJson = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
 const workspaces = Array.isArray(packageJson.workspaces) ? packageJson.workspaces : [];
+const workspaceSet = new Set(workspaces);
+const builtinModuleNames = new Set(builtinModules.filter((moduleName) => !moduleName.startsWith("_")));
 
 for (const workspace of workspaces) {
 	if (typeof workspace !== "string" || !workspace.startsWith("components/")) continue;
-	const workspacePackageJson = JSON.parse(await readFile(join(root, workspace, "package.json"), "utf8"));
-	if (typeof workspacePackageJson.scripts?.build !== "string") continue;
+	if (!(await hasBuildScript(workspace))) continue;
 
 	console.log(`Building ${workspace}`);
-	const result = spawnSync("npm", ["run", "--workspace", workspace, "build"], {
-		cwd: root,
+	run("npm", ["run", "--workspace", workspace, "build"], root);
+	await bundleCli(workspace);
+}
+
+for (const componentName of await readStandaloneComponentNames()) {
+	const componentPath = `components/${componentName}`;
+	if (!(await hasBuildScript(componentPath))) continue;
+
+	console.log(`Building ${componentPath} (standalone)`);
+	run("npm", ["run", "build"], join(root, componentPath));
+	await bundleCli(componentPath);
+}
+
+async function readStandaloneComponentNames() {
+	const entries = await readdir(join(root, "components"), { withFileTypes: true });
+	return entries
+		.filter((entry) => entry.isDirectory() && !workspaceSet.has(`components/${entry.name}`))
+		.map((entry) => entry.name)
+		.sort();
+}
+
+async function hasBuildScript(relativePath) {
+	let manifest;
+	try {
+		manifest = JSON.parse(await readFile(join(root, relativePath, "package.json"), "utf8"));
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+	return typeof manifest.scripts?.build === "string";
+}
+
+async function bundleCli(workspace) {
+	const entry = join(root, workspace, "src", "cli.ts");
+	const output = join(root, workspace, "dist", "cli.js");
+	console.log(`Bundling ${workspace}/dist/cli.js`);
+	run("bun", ["build", entry, "--target", "node", "--format", "esm", "--outfile", output], root);
+	await normalizeBuiltinImports(output);
+}
+
+function run(command, args, cwd) {
+	const result = spawnSync(command, args, {
+		cwd,
 		shell: process.platform === "win32",
 		stdio: "inherit",
 	});
 	if (result.error !== undefined) throw result.error;
 	if (result.status !== 0) process.exit(result.status ?? 1);
 }
+
+async function normalizeBuiltinImports(output) {
+	const bundled = await readFile(output, "utf8");
+	const normalized = bundled.replace(/(from\s+["']|import\s*\(\s*["'])([^"']+)(["'])/g, (match, prefix, specifier, suffix) => {
+		if (specifier.startsWith("node:")) return match;
+		if (!builtinModuleNames.has(specifier)) return match;
+		return `${prefix}node:${specifier}${suffix}`;
+	});
+	if (normalized !== bundled) {
+		await writeFile(output, normalized);
+	}
+}

package/packages/omo-codex/plugin/scripts/hook-status-message.mjs

@@ -1,7 +1,9 @@
 const PRODUCT_NAME = "LazyCodex";
 
 const WORD_OVERRIDES = new Map([
+	["lazycodex", "LazyCodex"],
 	["lsp", "LSP"],
+	["mcp", "MCP"],
 	["ulw-loop", "Ulw-Loop"],
 ]);
 

package/packages/omo-codex/plugin/scripts/install-flow.mjs

@@ -0,0 +1,43 @@
+import { readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+export const INSTALL_SNAPSHOT_FILE = "lazycodex-install.json";
+
+export function resolveInstallSnapshotPath(env, pluginRoot) {
+	if (env.LAZYCODEX_INSTALLED_VERSION_PATH?.trim()) return env.LAZYCODEX_INSTALLED_VERSION_PATH;
+	return join(pluginRoot, INSTALL_SNAPSHOT_FILE);
+}
+
+export function detectInstallFlow({ pluginRoot, env = {} } = {}) {
+	const snapshot = classifySnapshotPath(resolveInstallSnapshotPath(env, pluginRoot));
+	if (snapshot.kind === "file") return { flow: "npx-local", reason: "install-snapshot-present" };
+	if (snapshot.kind !== "absent") {
+		return { flow: "unknown", reason: `install-snapshot-${snapshot.kind}: ${snapshot.detail}` };
+	}
+	if (isVersionedWorkspaceManifest(join(pluginRoot, "..", "..", "..", "package.json"))) {
+		return { flow: "npx-local", reason: "workspace-tree" };
+	}
+	return { flow: "marketplace", reason: "install-snapshot-absent" };
+}
+
+function classifySnapshotPath(path) {
+	try {
+		if (statSync(path).isFile()) return { kind: "file" };
+		return { kind: "not-file", detail: "not-a-regular-file" };
+	} catch (error) {
+		if (!(error instanceof Error)) throw error;
+		if ("code" in error && error.code === "ENOENT") return { kind: "absent" };
+		return { kind: "unreadable", detail: "code" in error ? String(error.code) : "unknown-error" };
+	}
+}
+
+function isVersionedWorkspaceManifest(path) {
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf8"));
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return false;
+		return typeof parsed.version === "string" && parsed.version.trim().length > 0;
+	} catch (error) {
+		if (error instanceof Error) return false;
+		throw error;
+	}
+}

package/packages/omo-codex/plugin/scripts/migrate-omo-sot/editor.mjs

@@ -0,0 +1,125 @@
+import { stringEnd, stripJsonComments } from "./jsonc.mjs";
+
+export function addCodexCodegraphValues(content, config, additions) {
+	const codex = recordAt(config, "[codex]");
+	const codexRange = findObjectPropertyRange(content, 0, "[codex]");
+	if (!isRecord(codex) || codexRange === null) {
+		return insertPropertiesIntoObject(content, 0, {
+			"[codex]": {
+				codegraph: additions,
+			},
+		});
+	}
+
+	const codegraph = recordAt(codex, "codegraph");
+	const codegraphRange = findObjectPropertyRange(content, codexRange.valueStart, "codegraph");
+	if (!isRecord(codegraph) || codegraphRange === null) {
+		return insertPropertiesIntoObject(content, codexRange.valueStart, { codegraph: additions });
+	}
+	return insertPropertiesIntoObject(content, codegraphRange.valueStart, additions);
+}
+
+export function recordAt(value, key) {
+	return isRecord(value) ? value[key] : undefined;
+}
+
+export function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function hasOwn(value, key) {
+	return isRecord(value) && Object.prototype.hasOwnProperty.call(value, key);
+}
+
+function findObjectPropertyRange(content, objectStart, name) {
+	const open = content.indexOf("{", objectStart);
+	if (open < 0) return null;
+	let index = open + 1;
+	while (index < content.length) {
+		index = skipTrivia(content, index);
+		if (content[index] === "}") return null;
+		if (content[index] !== "\"") return null;
+		const end = stringEnd(content, index);
+		const key = JSON.parse(content.slice(index, end));
+		index = skipTrivia(content, end);
+		if (content[index] !== ":") return null;
+		const valueStart = skipTrivia(content, index + 1);
+		const valueEnd = valueRangeEnd(content, valueStart);
+		if (key === name) return { valueEnd, valueStart };
+		index = skipTrivia(content, valueEnd);
+		if (content[index] === ",") index += 1;
+	}
+	return null;
+}
+
+function insertPropertiesIntoObject(content, objectStart, properties) {
+	const open = content.indexOf("{", objectStart);
+	const close = matchingBrace(content, open);
+	if (open < 0 || close < 0) return content;
+	const entries = Object.entries(properties);
+	if (entries.length === 0) return content;
+	const parentIndent = lineIndent(content, open);
+	const childIndent = `${parentIndent}  `;
+	const body = entries.map(([key, value]) => `${childIndent}${JSON.stringify(key)}: ${formatJsoncValue(value, childIndent)}`).join(",\n");
+	const hasProperty = /"[^"]+"\s*:/.test(stripJsonComments(content.slice(open + 1, close)));
+	const beforeClose = content.slice(0, close).replace(/\s*$/, "");
+	const suffix = content.slice(close);
+	const comma = hasProperty && !beforeClose.endsWith(",") && !beforeClose.endsWith("{") ? "," : "";
+	return `${beforeClose}${comma}\n${body}\n${parentIndent}${suffix}`;
+}
+
+function formatJsoncValue(value, indent) {
+	if (!isRecord(value)) return JSON.stringify(value);
+	const nextIndent = `${indent}  `;
+	const entries = Object.entries(value).map(([key, entry]) => `${nextIndent}${JSON.stringify(key)}: ${formatJsoncValue(entry, nextIndent)}`);
+	return `{\n${entries.join(",\n")}\n${indent}}`;
+}
+
+function valueRangeEnd(content, start) {
+	const char = content[start];
+	if (char === "{" || char === "[") return matchingBrace(content, start) + 1;
+	if (char === "\"") return stringEnd(content, start);
+	let index = start;
+	while (index < content.length && content[index] !== "," && content[index] !== "}") index += 1;
+	return index;
+}
+
+function matchingBrace(content, start) {
+	const open = content[start];
+	const close = open === "{" ? "}" : "]";
+	let depth = 0;
+	for (let index = start; index < content.length; index += 1) {
+		const char = content[index];
+		if (char === "\"") index = stringEnd(content, index) - 1;
+		else if (char === "/" && content[index + 1] === "/") while (index < content.length && content[index] !== "\n") index += 1;
+		else if (char === "/" && content[index + 1] === "*") {
+			index += 2;
+			while (index < content.length && !(content[index] === "*" && content[index + 1] === "/")) index += 1;
+			index += 1;
+		} else if (char === open) depth += 1;
+		else if (char === close) {
+			depth -= 1;
+			if (depth === 0) return index;
+		}
+	}
+	return -1;
+}
+
+function skipTrivia(content, index) {
+	while (index < content.length) {
+		if (/\s/.test(content[index])) index += 1;
+		else if (content[index] === "/" && content[index + 1] === "/") while (index < content.length && content[index] !== "\n") index += 1;
+		else if (content[index] === "/" && content[index + 1] === "*") {
+			index += 2;
+			while (index < content.length && !(content[index] === "*" && content[index + 1] === "/")) index += 1;
+			index += 2;
+		} else return index;
+	}
+	return index;
+}
+
+function lineIndent(content, index) {
+	const lineStart = content.lastIndexOf("\n", index) + 1;
+	const match = /^[ \t]*/.exec(content.slice(lineStart, index));
+	return match?.[0] ?? "";
+}

package/packages/omo-codex/plugin/scripts/migrate-omo-sot/jsonc.mjs

@@ -0,0 +1,43 @@
+export function parseJsonc(content) {
+	try {
+		return { ok: true, value: JSON.parse(stripTrailingCommas(stripJsonComments(content))) };
+	} catch (error) {
+		if (error instanceof Error) return { ok: false, error };
+		throw error;
+	}
+}
+
+export function stripJsonComments(content) {
+	let result = "";
+	for (let index = 0; index < content.length; index += 1) {
+		const char = content[index];
+		const next = content[index + 1];
+		if (char === "\"") {
+			const end = stringEnd(content, index);
+			result += content.slice(index, end);
+			index = end - 1;
+		} else if (char === "/" && next === "/") {
+			while (index < content.length && content[index] !== "\n") index += 1;
+			result += "\n";
+		} else if (char === "/" && next === "*") {
+			index += 2;
+			while (index < content.length && !(content[index] === "*" && content[index + 1] === "/")) index += 1;
+			index += 1;
+		} else {
+			result += char;
+		}
+	}
+	return result;
+}
+
+export function stringEnd(content, start) {
+	for (let index = start + 1; index < content.length; index += 1) {
+		if (content[index] === "\\") index += 1;
+		else if (content[index] === "\"") return index + 1;
+	}
+	return content.length;
+}
+
+function stripTrailingCommas(content) {
+	return content.replace(/,\s*([}\]])/g, "$1");
+}

package/packages/omo-codex/plugin/scripts/migrate-omo-sot/scaffold.mjs

@@ -0,0 +1,29 @@
+export const SCAFFOLD = `{
+  // Shared OMO settings. Harness override blocks below are additive.
+  "codegraph": {
+    // "enabled": true,
+    // "auto_provision": true,
+    // "telemetry": false,
+    // "install_dir": "~/.omo/codegraph"
+  },
+
+  "[codex]": {
+    "codegraph": {
+      // "enabled": true,
+      // "auto_provision": true,
+      // "install_dir": "~/.omo/codegraph",
+      // "telemetry": false
+    }
+  },
+
+  "[opencode]": {
+    "codegraph": {
+      // "enabled": true,
+      // "auto_provision": true,
+      // "install_dir": "~/.omo/codegraph",
+      // "telemetry": false,
+      // "watch_debounce_ms": 250
+    }
+  }
+}
+`;

package/packages/omo-codex/plugin/scripts/migrate-omo-sot.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { addCodexCodegraphValues, hasOwn, isRecord, recordAt } from "./migrate-omo-sot/editor.mjs";
+import { parseJsonc } from "./migrate-omo-sot/jsonc.mjs";
+import { SCAFFOLD } from "./migrate-omo-sot/scaffold.mjs";
+
+const CODEGRAPH_KEYS = ["auto_provision", "enabled", "install_dir", "telemetry"];
+const ENV_MAPPINGS = [
+	["auto_provision", "OMO_CODEGRAPH_AUTO_PROVISION", "boolean"],
+	["auto_provision", "CODEX_CODEGRAPH_AUTO_PROVISION", "boolean"],
+	["enabled", "OMO_CODEGRAPH_ENABLED", "boolean"],
+	["enabled", "CODEX_CODEGRAPH_ENABLED", "boolean"],
+	["install_dir", "OMO_CODEGRAPH_INSTALL_DIR", "string"],
+	["install_dir", "CODEX_CODEGRAPH_INSTALL_DIR", "string"],
+	["telemetry", "OMO_CODEGRAPH_TELEMETRY", "boolean"],
+	["telemetry", "CODEX_CODEGRAPH_TELEMETRY", "boolean"],
+];
+
+export async function migrateOmoSotConfig({ env = process.env, seed = false, configPath } = {}) {
+	const targetPath = configPath ?? join(resolveHomeDir(env), ".omo", "config.jsonc");
+	if (!(await pathExists(targetPath))) {
+		if (!seed) return { changed: false, configPath: targetPath, seeded: false, warnings: [] };
+		const parsedScaffold = parseJsonc(SCAFFOLD);
+		if (!parsedScaffold.ok) throw parsedScaffold.error;
+		const additions = collectCodexAdditions(parsedScaffold.value, env);
+		const content = addCodexCodegraphValues(SCAFFOLD, parsedScaffold.value, additions);
+		await mkdir(dirname(targetPath), { recursive: true });
+		await writeFile(targetPath, content);
+		return { changed: true, configPath: targetPath, seeded: true, warnings: [] };
+	}
+
+	const content = await readFile(targetPath, "utf8");
+	const parsed = parseJsonc(content);
+	if (!parsed.ok) {
+		return {
+			changed: false,
+			configPath: targetPath,
+			seeded: false,
+			warnings: [`Could not parse ${targetPath}; left existing OMO SOT untouched: ${parsed.error.message}`],
+		};
+	}
+
+	const additions = collectCodexAdditions(parsed.value, env);
+	if (Object.keys(additions).length === 0) {
+		return { changed: false, configPath: targetPath, seeded: false, warnings: [] };
+	}
+
+	const edited = addCodexCodegraphValues(content, parsed.value, additions);
+	if (edited === content) return { changed: false, configPath: targetPath, seeded: false, warnings: [] };
+	await writeFile(targetPath, edited);
+	return { changed: true, configPath: targetPath, seeded: false, warnings: [] };
+}
+
+function resolveHomeDir(env) {
+	const candidate = env.HOME ?? env.USERPROFILE;
+	return candidate?.trim() ? candidate : homedir();
+}
+
+async function pathExists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+function collectCodexAdditions(config, env) {
+	const codexCodegraph = recordAt(recordAt(config, "[codex]"), "codegraph");
+	const additions = {};
+	addSupportedCodegraphValues(additions, recordAt(config, "codegraph"), codexCodegraph);
+	for (const [key, envKey, kind] of ENV_MAPPINGS) {
+		const raw = env[envKey];
+		if (raw === undefined || hasOwn(codexCodegraph, key)) continue;
+		const parsed = parseEnvValue(raw, kind);
+		if (parsed !== null) additions[key] = parsed;
+	}
+	for (const key of Object.keys(additions)) {
+		if (hasOwn(codexCodegraph, key)) delete additions[key];
+	}
+	return additions;
+}
+
+function addSupportedCodegraphValues(additions, baseCodegraph, codexCodegraph) {
+	if (!isRecord(baseCodegraph)) return;
+	for (const key of CODEGRAPH_KEYS) {
+		if (hasOwn(codexCodegraph, key) || !hasOwn(baseCodegraph, key)) continue;
+		const value = baseCodegraph[key];
+		if (isValidCodegraphValue(key, value)) additions[key] = value;
+	}
+}
+
+function parseEnvValue(value, kind) {
+	if (kind === "string") return value;
+	const normalized = value.trim().toLowerCase();
+	if (["1", "true", "yes", "on"].includes(normalized)) return true;
+	if (["0", "false", "no", "off"].includes(normalized)) return false;
+	return null;
+}
+
+function isValidCodegraphValue(key, value) {
+	if (key === "install_dir") return typeof value === "string";
+	return typeof value === "boolean";
+}
+
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	migrateOmoSotConfig({ seed: process.argv.includes("--seed") })
+		.then((result) => {
+			for (const warning of result.warnings) process.stderr.write(`${warning}\n`);
+		})
+		.catch((error) => {
+			console.error(error instanceof Error ? error.message : String(error));
+			process.exitCode = 1;
+		});
+}