oh-my-opencode 4.10.0 → 4.11.0

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

@@ -1,46 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { join, sep } from "node:path";
-
-import { exists, isRecord } from "./utils.mjs";
-
-const PLUGIN_ROOT_TARGET_PATTERN = /\$\{PLUGIN_ROOT\}\/([^"']+)/g;
-
-export async function findMissingHookCommandTargets(pluginRoot) {
-	const manifestPath = join(pluginRoot, "hooks", "hooks.json");
-	if (!(await exists(manifestPath))) return [];
-
-	const commands = [];
-	collectCommands(JSON.parse(await readFile(manifestPath, "utf8")), commands);
-
-	const missing = [];
-	const seen = new Set();
-	for (const command of commands) {
-		for (const match of command.matchAll(PLUGIN_ROOT_TARGET_PATTERN)) {
-			const target = join(pluginRoot, ...match[1].split("/"));
-			if (seen.has(target)) continue;
-			seen.add(target);
-			if (!(await exists(target))) missing.push(target);
-		}
-	}
-	return missing;
-}
-
-export async function assertHookCommandTargets(pluginRoot) {
-	const missing = await findMissingHookCommandTargets(pluginRoot);
-	if (missing.length === 0) return;
-	const relativeMissing = missing.map((path) => path.split(`${pluginRoot}${sep}`).join("").split(sep).join("/"));
-	throw new Error(
-		`Plugin payload is missing ${missing.length} hook command target(s) referenced by hooks.json: ${relativeMissing.join(", ")}. ` +
-			"The previous plugin cache was left untouched; this payload was not activated.",
-	);
-}
-
-function collectCommands(value, commands) {
-	if (Array.isArray(value)) {
-		for (const entry of value) collectCommands(entry, commands);
-		return;
-	}
-	if (!isRecord(value)) return;
-	if (value.type === "command" && typeof value.command === "string") commands.push(value.command);
-	for (const entry of Object.values(value)) collectCommands(entry, commands);
-}

package/packages/omo-codex/scripts/install/hook-trust.d.mts

@@ -1,10 +0,0 @@
-export interface TrustedHookState {
-	key: string;
-	trustedHash: string;
-}
-
-export declare function trustedHookStatesForPlugin(options: {
-	marketplaceName: string;
-	pluginName: string;
-	pluginRoot: string;
-}): Promise<TrustedHookState[]>;

package/packages/omo-codex/scripts/install/hook-trust.mjs

@@ -1,84 +0,0 @@
-import { createHash } from "node:crypto";
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-
-import { exists, isRecord } from "./utils.mjs";
-
-const EVENT_LABELS = new Map([
-	["PreToolUse", "pre_tool_use"],
-	["PermissionRequest", "permission_request"],
-	["PostToolUse", "post_tool_use"],
-	["PreCompact", "pre_compact"],
-	["PostCompact", "post_compact"],
-	["SessionStart", "session_start"],
-	["UserPromptSubmit", "user_prompt_submit"],
-	["SubagentStart", "subagent_start"],
-	["SubagentStop", "subagent_stop"],
-	["Stop", "stop"],
-]);
-
-export async function trustedHookStatesForPlugin({ marketplaceName, pluginName, pluginRoot }) {
-	const manifestPath = join(pluginRoot, ".codex-plugin", "plugin.json");
-	if (!(await exists(manifestPath))) return [];
-	const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
-	if (!isRecord(manifest) || typeof manifest.hooks !== "string") return [];
-
-	const hooksPath = join(pluginRoot, manifest.hooks);
-	if (!(await exists(hooksPath))) return [];
-	const parsed = JSON.parse(await readFile(hooksPath, "utf8"));
-	if (!isRecord(parsed) || !isRecord(parsed.hooks)) return [];
-
-	const keySource = `${pluginName}@${marketplaceName}:${stripDotSlash(manifest.hooks)}`;
-	const states = [];
-	for (const [eventName, groups] of Object.entries(parsed.hooks)) {
-		if (!Array.isArray(groups)) continue;
-		const eventLabel = EVENT_LABELS.get(eventName);
-		if (eventLabel === undefined) continue;
-		for (const [groupIndex, group] of groups.entries()) {
-			if (!isRecord(group) || !Array.isArray(group.hooks)) continue;
-			for (const [handlerIndex, handler] of group.hooks.entries()) {
-				if (!isRecord(handler) || handler.type !== "command") continue;
-				if (handler.async === true) continue;
-				if (typeof handler.command !== "string" || handler.command.trim() === "") continue;
-				const key = `${keySource}:${eventLabel}:${groupIndex}:${handlerIndex}`;
-				states.push({
-					key,
-					trustedHash: commandHookHash(eventLabel, group.matcher, handler),
-				});
-			}
-		}
-	}
-	return states;
-}
-
-function commandHookHash(eventName, matcher, handler) {
-	const command = handler.command;
-	const timeout = Math.max(Number(handler.timeout ?? 600), 1);
-	const normalizedHandler = {
-		type: "command",
-		command,
-		timeout,
-		async: false,
-	};
-	if (typeof handler.statusMessage === "string") normalizedHandler.statusMessage = handler.statusMessage;
-	const identity = {
-		event_name: eventName,
-		hooks: [normalizedHandler],
-	};
-	if (typeof matcher === "string") identity.matcher = matcher;
-	return `sha256:${createHash("sha256").update(JSON.stringify(canonicalJson(identity))).digest("hex")}`;
-}
-
-function canonicalJson(value) {
-	if (Array.isArray(value)) return value.map(canonicalJson);
-	if (!isRecord(value)) return value;
-	const result = {};
-	for (const key of Object.keys(value).sort()) {
-		result[key] = canonicalJson(value[key]);
-	}
-	return result;
-}
-
-function stripDotSlash(value) {
-	return value.startsWith("./") ? value.slice(2) : value;
-}

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

@@ -1,102 +0,0 @@
-import { readdir, readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-export async function readDistributionManifest(repoRoot) {
-	try {
-		const parsed = JSON.parse(await readFile(join(repoRoot, "package.json"), "utf8"));
-		if (typeof parsed.version !== "string" || parsed.version.trim().length === 0) return undefined;
-		return {
-			name: typeof parsed.name === "string" && parsed.name.trim().length > 0 ? parsed.name.trim() : "lazycodex-ai",
-			version: parsed.version.trim(),
-		};
-	} catch (error) {
-		if (error instanceof Error) return undefined;
-		throw error;
-	}
-}
-
-export function resolveLazyCodexPluginVersion({ manifestVersion, marketplaceName, pluginName, distributionManifest }) {
-	if (marketplaceName === "sisyphuslabs" && pluginName === "omo" && distributionManifest !== undefined) {
-		return distributionManifest.version;
-	}
-	return manifestVersion ?? "local";
-}
-
-export async function stampLazyCodexPluginVersion({ pluginRoot, version }) {
-	await stampJsonVersion(join(pluginRoot, ".codex-plugin", "plugin.json"), version);
-	await stampJsonVersion(join(pluginRoot, "package.json"), version);
-	await stampHookStatusMessages(join(pluginRoot, "hooks", "hooks.json"), version);
-	await stampComponentVersions({ pluginRoot, version });
-}
-
-export async function writeLazyCodexInstallSnapshot({ pluginRoot, distributionManifest }) {
-	if (distributionManifest === undefined) return;
-	await writeFile(
-		join(pluginRoot, "lazycodex-install.json"),
-		`${JSON.stringify(
-			{
-				packageName: distributionManifest.name,
-				version: distributionManifest.version,
-			},
-			null,
-			"\t",
-		)}\n`,
-	);
-}
-
-async function stampJsonVersion(path, version) {
-	try {
-		const parsed = JSON.parse(await readFile(path, "utf8"));
-		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return;
-		parsed.version = version;
-		await writeFile(path, `${JSON.stringify(parsed, null, "\t")}\n`);
-	} catch (error) {
-		if (error instanceof Error) return;
-		throw error;
-	}
-}
-
-async function stampHookStatusMessages(path, version) {
-	try {
-		const parsed = JSON.parse(await readFile(path, "utf8"));
-		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return;
-		stampHookGroups(parsed.hooks, version);
-		await writeFile(path, `${JSON.stringify(parsed, null, "\t")}\n`);
-	} catch (error) {
-		if (error instanceof Error) return;
-		throw error;
-	}
-}
-
-async function stampComponentVersions({ pluginRoot, version }) {
-	let entries;
-	try {
-		entries = await readdir(join(pluginRoot, "components"));
-	} catch (error) {
-		if (error instanceof Error) return;
-		throw error;
-	}
-	for (const entry of entries) {
-		const componentRoot = join(pluginRoot, "components", entry);
-		await stampJsonVersion(join(componentRoot, "package.json"), version);
-		await stampHookStatusMessages(join(componentRoot, "hooks", "hooks.json"), version);
-	}
-}
-
-function stampHookGroups(hooks, version) {
-	if (typeof hooks !== "object" || hooks === null || Array.isArray(hooks)) return;
-	for (const groups of Object.values(hooks)) {
-		if (!Array.isArray(groups)) continue;
-		for (const group of groups) {
-			if (typeof group !== "object" || group === null || !Array.isArray(group.hooks)) continue;
-			for (const hook of group.hooks) {
-				stampHookStatusMessage(hook, version);
-			}
-		}
-	}
-}
-
-function stampHookStatusMessage(hook, version) {
-	if (typeof hook !== "object" || hook === null || typeof hook.statusMessage !== "string") return;
-	hook.statusMessage = hook.statusMessage.replace(/^LazyCodex\([^)]+\):/, `LazyCodex(${version}):`);
-}

package/packages/omo-codex/scripts/install/legacy-bins.mjs

@@ -1,66 +0,0 @@
-import { lstat, readFile, readlink, rm } from "node:fs/promises";
-import { join } from "node:path";
-
-import { COMMAND_SHIM_MARKER } from "./command-shim.mjs";
-
-const LEGACY_CODEX_COMPONENT_BINS = [
-	{ name: "omo", component: "ulw-loop" },
-	{ name: "codex-comment-checker", component: "comment-checker" },
-	{ name: "codex-lsp", component: "lsp" },
-	{ name: "codex-rules", component: "rules" },
-	{ name: "codex-start-work-continuation", component: "start-work-continuation" },
-	{ name: "codex-telemetry", component: "telemetry" },
-	{ name: "codex-ultrawork", component: "ultrawork" },
-];
-
-export async function removeLegacyCodexComponentBins(binDir, platform) {
-	for (const entry of LEGACY_CODEX_COMPONENT_BINS) {
-		const linkPath = join(binDir, platform === "win32" ? `${entry.name}.cmd` : entry.name);
-		await removeLegacyCodexComponentBin(linkPath, entry.component, platform);
-	}
-}
-
-async function removeLegacyCodexComponentBin(linkPath, component, platform) {
-	try {
-		const stat = await lstat(linkPath);
-		if (platform !== "win32") {
-			if (!stat.isSymbolicLink()) return;
-			const target = await readlink(linkPath);
-			if (isManagedLegacyComponentTarget(target, component)) await rm(linkPath, { force: true });
-			return;
-		}
-		if (!stat.isFile()) return;
-		const content = await readFile(linkPath, "utf8");
-		if (content.includes(COMMAND_SHIM_MARKER)) await rm(linkPath, { force: true });
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") return;
-		throw error;
-	}
-}
-
-function isManagedLegacyComponentTarget(target, component) {
-	const parts = target.split(/[\\/]+/);
-	const suffixStart = parts.length - 4;
-	const suffix = parts.slice(-4);
-	return (
-		suffix[0] === "components" &&
-		suffix[1] === component &&
-		suffix[2] === "dist" &&
-		suffix[3] === "cli.js" &&
-		(hasPluginCachePrefix(parts, suffixStart) || hasOmoCodexPluginPrefix(parts, suffixStart))
-	);
-}
-
-function hasPluginCachePrefix(parts, endExclusive) {
-	for (let index = 0; index < endExclusive - 1; index += 1) {
-		if (parts[index] === "plugins" && parts[index + 1] === "cache") return true;
-	}
-	return false;
-}
-
-function hasOmoCodexPluginPrefix(parts, endExclusive) {
-	for (let index = 0; index <= endExclusive - 3; index += 1) {
-		if (parts[index] === "packages" && parts[index + 1] === "omo-codex" && parts[index + 2] === "plugin") return true;
-	}
-	return false;
-}

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

@@ -1,104 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-
-import { isRecord } from "./utils.mjs";
-
-const DEFAULT_MARKETPLACE_PATH = "packages/omo-codex/marketplace.json";
-
-export async function readMarketplace(repoRoot, options = {}) {
-	const marketplacePath = options.marketplacePath ?? join(repoRoot, DEFAULT_MARKETPLACE_PATH);
-	const raw = await readFile(marketplacePath, "utf8");
-	const parsed = JSON.parse(raw);
-	if (!isRecord(parsed)) throw new Error("marketplace.json must be an object");
-	if (typeof parsed.name !== "string" || parsed.name.trim() === "") {
-		throw new Error("marketplace.json name must be a non-empty string");
-	}
-	validatePathSegment(parsed.name, "marketplace name");
-	if (!Array.isArray(parsed.plugins)) throw new Error("marketplace.json plugins must be an array");
-
-	return {
-		name: parsed.name,
-		plugins: parsed.plugins.map((plugin, index) => normalizeMarketplacePlugin(plugin, index)),
-	};
-}
-
-export function resolvePluginSource(marketplaceRoot, plugin, options = {}) {
-	const sourcePath = localSourcePath(options.pathOverride ?? plugin.source);
-	const relativePath = sourcePath.slice(2);
-	return join(marketplaceRoot, ...relativePath.split(/[\\/]/));
-}
-
-export async function readPluginManifest(pluginRoot) {
-	const raw = await readFile(join(pluginRoot, ".codex-plugin", "plugin.json"), "utf8");
-	const parsed = JSON.parse(raw);
-	if (!isRecord(parsed)) throw new Error(`${pluginRoot} plugin.json must be an object`);
-	if (typeof parsed.name !== "string" || parsed.name.trim() === "") {
-		throw new Error(`${pluginRoot} plugin.json name must be a non-empty string`);
-	}
-	const manifest = { name: parsed.name };
-	if (parsed.version !== undefined) {
-		if (typeof parsed.version !== "string" || parsed.version.trim() === "") {
-			throw new Error(`${pluginRoot} plugin.json version must be a non-empty string`);
-		}
-		manifest.version = parsed.version.trim();
-	}
-	return manifest;
-}
-
-export function validatePathSegment(value, label) {
-	if (!/^[A-Za-z0-9._+-]+$/.test(value)) {
-		throw new Error(`${label} contains unsupported characters: ${value}`);
-	}
-	if (value === "." || value === "..") {
-		throw new Error(`${label} must not be a path traversal segment`);
-	}
-}
-
-function normalizeMarketplacePlugin(plugin, index) {
-	if (!isRecord(plugin)) throw new Error(`marketplace plugin ${index} must be an object`);
-	if (typeof plugin.name !== "string" || plugin.name.trim() === "") {
-		throw new Error(`marketplace plugin ${index} name must be a non-empty string`);
-	}
-	validatePathSegment(plugin.name, "plugin name");
-	if (plugin.source === undefined || typeof plugin.source === "string") {
-		if (typeof plugin.source === "string") validateLocalSourcePath(plugin.source);
-		return {
-			name: plugin.name,
-			source: plugin.source,
-		};
-	}
-	if (isRecord(plugin.source) && plugin.source.source === "local" && typeof plugin.source.path === "string") {
-		validateLocalSourcePath(plugin.source.path);
-		return {
-			name: plugin.name,
-			source: { source: "local", path: plugin.source.path },
-		};
-	}
-	throw new Error("local plugin source must be a string path or { source: \"local\", path } object");
-}
-
-function localSourcePath(source) {
-	if (typeof source === "string") return validateLocalSourcePath(source);
-	if (
-		isRecord(source) &&
-		source.source === "local" &&
-		typeof source.path === "string"
-	) {
-		return validateLocalSourcePath(source.path);
-	}
-	throw new Error("local plugin source must be a string path or { source: \"local\", path } object");
-}
-
-function validateLocalSourcePath(path) {
-	if (!path.startsWith("./")) {
-		throw new Error("local plugin source path must start with ./");
-	}
-	const relative = path.slice(2);
-	if (relative.length === 0) throw new Error("local plugin source path must not be empty");
-	for (const part of relative.split(/[\\/]/)) {
-		if (part === "" || part === "." || part === "..") {
-			throw new Error("local plugin source path must stay within the marketplace root");
-		}
-	}
-	return path;
-}

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

@@ -1,81 +0,0 @@
-import { existsSync } from "node:fs";
-import { cp } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
-
-export function createCachedMcpRuntimeArgRewriter({ copyDist = cp } = {}) {
-	const copiedDistRoots = new Map();
-	return async function rewriteCachedMcpRuntimeArg({ arg, pluginRoot, serverName, sourceRoot }) {
-		return rewriteCachedMcpRuntimeArgWithCache({ arg, pluginRoot, serverName, sourceRoot }, { copiedDistRoots, copyDist });
-	};
-}
-
-export async function rewriteCachedMcpRuntimeArg(args) {
-	return createCachedMcpRuntimeArgRewriter()(args);
-}
-
-async function rewriteCachedMcpRuntimeArgWithCache({ arg, pluginRoot, serverName, sourceRoot }, { copiedDistRoots, copyDist }) {
-	if (typeof arg !== "string" || (!arg.startsWith("./") && !arg.startsWith("../"))) return arg;
-	const fallback = resolveCachedRuntimePath(pluginRoot, sourceRoot, arg);
-	const targetPath = resolve(pluginRoot, arg);
-	const runtimePath = isPathInside(targetPath, pluginRoot) ? targetPath : resolve(sourceRoot, arg);
-	const packageRoot = resolveExternalMcpPackageRoot(runtimePath, sourceRoot);
-	if (packageRoot === undefined) return fallback;
-	const distRoot = join(packageRoot, "dist");
-	const distPath = relative(distRoot, runtimePath);
-	if (distPath.startsWith("..") || isAbsolute(distPath)) return fallback;
-	const cachedRoot = join(pluginRoot, "mcp", safePathSegment(serverName));
-	const cacheKey = `${distRoot}\0${cachedRoot}`;
-	let copyPromise = copiedDistRoots.get(cacheKey);
-	if (copyPromise === undefined) {
-		copyPromise = copyDist(distRoot, join(cachedRoot, "dist"), { recursive: true });
-		copiedDistRoots.set(cacheKey, copyPromise);
-	}
-	await copyPromise;
-	return join(cachedRoot, "dist", distPath);
-}
-
-function resolveExternalMcpPackageRoot(runtimePath, sourceRoot) {
-	const packagesRoot = findPackagesRoot(sourceRoot);
-	if (packagesRoot === undefined) return undefined;
-	if (!isPathInside(runtimePath, packagesRoot)) return undefined;
-	let packageRoot = dirname(runtimePath);
-	while (packageRoot !== packagesRoot) {
-		if (isPathInside(runtimePath, join(packageRoot, "dist")) && isRuntimePackageRoot(packageRoot)) {
-			return packageRoot;
-		}
-		const parent = dirname(packageRoot);
-		if (parent === packageRoot) return undefined;
-		packageRoot = parent;
-	}
-	return undefined;
-}
-
-function isRuntimePackageRoot(packageRoot) {
-	return existsSync(join(packageRoot, "package.json")) || existsSync(join(packageRoot, "dist"));
-}
-
-function findPackagesRoot(path) {
-	let current = resolve(path);
-	for (let index = 0; index < 8; index++) {
-		if (basename(current) === "packages") return current;
-		const parent = dirname(current);
-		if (parent === current) return undefined;
-		current = parent;
-	}
-	return undefined;
-}
-
-function resolveCachedRuntimePath(pluginRoot, sourceRoot, runtimePath) {
-	const targetPath = resolve(pluginRoot, runtimePath);
-	if (isPathInside(targetPath, pluginRoot)) return targetPath;
-	return resolve(sourceRoot, runtimePath);
-}
-
-function isPathInside(candidatePath, rootPath) {
-	const pathFromRoot = relative(rootPath, candidatePath);
-	return pathFromRoot === "" || (!pathFromRoot.startsWith("..") && !isAbsolute(pathFromRoot));
-}
-
-function safePathSegment(value) {
-	return value.replace(/[^A-Za-z0-9._-]/g, "_");
-}

package/packages/omo-codex/scripts/install/model-catalog.mjs

@@ -1,74 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-
-const FALLBACK_CODEX_MODEL_CATALOG = {
-	current: {
-		model: "gpt-5.5",
-		modelContextWindow: 400_000,
-		modelReasoningEffort: "high",
-		planModeReasoningEffort: "xhigh",
-	},
-	managedProfiles: [
-		{
-			model: "gpt-5.5",
-			modelContextWindow: 1_000_000,
-			modelReasoningEffort: "high",
-			planModeReasoningEffort: "xhigh",
-		},
-		{ model: "gpt-5.5", modelContextWindow: 272_000 },
-	],
-};
-
-export async function readCodexModelCatalog(codexPackageRoot) {
-	try {
-		const parsed = JSON.parse(await readFile(join(codexPackageRoot, "plugin", "model-catalog.json"), "utf8"));
-		return parseCodexModelCatalog(parsed) ?? FALLBACK_CODEX_MODEL_CATALOG;
-	} catch (error) {
-		if (!(error instanceof Error)) throw error;
-		return FALLBACK_CODEX_MODEL_CATALOG;
-	}
-}
-
-export async function readCodexReasoningProfile(codexPackageRoot) {
-	return (await readCodexModelCatalog(codexPackageRoot)).current;
-}
-
-function parseCodexModelCatalog(value) {
-	if (!isRecord(value) || !isRecord(value.current) || !Array.isArray(value.managedProfiles)) return null;
-	const { current } = value;
-	if (
-		typeof current.model !== "string" ||
-		typeof current.model_context_window !== "number" ||
-		typeof current.model_reasoning_effort !== "string" ||
-		typeof current.plan_mode_reasoning_effort !== "string"
-	) {
-		return null;
-	}
-	const managedProfiles = [];
-	for (const profile of value.managedProfiles) {
-		if (!isRecord(profile) || !isRecord(profile.match)) return null;
-		managedProfiles.push(parseProfileMatch(profile.match));
-	}
-	return {
-		current: {
-			model: current.model,
-			modelContextWindow: current.model_context_window,
-			modelReasoningEffort: current.model_reasoning_effort,
-			planModeReasoningEffort: current.plan_mode_reasoning_effort,
-		},
-		managedProfiles,
-	};
-}
-
-function parseProfileMatch(match) {
-	const profile = {};
-	if (typeof match.model === "string") profile.model = match.model;
-	if (typeof match.model_context_window === "number") profile.modelContextWindow = match.model_context_window;
-	if (typeof match.model_reasoning_effort === "string") profile.modelReasoningEffort = match.model_reasoning_effort;
-	if (typeof match.plan_mode_reasoning_effort === "string") profile.planModeReasoningEffort = match.plan_mode_reasoning_effort;
-	return profile;
-}
-
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/packages/omo-codex/scripts/install/multi-agent-v2-config.mjs

@@ -1,50 +0,0 @@
-import { appendBlock, findTomlSection, removeSetting, replaceOrInsertSetting } from "./toml-editor.mjs";
-
-const CODEX_MULTI_AGENT_V2_HEADER = "features.multi_agent_v2";
-const CODEX_MULTI_AGENT_V2_MAX_CONCURRENT_THREADS_PER_SESSION = 10000;
-
-/**
- * Configure multi_agent_v2 thread limits without forcing the feature on.
- *
- * Whether V2 is active is determined at runtime by the model's server-side
- * catalog entry (ModelInfo.multi_agent_version).  Forcing enabled = true
- * in config breaks models whose API does not support encrypted tool
- * parameters.  The installer therefore only sets the tuning knob
- * (max_concurrent_threads_per_session) so that sessions that DO activate
- * V2 benefit from the higher limit.
- */
-export function ensureCodexMultiAgentV2Config(config) {
-	const normalizedConfig = removeLegacyAgentsMaxThreadsSetting(removeFeatureFlagSetting(config, "multi_agent_v2"));
-	const section = findTomlSection(normalizedConfig, CODEX_MULTI_AGENT_V2_HEADER);
-	const maxThreadsValue = CODEX_MULTI_AGENT_V2_MAX_CONCURRENT_THREADS_PER_SESSION.toString();
-	if (!section) {
-		return appendBlock(
-			normalizedConfig,
-			`[${CODEX_MULTI_AGENT_V2_HEADER}]\nmax_concurrent_threads_per_session = ${maxThreadsValue}\nhide_spawn_agent_metadata = false\n`,
-		);
-	}
-
-	// Codex defaults hide_spawn_agent_metadata to true on V2, which strips the
-	// agent_type parameter from spawn_agent and makes the role TOMLs this
-	// installer ships unselectable.
-	const withMaxThreads = replaceOrInsertSetting(
-		normalizedConfig,
-		section,
-		"max_concurrent_threads_per_session",
-		maxThreadsValue,
-	);
-	const updatedSection = findTomlSection(withMaxThreads, CODEX_MULTI_AGENT_V2_HEADER);
-	return replaceOrInsertSetting(withMaxThreads, updatedSection, "hide_spawn_agent_metadata", "false");
-}
-
-function removeFeatureFlagSetting(config, featureName) {
-	const section = findTomlSection(config, "features");
-	if (!section) return config;
-	return removeSetting(config, section, featureName);
-}
-
-function removeLegacyAgentsMaxThreadsSetting(config) {
-	const section = findTomlSection(config, "agents");
-	if (!section) return config;
-	return removeSetting(config, section, "max_threads");
-}

package/packages/omo-codex/scripts/install/permissions.d.mts

@@ -1 +0,0 @@
-export function ensureAutonomousPermissions(config: string): string;

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

@@ -1,37 +0,0 @@
-import { appendBlock, findTomlSection, removeSetting, replaceOrInsertRootSetting, replaceOrInsertSetting } from "./toml-editor.mjs";
-
-const AUTONOMOUS_FEATURES = ["multi_agent", "child_agents_md", "unified_exec", "goals"];
-
-export function ensureAutonomousPermissions(config) {
-	let next = replaceOrInsertRootSetting(config, "approval_policy", JSON.stringify("never"));
-	next = replaceOrInsertRootSetting(next, "sandbox_mode", JSON.stringify("danger-full-access"));
-	next = replaceOrInsertRootSetting(next, "network_access", JSON.stringify("enabled"));
-	for (const featureName of AUTONOMOUS_FEATURES) {
-		next = ensureFeatureEnabled(next, featureName);
-	}
-	next = removeWindowsSandboxSetting(next);
-	next = ensureNoticeEnabled(next, "hide_full_access_warning");
-	return ensureNoticeEnabled(next, "hide_world_writable_warning");
-}
-
-function removeWindowsSandboxSetting(config) {
-	const section = findTomlSection(config, "windows");
-	if (!section) return config;
-	return removeSetting(config, section, "sandbox");
-}
-
-function ensureNoticeEnabled(config, key) {
-	const section = findTomlSection(config, "notice");
-	if (!section) return appendNoticeBlock(config, key);
-	return replaceOrInsertSetting(config, section, key, "true");
-}
-
-function ensureFeatureEnabled(config, key) {
-	const section = findTomlSection(config, "features");
-	if (!section) return appendBlock(config, `[features]\n${key} = true\n`);
-	return replaceOrInsertSetting(config, section, key, "true");
-}
-
-function appendNoticeBlock(config, key) {
-	return appendBlock(config, `[notice]\n${key} = true\n`);
-}