holycodex 0.11.0 → 0.11.2

package/dist/cli.js

@@ -1,7 +1,7 @@
 import process$1 from "node:process";
-import { access, copyFile, cp, lstat, mkdir, readFile, readdir, readlink, rename, rm, stat, writeFile } from "node:fs/promises";
+import { access, copyFile, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, rename, rm, stat, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { delimiter, dirname, join } from "node:path";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { Buffer } from "node:buffer";
@@ -81,7 +81,6 @@ function cached(getter) {
 			Object.defineProperty(this, "value", { value });
 			return value;
 		}
-		throw new Error("cached value already set");
 	} };
 }
 function nullish(input) {
@@ -1907,115 +1906,6 @@ function handleIntersectionResults(result, left, right) {
 	result.value = merged.data;
 	return result;
 }
-var $ZodRecord = /*@__PURE__*/ $constructor("$ZodRecord", (inst, def) => {
-	$ZodType.init(inst, def);
-	inst._zod.parse = (payload, ctx) => {
-		const input = payload.value;
-		if (!isPlainObject(input)) {
-			payload.issues.push({
-				expected: "record",
-				code: "invalid_type",
-				input,
-				inst
-			});
-			return payload;
-		}
-		const proms = [];
-		const values = def.keyType._zod.values;
-		if (values) {
-			payload.value = {};
-			const recordKeys = /* @__PURE__ */ new Set();
-			for (const key of values) if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
-				recordKeys.add(typeof key === "number" ? key.toString() : key);
-				const keyResult = def.keyType._zod.run({
-					value: key,
-					issues: []
-				}, ctx);
-				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
-				if (keyResult.issues.length) {
-					payload.issues.push({
-						code: "invalid_key",
-						origin: "record",
-						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
-						input: key,
-						path: [key],
-						inst
-					});
-					continue;
-				}
-				const outKey = keyResult.value;
-				const result = def.valueType._zod.run({
-					value: input[key],
-					issues: []
-				}, ctx);
-				if (result instanceof Promise) proms.push(result.then((result) => {
-					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
-					payload.value[outKey] = result.value;
-				}));
-				else {
-					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
-					payload.value[outKey] = result.value;
-				}
-			}
-			let unrecognized;
-			for (const key in input) if (!recordKeys.has(key)) {
-				unrecognized = unrecognized ?? [];
-				unrecognized.push(key);
-			}
-			if (unrecognized && unrecognized.length > 0) payload.issues.push({
-				code: "unrecognized_keys",
-				input,
-				inst,
-				keys: unrecognized
-			});
-		} else {
-			payload.value = {};
-			for (const key of Reflect.ownKeys(input)) {
-				if (key === "__proto__") continue;
-				if (!Object.prototype.propertyIsEnumerable.call(input, key)) continue;
-				let keyResult = def.keyType._zod.run({
-					value: key,
-					issues: []
-				}, ctx);
-				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
-				if (typeof key === "string" && number$1.test(key) && keyResult.issues.length) {
-					const retryResult = def.keyType._zod.run({
-						value: Number(key),
-						issues: []
-					}, ctx);
-					if (retryResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
-					if (retryResult.issues.length === 0) keyResult = retryResult;
-				}
-				if (keyResult.issues.length) {
-					if (def.mode === "loose") payload.value[key] = input[key];
-					else payload.issues.push({
-						code: "invalid_key",
-						origin: "record",
-						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
-						input: key,
-						path: [key],
-						inst
-					});
-					continue;
-				}
-				const result = def.valueType._zod.run({
-					value: input[key],
-					issues: []
-				}, ctx);
-				if (result instanceof Promise) proms.push(result.then((result) => {
-					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
-					payload.value[keyResult.value] = result.value;
-				}));
-				else {
-					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
-					payload.value[keyResult.value] = result.value;
-				}
-			}
-		}
-		if (proms.length) return Promise.all(proms).then(() => payload);
-		return payload;
-	};
-});
 var $ZodEnum = /*@__PURE__*/ $constructor("$ZodEnum", (inst, def) => {
 	$ZodType.init(inst, def);
 	const values = getEnumValues(def.entries);
@@ -3281,39 +3171,6 @@ var intersectionProcessor = (schema, ctx, json, params) => {
 	const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
 	json.allOf = [...isSimpleIntersection(a) ? a.allOf : [a], ...isSimpleIntersection(b) ? b.allOf : [b]];
 };
-var recordProcessor = (schema, ctx, _json, params) => {
-	const json = _json;
-	const def = schema._zod.def;
-	json.type = "object";
-	const keyType = def.keyType;
-	const patterns = keyType._zod.bag?.patterns;
-	if (def.mode === "loose" && patterns && patterns.size > 0) {
-		const valueSchema = process$2(def.valueType, ctx, {
-			...params,
-			path: [
-				...params.path,
-				"patternProperties",
-				"*"
-			]
-		});
-		json.patternProperties = {};
-		for (const pattern of patterns) json.patternProperties[pattern.source] = valueSchema;
-	} else {
-		if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") json.propertyNames = process$2(def.keyType, ctx, {
-			...params,
-			path: [...params.path, "propertyNames"]
-		});
-		json.additionalProperties = process$2(def.valueType, ctx, {
-			...params,
-			path: [...params.path, "additionalProperties"]
-		});
-	}
-	const keyValues = keyType._zod.values;
-	if (keyValues) {
-		const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
-		if (validKeyValues.length > 0) json.required = validKeyValues;
-	}
-};
 var nullableProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
 	const inner = process$2(def.innerType, ctx, params);
@@ -3965,14 +3822,6 @@ function strictObject(shape, params) {
 		...normalizeParams(params)
 	});
 }
-function looseObject(shape, params) {
-	return new ZodObject({
-		type: "object",
-		shape,
-		catchall: unknown(),
-		...normalizeParams(params)
-	});
-}
 var ZodUnion = /*@__PURE__*/ $constructor("ZodUnion", (inst, def) => {
 	$ZodUnion.init(inst, def);
 	ZodType.init(inst, def);
@@ -4010,27 +3859,6 @@ function intersection(left, right) {
 		right
 	});
 }
-var ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
-	$ZodRecord.init(inst, def);
-	ZodType.init(inst, def);
-	inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
-	inst.keyType = def.keyType;
-	inst.valueType = def.valueType;
-});
-function record(keyType, valueType, params) {
-	if (!valueType || !valueType._zod) return new ZodRecord({
-		type: "record",
-		keyType: string(),
-		valueType: keyType,
-		...normalizeParams(valueType)
-	});
-	return new ZodRecord({
-		type: "record",
-		keyType,
-		valueType,
-		...normalizeParams(params)
-	});
-}
 var ZodEnum = /*@__PURE__*/ $constructor("ZodEnum", (inst, def) => {
 	$ZodEnum.init(inst, def);
 	ZodType.init(inst, def);
@@ -4252,13 +4080,13 @@ function superRefine(fn, params) {
 }
 //#endregion
 //#region packages/cli/src/catalog.ts
-var VERSION = "0.11.0";
+var VERSION = "0.11.2";
 var SKILLS = [
 	"ast-grep",
 	"babysit-ci",
-	"caveman",
 	"code-review",
 	"compress",
+	"context7-cli",
 	"debugging",
 	"handoff",
 	"lsp",
@@ -4740,36 +4568,112 @@ var GENERATED_RUNTIMES = [
 	"git-bash-resolver.js",
 	"LICENSE-LSP-MIT.txt",
 	"lsp.js",
-	"mcp-stdio-core.js",
 	"rules.js"
 ];
-var WINDOWS_SHELL_POLICY = "On native Windows, before the first shell action, inspect callable and deferred tools until `mcp__git_bash__run` is resolved. Use it for every shell command, including Git, Bash, POSIX, package, build, test, and script commands. If unavailable, stop and report the blocker. Never fall back to PowerShell or cmd.";
-/** Provides effective mcp servers. */
-function effectiveMcpServers(platform) {
-	return {
-		...platform === "win32" ? { git_bash: {
-			command: "node",
-			args: ["runtime/git-bash.js", "mcp"],
-			cwd: ".",
-			enabled_tools: ["run"]
-		} } : {},
-		lsp: {
-			command: "node",
-			args: ["runtime/lsp.js", "mcp"],
-			cwd: "."
-		},
-		context7: {
-			command: "bunx",
-			args: ["@upstash/context7-mcp"]
-		}
-	};
-}
+var WINDOWS_SHELL_POLICY = "On native Windows, run every shell command through the bundled Git Bash launcher, including Git, package, build, test, script and POSIX commands. Never execute task commands through PowerShell or cmd. If Git Bash cannot be resolved, stop and report the blocker. On non-Windows, use the native shell normally.";
+var LITE_WRITING_POLICY = "Communicate grammatically and concisely. Omit filler, hedging, repetition, decoration, self-reference, style announcements and tool narration. Preserve exact technical terms, APIs, commands, paths, errors and commit keywords. Use fuller grammar for safety, ambiguity, clarification and ordered instructions. Apply this policy only to agent communication, never to literal authored or transformed content, UI or accessibility labels, help text, errors, logs, tests, fixtures, documentation, comments, commit or PR text, authored prompts, translations, quotations, generated content, public APIs, or existing repository and product voice.";
+var CONTEXT7_POLICY = "Within assigned scope, use the Context7 CLI skill first for current library, framework, SDK and API documentation. Use live web search for releases, dates, broader research, missing Context7 coverage and corroboration. Context7 does not authorize scope expansion.";
 /** Returns packaged runtime files required on a platform. */
 function requiredPackageRuntimes(platform) {
 	return platform === "win32" ? GENERATED_RUNTIMES : GENERATED_RUNTIMES.filter((file) => file !== "git-bash.js");
 }
 //#endregion
-//#region packages/git-bash-mcp/src/git-bash-resolver.ts
+//#region packages/cli/src/arguments.ts
+var INSTALL_FLAGS = /* @__PURE__ */ new Set([
+	"--plan",
+	"--max-subagents",
+	"--codex-autonomous",
+	"--no-codex-autonomous",
+	"--dangerous-codex-autonomous",
+	"--fast",
+	"--fast-all",
+	"--no-fast",
+	"--json"
+]);
+var SHARED_FLAGS = /* @__PURE__ */ new Set(["--json"]);
+/** Strictly parses command-specific HolyCodex CLI arguments. */
+function parseCliArguments(args) {
+	if (args.length === 0 || args[0] === "--help" || args[0] === "-h") return base("help");
+	if (args[0] === "--version" || args[0] === "-v") {
+		if (args.length !== 1) throw new Error("--version does not accept other arguments.");
+		return base("version");
+	}
+	const command = args[0];
+	if (command !== "install" && command !== "doctor" && command !== "cleanup") throw new Error(`Unknown command: ${command ?? ""}`);
+	if (args[1] === "--help" || args[1] === "-h") {
+		if (args.length !== 2) throw new Error("--help does not accept other arguments.");
+		return {
+			...base("help"),
+			command
+		};
+	}
+	const allowed = command === "install" ? INSTALL_FLAGS : SHARED_FLAGS;
+	const values = /* @__PURE__ */ new Map();
+	for (let index = 1; index < args.length; index += 1) {
+		const token = args[index];
+		if (token === void 0 || !token.startsWith("--")) throw new Error(`Unexpected positional argument: ${token ?? ""}`);
+		const separator = token.indexOf("=");
+		const name = separator < 0 ? token : token.slice(0, separator);
+		if (!allowed.has(name)) throw new Error(`Option ${name} is not valid for ${command}.`);
+		if (values.has(name)) throw new Error(`Repeated option: ${name}`);
+		if (name !== "--plan" && name !== "--max-subagents") {
+			if (separator >= 0) throw new Error(`${name} does not accept a value.`);
+			values.set(name, true);
+			continue;
+		}
+		const value = separator < 0 ? args[++index] : token.slice(separator + 1);
+		if (value === void 0 || value === "" || separator < 0 && value.startsWith("--")) throw new Error(`Missing value for ${name}.`);
+		values.set(name, value);
+	}
+	const autonomyFlags = [
+		"--codex-autonomous",
+		"--no-codex-autonomous",
+		"--dangerous-codex-autonomous"
+	].filter((flag) => values.has(flag));
+	if (autonomyFlags.length > 1) throw new Error(`Conflicting autonomy flags: ${autonomyFlags.join(", ")}`);
+	const fastFlags = [
+		"--fast",
+		"--fast-all",
+		"--no-fast"
+	].filter((flag) => values.has(flag));
+	if (fastFlags.length > 1) throw new Error(`Conflicting Fast flags: ${fastFlags.join(", ")}`);
+	const planValue = values.get("--plan") ?? "plus";
+	const plan = PlanNameSchema.safeParse(planValue);
+	if (!plan.success) throw new Error(`Unknown plan: ${String(planValue)}. Valid plans: ${PLAN_NAMES.join(", ")}.`);
+	const maxValue = values.get("--max-subagents");
+	if (maxValue !== void 0 && (typeof maxValue !== "string" || !/^\d+$/.test(maxValue) || Number(maxValue) > 3)) throw new Error(`Invalid --max-subagents value: ${String(maxValue)}. Expected an integer from 0 through 3.`);
+	const autonomy = values.has("--dangerous-codex-autonomous") ? {
+		requested: true,
+		mode: "dangerous"
+	} : values.has("--codex-autonomous") ? {
+		requested: true,
+		mode: "autonomous"
+	} : values.has("--no-codex-autonomous") ? {
+		requested: true,
+		mode: "default"
+	} : { requested: false };
+	const fast = FastModeSchema.parse(values.has("--fast-all") ? "fast-all" : values.has("--fast") ? "fast" : "standard");
+	return {
+		action: "run",
+		command,
+		json: values.has("--json"),
+		plan: plan.data,
+		...maxValue === void 0 ? {} : { maxSubagents: Number(maxValue) },
+		autonomy,
+		fast
+	};
+}
+function base(action) {
+	return {
+		action,
+		json: false,
+		plan: DEFAULT_PLAN,
+		autonomy: { requested: false },
+		fast: "standard"
+	};
+}
+//#endregion
+//#region packages/git-bash/src/git-bash-resolver.ts
 var GIT_BASH_ENV_KEY = "HOLYCODEX_GIT_BASH_PATH";
 var PROGRAM_FILES = "C:\\Program Files\\Git\\bin\\bash.exe";
 var PROGRAM_FILES_X86 = "C:\\Program Files (x86)\\Git\\bin\\bash.exe";
@@ -4850,7 +4754,7 @@ function missing(checkedPaths) {
 	};
 }
 //#endregion
-//#region packages/mcp-stdio-core/src/process.ts
+//#region packages/runtime-core/src/process.ts
 var TRUNCATED_MARKER = "\n... diagnostic output truncated ...\n";
 var defaultManagedProcessRuntime = {
 	terminationGraceMs: 2e3,
@@ -4915,11 +4819,13 @@ async function runManagedProcess(input, runtime = defaultManagedProcessRuntime)
 		let matched = false;
 		let settled = false;
 		let forceKillTimeout;
+		let finalResolutionTimeout;
 		const finish = (exitCode, error, errorCode) => {
 			if (settled) return;
 			settled = true;
 			clearTimeout(timeout);
 			if (forceKillTimeout !== void 0) clearTimeout(forceKillTimeout);
+			if (finalResolutionTimeout !== void 0) clearTimeout(finalResolutionTimeout);
 			resolve({
 				exitCode,
 				stdout: outputText(stdout),
@@ -4938,6 +4844,8 @@ async function runManagedProcess(input, runtime = defaultManagedProcessRuntime)
 				runtime.kill(child, input.platform, "SIGKILL");
 			}, runtime.terminationGraceMs);
 			forceKillTimeout.unref();
+			finalResolutionTimeout = setTimeout(() => finish(child.exitCode, "Managed process did not emit close after termination."), input.finalResolutionMs ?? runtime.terminationGraceMs * 2);
+			finalResolutionTimeout.unref();
 		};
 		const inspectMatch = () => {
 			if (matched || input.matchOutput === void 0) return;
@@ -4968,7 +4876,9 @@ async function runManagedProcess(input, runtime = defaultManagedProcessRuntime)
 /** Terminates process tree. */
 function killProcessTree(child, platform, signal = "SIGTERM", runTaskkill = (command, args) => spawnSync(command, [...args], {
 	stdio: "ignore",
-	windowsHide: true
+	windowsHide: true,
+	timeout: 2e3,
+	killSignal: "SIGKILL"
 })) {
 	if (platform === "win32" && child.pid !== void 0) {
 		const result = runTaskkill("taskkill", [
@@ -5311,6 +5221,13 @@ function nextTableBoundary(input) {
 	if (managedHeader < 0) return header;
 	return Math.min(header, managedHeader);
 }
+function tableSource(input, table) {
+	const match = new RegExp(`^\\s*\\[${table.replaceAll(".", "\\.")}]\\s*(?:#.*)?$`, "m").exec(input);
+	if (match === null) return void 0;
+	const tail = input.slice(match.index + match[0].length);
+	const end = nextTableBoundary(tail);
+	return end < 0 ? tail : tail.slice(0, end);
+}
 function rootValue(input, key) {
 	if (key === "status_line") return rootTomlStringArraySource(input, key);
 	return new RegExp(`^\\s*${key}\\s*=.*$`, "m").exec(input)?.[0];
@@ -5351,23 +5268,27 @@ function readPreservedRootOverrides(input) {
 	const managedRoot = new RegExp(`^${START}\\r?\\n([\\s\\S]*?)^${END}\\r?$`, "m").exec(input)?.[1];
 	if (managedRoot === void 0) return {
 		model: false,
-		reasoningEffort: false
+		reasoningEffort: false,
+		webSearch: false
 	};
 	const plan = readManagedPlan(managedRoot);
 	const model = rootTomlString(input, "model");
 	const reasoningEffort = rootTomlString(input, "model_reasoning_effort");
 	if (plan === void 0 || model === void 0 || reasoningEffort === void 0) return {
 		model: false,
-		reasoningEffort: false
+		reasoningEffort: false,
+		webSearch: false
 	};
 	if (MANAGED_ROOT_MODEL_HISTORY_BY_PLAN[plan].some((route) => route.model === model && route.reasoningEffort === reasoningEffort)) return {
 		model: false,
-		reasoningEffort: false
+		reasoningEffort: false,
+		webSearch: rootTomlString(managedRoot, "web_search") !== "live"
 	};
 	const preset = MODEL_ROUTING_PLANS[plan].root;
 	return {
 		model: model !== preset.model,
-		reasoningEffort: reasoningEffort !== preset.reasoningEffort
+		reasoningEffort: reasoningEffort !== preset.reasoningEffort,
+		webSearch: rootTomlString(managedRoot, "web_search") !== "live"
 	};
 }
 function preserveManagedRootPreferences(input, base) {
@@ -5378,7 +5299,11 @@ function preserveManagedRootPreferences(input, base) {
 	const tables = firstTable < 0 ? "" : base.slice(firstTable);
 	let updatedRoot = root.trim();
 	const overrides = readPreservedRootOverrides(input);
-	for (const [key, preserve] of [["model", overrides.model], ["model_reasoning_effort", overrides.reasoningEffort]]) {
+	for (const [key, preserve] of [
+		["model", overrides.model],
+		["model_reasoning_effort", overrides.reasoningEffort],
+		["web_search", overrides.webSearch]
+	]) {
 		const live = rootValue(managedRoot, key)?.trim();
 		if (!preserve || live === void 0) continue;
 		if (rootValue(root, key)?.trim() === live) continue;
@@ -5416,6 +5341,7 @@ function installConfig(input, mode, _platform, plan = DEFAULT_PLAN, maxSubagents
 	const hadOriginalRoot = /^# holycodex original root:/m.test(input);
 	const permissionLines = originalPermissionLines ?? (legacyGeneratedRoot !== void 0 && previousOriginalRoot === void 0 ? [] : previousOriginalRoot === void 0 ? hadManagedAutonomy && !hadOriginalRoot ? [] : readPermissionLines(root) : readPermissionLines(previousOriginalRoot));
 	const controlled = [
+		"web_search",
 		"approval_policy",
 		"approvals_reviewer",
 		"sandbox_mode",
@@ -5426,6 +5352,7 @@ function installConfig(input, mode, _platform, plan = DEFAULT_PLAN, maxSubagents
 		...request.requested ? ["default_permissions"] : []
 	].map((key) => rootValue(root, key));
 	const preservedRoot = [
+		"web_search",
 		"approval_policy",
 		"approvals_reviewer",
 		"sandbox_mode",
@@ -5446,72 +5373,131 @@ function installConfig(input, mode, _platform, plan = DEFAULT_PLAN, maxSubagents
 	const original = originalSource ? `${ORIGINAL_ROOT}${Buffer.from(originalSource).toString("base64")}\n` : "";
 	const maxSubagentsMetadata = maxSubagents === void 0 ? "" : `${MAX_SUBAGENTS_PREFIX}${maxSubagents}\n`;
 	const rootServiceTier = fastMode === "fast-all" ? "fast" : "default";
-	const rootBlock = `${START}\n${PLAN_PREFIX}${plan}\n${FAST_MODE_PREFIX}${fastMode}\n${AUTONOMY_METADATA_PREFIX}${effectiveAutonomy}\n${maxSubagentsMetadata}${original}${originalPermissionMetadata(permissionLines)}${model}${effort}model_verbosity = "low"\nservice_tier = "${rootServiceTier}"\n${rootPermissionLines.join("\n")}\nstatus_line = ${mergedStatusLine(rootValue(root, "status_line"))}\n${END}`;
+	const priorManagedRoot = new RegExp(`^${START}\\r?\\n([\\s\\S]*?)^${END}\\r?$`, "m").exec(input)?.[1];
+	const webSearch = readPreservedRootOverrides(input).webSearch ? rootTomlString(priorManagedRoot ?? "", "web_search") ?? "live" : "live";
+	const statusLine = mergedStatusLine(rootValue(root, "status_line") ?? rootTomlStringArraySource(tableSource(base, "tui") ?? "", "status_line"));
+	const rootBlock = `${START}\n${PLAN_PREFIX}${plan}\n${FAST_MODE_PREFIX}${fastMode}\n${AUTONOMY_METADATA_PREFIX}${effectiveAutonomy}\n${maxSubagentsMetadata}${original}${originalPermissionMetadata(permissionLines)}${model}${effort}web_search = ${JSON.stringify(webSearch)}\nmodel_verbosity = "low"\nservice_tier = "${rootServiceTier}"\n${rootPermissionLines.join("\n")}\n${END}`;
 	let configured = `${preservedRoot ? `${preservedRoot}\n` : ""}${rootBlock}${tables ? `\n\n${tables}` : ""}`;
+	const legacyMultiAgentV2 = /\bmulti_agent_v2\s*=\s*(true|false)/.exec(configured)?.[1];
 	configured = injectTableKeys(configured, "features", [
 		["default_mode_request_user_input", "true"],
 		["multi_agent", "true"],
-		["multi_agent_v2", "true"]
+		...legacyMultiAgentV2 === void 0 ? [] : [["multi_agent_v2", legacyMultiAgentV2]]
 	]);
 	const usage = MODEL_ROUTING_PLANS[plan].usage;
-	configured = injectTableKeys(configured, "agents", [["max_threads", String(effectiveMaxSubagents + 1)], ["max_depth", String(usage.maxDepth)]]);
+	configured = injectTableKeys(configured, "agents", [["max_concurrent_threads_per_session", String(effectiveMaxSubagents + 1)], ["max_depth", String(usage.maxDepth)]]);
+	configured = injectTableKeys(configured, "tui", [["status_line", statusLine]]);
 	if (effectiveAutonomy !== "dangerous") configured = injectTableKeys(configured, "sandbox_workspace_write", [["network_access", "true"]]);
-	configured = injectTableKeys(configured, "desktop", [["enabled-reasoning-efforts", "[\"low\", \"medium\", \"high\", \"xhigh\", \"max\"]"], ["show-context-window-usage", "true"]]);
+	configured = injectTableKeys(configured, "desktop", [["show-context-window-usage", "true"]]);
 	if (_platform === "win32") configured = injectTableKeys(configured, "windows", [["sandbox", "\"unelevated\""]]);
 	for (const agent of AGENTS) configured = injectTableKeys(configured, `agents.${agent}`, [["config_file", `"holycodex/agents/${agent}.toml"`]]);
 	const plugin = `${START}\n[plugins."holycodex@holycodex"]\nenabled = true\n${END}`;
 	return `${configured.trim()}\n\n${plugin}\n`;
 }
 //#endregion
+//#region packages/cli/src/context7.ts
+var RUNNERS = [
+	{
+		executable: "nubx",
+		command: "nubx",
+		prefix: ["-y"]
+	},
+	{
+		executable: "nub",
+		command: "nub",
+		prefix: ["dlx"]
+	},
+	{
+		executable: "bunx",
+		command: "bunx",
+		prefix: []
+	},
+	{
+		executable: "bun",
+		command: "bun",
+		prefix: ["x"]
+	},
+	{
+		executable: "pnpmx",
+		command: "pnpmx",
+		prefix: []
+	},
+	{
+		executable: "pnpm",
+		command: "pnpm",
+		prefix: ["dlx"]
+	},
+	{
+		executable: "npmx",
+		command: "npmx",
+		prefix: ["--yes"]
+	},
+	{
+		executable: "npm",
+		command: "npx",
+		prefix: ["--yes"]
+	},
+	{
+		executable: "yarn",
+		command: "yarn",
+		prefix: ["dlx"]
+	}
+];
+/** Constructs the supported direct Context7 invocation for the first available runner. */
+function context7Command(args, executableExists = executableOnPath, env = process.env) {
+	const runner = RUNNERS.find((candidate) => executableExists(candidate.executable));
+	if (runner === void 0) return void 0;
+	return {
+		command: runner.command,
+		args: [
+			...runner.prefix,
+			"ctx7@latest",
+			...args
+		],
+		env: {
+			...env,
+			CI: env.CI ?? "1"
+		}
+	};
+}
+/** Reports whether an executable can be resolved from PATH. */
+function executableOnPath(name) {
+	const path = process.env.PATH;
+	if (path === void 0) return false;
+	const extensions = process.platform === "win32" ? [
+		".exe",
+		".cmd",
+		".bat",
+		""
+	] : [""];
+	for (const directory of path.split(delimiter)) for (const extension of extensions) try {
+		if (process.getBuiltinModule("node:fs").existsSync(`${directory}/${name}${extension}`)) return true;
+	} catch {
+		continue;
+	}
+	return false;
+}
+//#endregion
 //#region packages/cli/src/doctor.ts
-var McpManifestSchema = looseObject({ mcpServers: record(string(), record(string(), unknown())) });
-async function runCommand(name, args, platform) {
+var COMPATIBILITY_KEYS = ["desktop.show-context-window-usage"];
+async function runCommand(name, args, env) {
 	const result = await runManagedProcess({
 		command: name,
 		args,
-		platform,
-		timeoutMs: 1e4,
-		maxOutputChars: 64 * 1024
+		platform: process.platform,
+		timeoutMs: 15e3,
+		maxOutputChars: 64 * 1024,
+		...env === void 0 ? {} : { env }
 	});
 	return {
 		ok: result.exitCode === 0 && !result.timedOut && result.error === void 0,
 		output: `${result.stdout}\n${result.stderr}`.trim() || result.error || ""
 	};
 }
-async function startContext7(platform) {
-	const result = await runManagedProcess({
-		command: "bunx",
-		args: ["@upstash/context7-mcp"],
-		platform,
-		timeoutMs: 15e3,
-		maxOutputChars: 128 * 1024,
-		stdin: `${JSON.stringify({
-			jsonrpc: "2.0",
-			id: 1,
-			method: "initialize",
-			params: {
-				protocolVersion: "2025-03-26",
-				capabilities: {},
-				clientInfo: {
-					name: "holycodex-doctor",
-					version: VERSION
-				}
-			}
-		})}\n`,
-		matchOutput: (output) => output.includes("\"serverInfo\"") || output.includes("\"capabilities\"")
-	});
-	const diagnostic = `${result.stdout}\n${result.stderr}`.trim() || result.error || "";
-	return {
-		ok: result.matched && !result.timedOut,
-		timedOut: result.timedOut,
-		packageFailure: /(?:404|failed to resolve|package.*not found|error: GET)/i.test(diagnostic),
-		detail: diagnostic
-	};
-}
 var defaultRuntime$1 = {
 	platform: process.platform,
-	command: (name, args) => runCommand(name, args, process.platform),
-	context7: () => startContext7(process.platform),
+	command: runCommand,
+	executable: executableOnPath,
 	gitBash: resolveGitBashForCurrentProcess
 };
 function check(id, status, code, detail, fix) {
@@ -5523,14 +5509,6 @@ function check(id, status, code, detail, fix) {
 		...fix === void 0 ? {} : { fix }
 	};
 }
-function mcpConfigMatches(actual, expected) {
-	const expectedEntries = Object.entries(expected);
-	if (Object.keys(actual).length !== expectedEntries.length) return false;
-	return expectedEntries.every(([key, expectedValue]) => {
-		const actualValue = actual[key];
-		return Array.isArray(expectedValue) ? Array.isArray(actualValue) && actualValue.length === expectedValue.length && actualValue.every((value, index) => value === expectedValue[index]) : actualValue === expectedValue;
-	});
-}
 async function missingFiles(root, paths) {
 	const missing = [];
 	for (const path of paths) try {
@@ -5540,138 +5518,82 @@ async function missingFiles(root, paths) {
 	}
 	return missing;
 }
-function tableBoolean(config, table, key) {
-	const body = new RegExp(`^\\s*\\[${table.replaceAll(".", "\\.")}]\\s*$([\\s\\S]*?)(?=^\\s*\\[|(?![\\s\\S]))`, "m").exec(config)?.[1];
-	const value = body === void 0 ? void 0 : new RegExp(`^\\s*${key}\\s*=\\s*(true|false)`, "m").exec(body)?.[1];
-	return value === void 0 ? void 0 : value === "true";
-}
-function tableString(config, table, key) {
-	const body = new RegExp(`^\\s*\\[${table.replaceAll(".", "\\.")}]\\s*$([\\s\\S]*?)(?=^\\s*\\[|(?![\\s\\S]))`, "m").exec(config)?.[1];
-	return body === void 0 ? void 0 : rootTomlString(body, key);
+function tableBody(config, table) {
+	return new RegExp(`^\\s*\\[${table.replaceAll(".", "\\.")}]\\s*$([\\s\\S]*?)(?=^\\s*\\[|(?![\\s\\S]))`, "m").exec(config)?.[1];
 }
-function tableStringArray(config, table, key) {
-	const body = new RegExp(`^\\s*\\[${table.replaceAll(".", "\\.")}]\\s*$([\\s\\S]*?)(?=^\\s*\\[|(?![\\s\\S]))`, "m").exec(config)?.[1];
-	return body === void 0 ? void 0 : rootTomlStringArray(body, key);
-}
-function tableInteger(config, table, key) {
-	const body = new RegExp(`^\\s*\\[${table.replaceAll(".", "\\.")}]\\s*$([\\s\\S]*?)(?=^\\s*\\[|(?![\\s\\S]))`, "m").exec(config)?.[1];
-	const value = body === void 0 ? void 0 : new RegExp(`^\\s*${key}\\s*=\\s*(\\d+)`, "m").exec(body)?.[1];
-	return value === void 0 ? void 0 : Number(value);
+function tableValue(config, table, key) {
+	const body = tableBody(config, table);
+	return body === void 0 ? void 0 : new RegExp(`^\\s*${key.replaceAll("-", "\\-")}\\s*=\\s*(.+?)\\s*$`, "m").exec(body)?.[1];
 }
 function autonomy(config) {
 	const approval = rootTomlString(config, "approval_policy");
-	const approvalsReviewer = rootTomlString(config, "approvals_reviewer");
+	const reviewer = rootTomlString(config, "approvals_reviewer");
 	const sandbox = rootTomlString(config, "sandbox_mode");
-	const network = tableBoolean(config, "sandbox_workspace_write", "network_access");
-	if (approval === "on-request" && approvalsReviewer === "auto_review" && sandbox === "workspace-write" && network === true) return "safe-workspace";
-	if (approval === "never" && approvalsReviewer === void 0 && sandbox === "workspace-write" && network === true) return "autonomous-workspace";
-	if (approval === "never" && approvalsReviewer === void 0 && sandbox === "danger-full-access") return "dangerous";
+	const network = tableValue(config, "sandbox_workspace_write", "network_access");
+	if (approval === "on-request" && reviewer === "auto_review" && sandbox === "workspace-write" && network === "true") return "safe-workspace";
+	if (approval === "never" && reviewer === void 0 && sandbox === "workspace-write" && network === "true") return "autonomous-workspace";
+	if (approval === "never" && reviewer === void 0 && sandbox === "danger-full-access") return "dangerous";
 	return "unknown";
 }
-/** Runs HolyCodex installation and environment health checks. */
+/** Runs installation, configuration, runtime, and override health checks. */
 async function doctor(home = process.env.CODEX_HOME ?? join(homedir(), ".codex"), runtime = defaultRuntime$1) {
 	const checks = [];
 	const pluginRoot = join(home, "plugins", "cache", "holycodex", "holycodex", VERSION);
 	const agentRoot = join(home, "holycodex", "agents");
 	const configPath = join(home, "config.toml");
 	let config = "";
-	let configAvailable = true;
 	try {
 		config = await readFile(configPath, "utf8");
 	} catch {
-		configAvailable = false;
+		checks.push(check("config", "error", "config-missing", `Missing ${configPath}.`, "Run holycodex install."));
 	}
 	const missing = await missingFiles(pluginRoot, [
 		".codex-plugin/plugin.json",
-		".mcp.json",
-		"LICENSE-OH-MY-OPENCODE-SLIM-MIT.txt",
 		"hooks/hooks.json",
 		...requiredPackageRuntimes(runtime.platform).map((file) => `runtime/${file}`),
 		...AGENTS.map((name) => `agents/${name}.toml`),
 		...SKILLS.map((name) => `skills/${name}/SKILL.md`)
 	]);
-	checks.push(missing.length === 0 ? check("package", "ok", "package-ready", `Plugin ${VERSION}, generated runtime, hooks, three agents, and ${SKILLS.length} skills are present.`) : check("package", "error", "package-incomplete", `Missing ${missing.join(", ")}.`, "Reinstall HolyCodex."));
-	let mcp;
-	try {
-		mcp = McpManifestSchema.parse(JSON.parse(await readFile(join(pluginRoot, ".mcp.json"), "utf8")));
-	} catch (error) {
-		checks.push(check("mcp-config", "error", "malformed-mcp-config", error instanceof ZodError ? "Invalid MCP JSON structure." : error instanceof Error ? error.message : "Invalid MCP JSON.", "Reinstall HolyCodex."));
-	}
-	const servers = mcp?.mcpServers;
-	const requiredMcps = runtime.platform === "win32" ? ["git_bash", "lsp"] : ["lsp"];
-	const expectedMcps = effectiveMcpServers(runtime.platform);
-	for (const name of requiredMcps) {
-		const configured = servers?.[name];
-		const expected = expectedMcps[name];
-		checks.push(configured === void 0 || expected === void 0 ? check(`mcp-${name}`, "error", "missing-required-mcp", `${name} is not configured.`, "Reinstall HolyCodex.") : !mcpConfigMatches(configured, expected) ? check(`mcp-${name}`, "error", "invalid-required-mcp-config", `${name} configuration is stale or contains unsupported settings.`, "Reinstall HolyCodex.") : check(`mcp-${name}`, "ok", "required-mcp-ready", `${name} is configured locally.`));
-	}
-	const gitBashConfig = servers?.git_bash;
-	if (runtime.platform === "win32" && gitBashConfig !== void 0) {
-		const expected = effectiveMcpServers("win32").git_bash;
-		checks.push(expected !== void 0 && mcpConfigMatches(gitBashConfig, expected) ? check("mcp-git_bash-config", "ok", "git-bash-mcp-config-ready", "Git Bash MCP exposes only run through the supported allowlist.") : check("mcp-git_bash-config", "error", "invalid-git-bash-mcp-config", "Git Bash MCP command or enabled_tools configuration is stale.", "Reinstall HolyCodex."));
-	} else if (runtime.platform !== "win32" && gitBashConfig !== void 0) checks.push(check("mcp-git_bash-config", "error", "unexpected-git-bash-mcp", "Git Bash MCP must not be installed on non-Windows platforms.", "Reinstall HolyCodex for this platform."));
-	const context7 = servers?.context7;
-	const expectedContext7 = effectiveMcpServers(runtime.platform).context7;
-	const obsoleteAuth = context7 !== void 0 && [
-		"headers",
-		"env",
-		"authorization",
-		"apiKey"
-	].some((key) => key in context7);
-	if (context7 === void 0) checks.push(check("context7-config", "error", "missing-context7", "Context7 is not configured.", "Reinstall HolyCodex."));
-	else if (string().safeParse(context7.url).success) checks.push(check("context7-config", "error", "obsolete-context7-remote", "Context7 still uses a hosted URL.", "Reinstall to use local bunx Context7."));
-	else if (obsoleteAuth) checks.push(check("context7-config", "error", "obsolete-context7-auth", "Context7 contains obsolete authentication settings.", "Remove auth settings and reinstall."));
-	else if (expectedContext7 === void 0 || !mcpConfigMatches(context7, expectedContext7)) checks.push(check("context7-config", "error", "invalid-context7-config", "Context7 launch configuration is stale or contains unsupported settings.", "Repair .mcp.json or reinstall."));
-	else checks.push(check("context7-config", "ok", "local-context7-config", "Local no-auth Context7 is configured."));
-	const bun = await runtime.command("bun", ["--version"]);
-	const bunx = await runtime.command("bunx", ["--version"]);
-	checks.push(bun.ok ? check("bun", "ok", "bun-ready", `Bun ${bun.output || "available"}.`) : check("bun", "error", "missing-bun", "Bun is unavailable.", "Install or repair Bun."));
-	checks.push(bunx.ok ? check("bunx", "ok", "bunx-ready", `bunx ${bunx.output || "available"}.`) : check("bunx", "error", "missing-bunx", "bunx is unavailable.", "Repair the Bun installation."));
-	if (bun.ok && bunx.ok && checks.some((item) => item.code === "local-context7-config")) {
-		const started = await runtime.context7();
-		checks.push(started.ok && !started.timedOut ? check("context7-startup", "ok", "context7-healthy", "Context7 completed a bounded MCP handshake.") : started.packageFailure ? check("context7-startup", "error", "context7-package-resolution-failed", started.detail || "Context7 package resolution failed.", "Check network/package availability.") : check("context7-startup", "error", "context7-startup-failed", started.detail || "Context7 did not complete an MCP handshake within 15 seconds.", runtime.platform === "win32" ? "Run bunx @upstash/context7-mcp in Git Bash." : "Run bunx @upstash/context7-mcp in the native shell."));
-	}
+	checks.push(missing.length === 0 ? check("package", "ok", "package-ready", `Plugin ${VERSION}, runtimes, agents, and ${SKILLS.length} skills are present.`) : check("package", "error", "package-incomplete", `Missing ${missing.join(", ")}.`, "Reinstall HolyCodex."));
+	const webSearchOverride = readPreservedRootOverrides(config).webSearch;
+	checks.push(rootTomlString(config, "web_search") === "live" ? check("web-search", "ok", "live-web-search", "Managed web search defaults to live.") : webSearchOverride ? check("web-search", "ok", "web-search-override", "An intentional user web-search override is preserved.") : check("web-search", "error", "web-search-not-live", "Managed web search is not live.", "Reinstall HolyCodex."));
+	const status = rootTomlStringArray(config, "status_line") ?? rootTomlStringArray(tableBody(config, "tui") ?? "", "status_line");
+	checks.push(status?.includes("context-remaining") ? check("context-visibility", "ok", "context-visible", "Context-window usage remains visible.") : check("context-visibility", "error", "context-hidden", "The status line does not show context remaining.", "Reinstall HolyCodex."));
+	checks.push(check("screenshot", "ok", "screenshot-default-preserved", "HolyCodex does not override the enabled Codex screenshot default."));
+	const context7 = context7Command(["--version"], runtime.executable);
+	if (context7 === void 0) checks.push(check("context7", "error", "context7-runner-missing", "No supported direct Context7 runner is available.", "Install nub, Bun, pnpm, npm, or Yarn."));
+	else checks.push(check("context7", "ok", "context7-cli-ready", `${context7.command} constructs a valid direct ctx7@latest command.`));
+	const lsp = await runtime.command(process.execPath, [
+		join(pluginRoot, "runtime", "lsp.js"),
+		"status",
+		"--json"
+	], {
+		...process.env,
+		HOLYCODEX_LSP_IDLE_SHUTDOWN_MS: "0",
+		HOLYCODEX_LSP_IDLE_CHECK_INTERVAL_MS: "50"
+	});
+	checks.push(lsp.ok ? check("lsp", "ok", "lsp-cli-ready", "The LSP CLI and daemon are reachable.") : check("lsp", "error", "lsp-cli-failed", lsp.output || "LSP CLI failed.", "Reinstall HolyCodex and inspect the reported daemon log."));
 	if (runtime.platform === "win32") {
-		const gitBash = runtime.gitBash();
-		checks.push(gitBash.found ? check("git-bash", "ok", "git-bash-ready", `Git Bash: ${gitBash.path ?? "configured"}.`) : check("git-bash", "error", "missing-git-bash", "Git Bash is required on Windows but unavailable.", gitBash.installHint));
-	} else checks.push(check("git-bash", "ok", "git-bash-not-applicable", "Git Bash is not applicable on this platform."));
-	if (!configAvailable) checks.push(check("codex-config", "error", "missing-codex-config", `Missing ${configPath}.`, "Run holycodex install."));
-	const mode = autonomy(config);
+		const resolution = runtime.gitBash();
+		checks.push(resolution.found ? check("git-bash", "ok", "git-bash-launcher-ready", `Git Bash resolves at ${resolution.path}; the bundled launcher is present.`) : check("git-bash", "error", "git-bash-unavailable", resolution.installHint, resolution.installHint));
+	}
 	const plan = readManagedPlan(config);
-	checks.push(plan === void 0 ? check("routing-plan", "error", "routing-plan-missing", "No managed model routing plan is recorded.", "Rerun holycodex install.") : check("routing-plan", "ok", "routing-plan-ready", `Model routing plan ${plan} is active.`));
-	const preset = plan === void 0 ? void 0 : MODEL_ROUTING_PLANS[plan];
-	const managedFastMode = readManagedFastMode(config);
-	const managedMaxSubagents = readManagedMaxSubagents(config);
-	const expectedMaxSubagents = managedMaxSubagents.configured ? managedMaxSubagents.value : preset?.usage.maxSubagents;
-	const rootOverrides = readPreservedRootOverrides(config);
-	checks.push(preset !== void 0 && rootTomlString(config, "model") === preset.root.model && rootTomlString(config, "model_reasoning_effort") === preset.root.reasoningEffort ? check("root-model", "ok", "root-model-ready", "Root model matches the selected routing plan.") : rootOverrides.model || rootOverrides.reasoningEffort ? check("root-model", "ok", "root-model-override", "Root model uses an intentionally preserved explicit override.") : check("root-model", "error", "root-model-stale", "Root model configuration does not match the selected routing plan.", "Reinstall HolyCodex."));
-	checks.push(["default", "fast"].includes(rootTomlString(config, "service_tier") ?? "") && (managedFastMode === void 0 || rootTomlString(config, "service_tier") === (managedFastMode === "fast-all" ? "fast" : "default")) ? check("service-tier", "ok", "service-tier-ready", "Codex service tier is explicitly managed.") : check("service-tier", "error", "service-tier-stale", "service_tier does not match the managed Fast mode.", "Reinstall HolyCodex with --fast, --fast-all, or --no-fast."));
-	checks.push(rootTomlString(config, "model_verbosity") === "low" ? check("root-verbosity", "ok", "root-verbosity-ready", "Root model verbosity is forced to low.") : check("root-verbosity", "error", "root-verbosity-stale", "Root model verbosity must be low.", "Reinstall HolyCodex."));
-	checks.push(preset === void 0 || expectedMaxSubagents === void 0 || tableInteger(config, "agents", "max_threads") !== expectedMaxSubagents + 1 || tableInteger(config, "agents", "max_depth") !== preset.usage.maxDepth ? check("agent-usage", "error", "agent-usage-stale", "Agent concurrency configuration does not match the selected routing plan or explicit override.", "Reinstall HolyCodex.") : check("agent-usage", "ok", "agent-usage-ready", `Agent concurrency allows ${expectedMaxSubagents} direct subagent${expectedMaxSubagents === 1 ? "" : "s"}.`));
-	checks.push(mode === "unknown" ? check("autonomy", "error", "invalid-autonomy-config", "Approval policy, approval reviewer, sandbox, and network settings do not match a supported mode.", "Rerun install with the intended autonomy flag.") : mode === "dangerous" ? check("autonomy", "warning", "dangerous-autonomy", "Explicit dangerous autonomy is active; workspace containment is removed.") : check("autonomy", "ok", `${mode}-ready`, mode === "safe-workspace" ? "Safe workspace autonomy is active." : "Approval-free workspace autonomy is active."));
-	checks.push(tableBoolean(config, "features", "default_mode_request_user_input") === true ? check("user-input", "ok", "user-input-ready", "default_mode_request_user_input is enabled.") : check("user-input", "error", "user-input-disabled", "default_mode_request_user_input is not enabled.", "Rerun holycodex install."));
-	checks.push(tableStringArray(config, "desktop", "enabled-reasoning-efforts")?.join(",") === "low,medium,high,xhigh,max" ? check("desktop-reasoning", "ok", "desktop-reasoning-ready", "Desktop exposes low through max reasoning efforts.") : check("desktop-reasoning", "error", "desktop-reasoning-stale", "Desktop reasoning choices must include low through max.", "Reinstall HolyCodex."));
-	checks.push(tableBoolean(config, "desktop", "show-context-window-usage") === true ? check("desktop-context-usage", "ok", "desktop-context-usage-ready", "Desktop context-window usage is visible.") : check("desktop-context-usage", "error", "desktop-context-usage-hidden", "Desktop context-window usage is not enabled.", "Reinstall HolyCodex."));
-	checks.push(rootTomlStringArray(config, "status_line")?.includes("context-remaining") === true ? check("context-visibility", "warning", "context-visible-support-unverified", "status_line includes context-remaining. Current official Codex config documents this item, but publishes no minimum compatible Codex version.") : check("context-visibility", "error", "context-hidden", "status_line does not include context-remaining.", "Rerun holycodex install."));
-	const codex = await runtime.command("codex", ["--version"]);
-	checks.push(codex.ok ? check("codex", "ok", "codex-version", codex.output || "Codex is available.") : check("codex", "warning", "codex-version-unavailable", "Codex version could not be read; status-line compatibility cannot be independently confirmed."));
-	if (runtime.platform === "win32") checks.push(tableString(config, "windows", "sandbox") === "unelevated" ? check("windows-sandbox", "ok", "windows-sandbox-ready", "Windows sandbox runs unelevated.") : check("windows-sandbox", "error", "windows-sandbox-stale", "Windows sandbox must run unelevated.", "Reinstall HolyCodex on Windows."));
-	const agentModelFailures = [];
-	const agentTierValues = [];
-	for (const agent of AGENTS) try {
-		const text = await readFile(join(agentRoot, `${agent}.toml`), "utf8");
-		const expected = plan === void 0 ? void 0 : MODEL_ROUTING_PLANS[plan].agents[agent];
-		if (expected === void 0 || rootTomlString(text, "model") !== expected.model || rootTomlString(text, "model_reasoning_effort") !== expected.reasoningEffort) agentModelFailures.push(agent);
-		agentTierValues.push(rootTomlString(text, "service_tier"));
-	} catch {
-		agentModelFailures.push(agent);
+	const overrides = readPreservedRootOverrides(config);
+	const fast = readManagedFastMode(config);
+	const max = readManagedMaxSubagents(config);
+	checks.push(plan === void 0 ? check("routes", "error", "route-plan-missing", "Managed route plan metadata is missing.", "Reinstall HolyCodex.") : check("routes", "ok", "routes-ready", `${plan} routes are active${max.configured ? ` with max-subagents=${max.value ?? "invalid"}` : ""}.`));
+	checks.push(overrides.model || overrides.reasoningEffort ? check("root-overrides", "ok", "root-overrides-preserved", "Intentional Root model or reasoning overrides are preserved and healthy.") : check("root-overrides", "ok", "root-managed-defaults", "Root uses managed route defaults."));
+	if (plan !== void 0 && fast === void 0) checks.push(check("fast", "warning", "fast-metadata-missing", "Fast metadata is missing; doctor will not guess a service tier.", "Reinstall with an explicit Fast mode."));
+	if (plan !== void 0) for (const agent of AGENTS) {
+		const source = await readFile(join(agentRoot, `${agent}.toml`), "utf8").catch(() => "");
+		const expected = MODEL_ROUTING_PLANS[plan].agents[agent];
+		const overridden = rootTomlString(source, "model") !== expected.model || rootTomlString(source, "model_reasoning_effort") !== expected.reasoningEffort;
+		checks.push(check(`agent-${agent}`, "ok", overridden ? "agent-override-preserved" : "agent-managed-default", overridden ? `${agent} has an intentional healthy route override.` : `${agent} uses managed route defaults.`));
 	}
-	checks.push(agentModelFailures.length === 0 ? check("agent-models", "ok", "agent-models-ready", `Specialist models match the ${plan ?? "unknown"} routing plan.`) : check("agent-models", "error", "agent-models-stale", `Agent model configuration is stale for ${agentModelFailures.join(", ")}.`, "Reinstall HolyCodex."));
-	const expectedAgentTier = managedFastMode === "standard" ? "default" : "fast";
-	if (agentTierValues.some((value) => value !== void 0)) checks.push(agentTierValues.every((value) => value === expectedAgentTier) ? check("agent-service-tiers", "ok", "agent-service-tiers-ready", `Specialist service tiers use ${expectedAgentTier}.`) : check("agent-service-tiers", "error", "agent-service-tiers-stale", `Specialist service tiers must use ${expectedAgentTier}.`, "Reinstall HolyCodex."));
+	for (const key of COMPATIBILITY_KEYS) if (config.includes(key.split(".")[1] ?? key)) checks.push(check(`compat-${key}`, "warning", "compatibility-sensitive-key", `${key} is compatibility-sensitive and isolated from supported managed Codex keys.`));
 	return {
-		healthy: !checks.some((item) => item.status === "error"),
-		autonomy: mode,
+		healthy: checks.every((item) => item.status !== "error"),
+		autonomy: autonomy(config),
 		checks
 	};
 }
@@ -6363,6 +6285,7 @@ var defaultRuntime = {
 	gitBash: resolveGitBashForCurrentProcess,
 	runProcess: runManagedProcess
 };
+var BACKUP_RETENTION = 5;
 function paths(home = process.env.CODEX_HOME ?? join(homedir(), ".codex")) {
 	const marketplaceCache = join(home, "plugins", "cache", "holycodex");
 	const cacheRoot = join(marketplaceCache, "holycodex");
@@ -6394,39 +6317,63 @@ async function install(options, runtime = defaultRuntime) {
 	const plan = options.plan ?? "plus";
 	const target = paths();
 	const root = backupRoot();
+	const configBackup = await backup(target.config, root);
+	const cacheBackup = await backup(target.marketplaceCache, root);
+	const agentsBackup = await backup(target.agents, root);
 	const backups = [
-		await backup(target.config, root),
-		await backup(target.marketplaceCache, root),
-		await backup(target.agents, root),
+		configBackup,
+		cacheBackup,
+		agentsBackup,
 		...await Promise.all(target.legacy.map((path) => backup(path, root)))
 	].filter((path) => path !== void 0);
 	const existingConfig = await readText(target.config);
 	const previousPlan = readManagedPlan(existingConfig);
 	const fastMode = options.fast ?? "standard";
 	const config = installConfig(existingConfig, options.autonomy, runtime.platform, plan, options.maxSubagents, fastMode);
-	await atomicWrite(target.config, config);
-	await rm(target.cache, {
-		recursive: true,
-		force: true
-	});
-	await mkdir(dirname(target.cache), { recursive: true });
-	await cp(pluginRoot, target.cache, { recursive: true });
-	await writePlatformPlugin(target.cache, runtime.platform, plan, fastMode);
 	const existingAgentPreferences = await readAgentPreferences(target.agents, previousPlan);
-	await rm(target.agents, {
-		recursive: true,
-		force: true
-	});
-	await cp(join(pluginRoot, "agents"), target.agents, { recursive: true });
-	await writeInstalledAgents(target.agents, runtime.platform, plan, fastMode);
-	await preserveAgentPreferences(target.agents, existingAgentPreferences, plan, fastMode);
+	const staging = await mkdtemp(join(tmpdir(), "holycodex-stage-"));
+	const stagedCache = join(staging, "cache");
+	const stagedAgents = join(staging, "agents");
+	await cp(pluginRoot, stagedCache, { recursive: true });
+	await writeInstalledAgents(join(stagedCache, "agents"), runtime.platform, plan, fastMode);
+	await cp(join(pluginRoot, "agents"), stagedAgents, { recursive: true });
+	await writeInstalledAgents(stagedAgents, runtime.platform, plan, fastMode);
+	await preserveAgentPreferences(stagedAgents, existingAgentPreferences, plan, fastMode);
+	await validateStaging(stagedCache, stagedAgents);
 	const removedLegacy = [];
-	for (const path of target.legacy) {
-		if (!await exists(path)) continue;
-		await rm(path, { recursive: true });
-		removedLegacy.push(path);
+	let codexSecurity;
+	try {
+		await atomicWrite(target.config, config);
+		await rm(target.cache, {
+			recursive: true,
+			force: true
+		});
+		await mkdir(dirname(target.cache), { recursive: true });
+		await cp(stagedCache, target.cache, { recursive: true });
+		await rm(target.agents, {
+			recursive: true,
+			force: true
+		});
+		await cp(stagedAgents, target.agents, { recursive: true });
+		for (const path of target.legacy) {
+			if (!await exists(path)) continue;
+			await rm(path, { recursive: true });
+			removedLegacy.push(path);
+		}
+		codexSecurity = await installCodexSecurity(runtime.runProcess, runtime.platform, process.env);
+		await removeObsoleteVersionCaches(target.cacheRoot);
+	} catch (error) {
+		await restoreTarget(target.config, configBackup);
+		await restoreTarget(target.marketplaceCache, cacheBackup);
+		await restoreTarget(target.agents, agentsBackup);
+		throw error;
+	} finally {
+		await rm(staging, {
+			recursive: true,
+			force: true
+		});
 	}
-	const codexSecurity = await installCodexSecurity(runtime.runProcess, runtime.platform, process.env);
+	await pruneBackupHistory();
 	return {
 		action: "install",
 		changed: [
@@ -6441,6 +6388,40 @@ async function install(options, runtime = defaultRuntime) {
 		...options.maxSubagents === void 0 ? {} : { maxSubagents: options.maxSubagents }
 	};
 }
+async function validateStaging(cache, agents) {
+	const required = [
+		join(cache, ".codex-plugin", "plugin.json"),
+		join(cache, "skills", "context7-cli", "SKILL.md"),
+		join(cache, "runtime", "lsp.js"),
+		...AGENTS.map((agent) => join(agents, `${agent}.toml`))
+	];
+	const missing = [];
+	for (const path of required) if (!await exists(path)) missing.push(path);
+	if (missing.length > 0) throw new Error(`Staged HolyCodex installation is incomplete: ${missing.join(", ")}`);
+}
+async function restoreTarget(target, source) {
+	await rm(target, {
+		recursive: true,
+		force: true
+	});
+	if (source !== void 0) await cp(source, target, { recursive: true });
+}
+async function removeObsoleteVersionCaches(cacheRoot) {
+	if (!await exists(cacheRoot)) return;
+	for (const entry of await readdir(cacheRoot)) if (entry !== "0.11.2") await rm(join(cacheRoot, entry), {
+		recursive: true,
+		force: true
+	});
+}
+async function pruneBackupHistory() {
+	const root = join(tmpdir(), "holycodex-backups");
+	if (!await exists(root)) return;
+	const entries = (await readdir(root)).sort().reverse();
+	await Promise.allSettled(entries.slice(BACKUP_RETENTION, 6).map((entry) => rm(join(root, entry), {
+		recursive: true,
+		force: true
+	})));
+}
 var AGENT_MANAGED_KEYS = /* @__PURE__ */ new Set([
 	"model",
 	"model_reasoning_effort",
@@ -6448,7 +6429,6 @@ var AGENT_MANAGED_KEYS = /* @__PURE__ */ new Set([
 	"service_tier"
 ]);
 var AGENT_BUNDLED_KEYS = /* @__PURE__ */ new Set(["description", "developer_instructions"]);
-var COMPACT_WINDOWS_SHELL_POLICY = /^On native Windows, resolve `mcp__git_bash__run` before shell use;[^\r\n]*never use PowerShell\/cmd\.\r?\n\r?\n/m;
 async function readAgentPreferences(root, previousPlan) {
 	const preferences = {};
 	await Promise.all(AGENTS.map(async (agent) => {
@@ -6513,26 +6493,27 @@ function mergeCustomAgentSettings(input, custom) {
 	if (custom.tables !== void 0 && !output.includes(custom.tables)) output = `${output.trimEnd()}\n\n${custom.tables}`;
 	return `${output.trimEnd()}\n`;
 }
-async function writePlatformPlugin(root, platform, plan, fastMode) {
-	await atomicWrite(join(root, ".mcp.json"), `${JSON.stringify({ mcpServers: effectiveMcpServers(platform) }, null, 2)}\n`);
-	await writeInstalledAgents(join(root, "agents"), platform, plan, fastMode);
-}
 async function writeInstalledAgents(root, platform, plan, fastMode) {
 	await Promise.all(AGENTS.map(async (agent) => {
 		const path = join(root, `${agent}.toml`);
 		const route = MODEL_ROUTING_PLANS[plan].agents[agent];
 		let source = await readText(path);
+		source = composeAgentPolicies(source, platform);
 		source = replaceTomlString(source, "model", route.model);
 		source = replaceTomlString(source, "model_reasoning_effort", route.reasoningEffort);
 		source = replaceTomlString(source, "model_verbosity", "low");
 		source = replaceOrAppendTomlString(source, "service_tier", fastMode === "standard" ? "default" : "fast");
-		if (platform === "win32") {
-			await atomicWrite(path, source);
-			return;
-		}
-		await atomicWrite(path, source.replace(`${WINDOWS_SHELL_POLICY}\r\n\r\n`, "").replace(`${WINDOWS_SHELL_POLICY}\n\n`, "").replace(COMPACT_WINDOWS_SHELL_POLICY, ""));
+		await atomicWrite(path, source);
 	}));
 }
+function composeAgentPolicies(input, platform) {
+	const policy = [
+		LITE_WRITING_POLICY,
+		CONTEXT7_POLICY,
+		...platform === "win32" ? [WINDOWS_SHELL_POLICY] : []
+	].join("\n\n");
+	return input.replace(/(developer_instructions\s*=\s*"""\r?\n)/, `$1${policy}\n\n`);
+}
 /** Provides cleanup. */
 async function cleanup(_options) {
 	const target = paths();
@@ -6652,88 +6633,39 @@ function renderNotice(kind, message, color) {
 //#endregion
 //#region packages/cli/src/cli.ts
 async function main() {
-	const args = process$1.argv.slice(2);
+	const parsed = parseCliArguments(process$1.argv.slice(2));
 	const stdoutColor = supportsColor(process$1.stdout.isTTY, process$1.env.NO_COLOR);
 	const stderrColor = supportsColor(process$1.stderr.isTTY, process$1.env.NO_COLOR);
-	const command = args.find((arg, index) => !arg.startsWith("-") && args[index - 1] !== "--plan" && args[index - 1] !== "--max-subagents");
-	if (args.includes("--help") || args.includes("-h") || args.length === 0) {
-		process$1.stdout.write(command === "install" ? renderInstallHelp(VERSION, stdoutColor) : renderHelp(VERSION, stdoutColor));
+	if (parsed.action === "help") {
+		process$1.stdout.write(parsed.command === "install" ? renderInstallHelp(VERSION, stdoutColor) : renderHelp(VERSION, stdoutColor));
 		return;
 	}
-	if (args.includes("--version") || args.includes("-v")) {
+	if (parsed.action === "version") {
 		process$1.stdout.write(`${VERSION}\n`);
 		return;
 	}
-	if (args.flatMap((arg, index) => arg === "--plan" ? [index] : []).length > 1) throw new Error("--plan may be specified only once.");
-	const planFlagIndex = args.indexOf("--plan");
-	const planValue = planFlagIndex < 0 ? DEFAULT_PLAN : args[planFlagIndex + 1];
-	if (planValue === void 0 || planValue.startsWith("-") || planValue === command) throw new Error(`Missing --plan value. Valid plans: ${PLAN_NAMES.join(", ")}.`);
-	const parsedPlan = PlanNameSchema.safeParse(planValue);
-	if (!parsedPlan.success) throw new Error(`Unknown plan: ${planValue}. Valid plans: ${PLAN_NAMES.join(", ")}.`);
-	const plan = parsedPlan.data;
-	if (args.flatMap((arg, index) => arg === "--max-subagents" ? [index] : []).length > 1) throw new Error("--max-subagents may be specified only once.");
-	const maxSubagentsIndex = args.indexOf("--max-subagents");
-	const maxSubagentsValue = maxSubagentsIndex < 0 ? void 0 : args[maxSubagentsIndex + 1];
-	if (maxSubagentsIndex >= 0 && (maxSubagentsValue === void 0 || maxSubagentsValue.startsWith("--") || maxSubagentsValue === command)) throw new Error("Missing --max-subagents value. Expected a nonnegative integer.");
-	if (maxSubagentsValue !== void 0 && !/^\d+$/.test(maxSubagentsValue)) throw new Error(`Invalid --max-subagents value: ${maxSubagentsValue}. Expected a nonnegative integer.`);
-	const maxSubagents = maxSubagentsValue === void 0 ? void 0 : Number(maxSubagentsValue);
-	const autonomyFlags = args.filter((arg) => [
-		"--codex-autonomous",
-		"--no-codex-autonomous",
-		"--dangerous-codex-autonomous"
-	].includes(arg));
-	if (autonomyFlags.length > 1) {
-		process$1.stderr.write(renderError(`Conflicting autonomy flags: ${autonomyFlags.join(", ")}`, stderrColor));
-		process$1.exitCode = 1;
-		return;
-	}
-	const fastFlags = args.filter((arg) => [
-		"--fast",
-		"--fast-all",
-		"--no-fast"
-	].includes(arg));
-	if (fastFlags.length > 1) {
-		process$1.stderr.write(renderError(`Conflicting fast flags: ${fastFlags.join(", ")}`, stderrColor));
-		process$1.exitCode = 1;
-		return;
-	}
-	const autonomy = args.includes("--dangerous-codex-autonomous") ? {
-		requested: true,
-		mode: "dangerous"
-	} : args.includes("--codex-autonomous") ? {
-		requested: true,
-		mode: "autonomous"
-	} : args.includes("--no-codex-autonomous") ? {
-		requested: true,
-		mode: "default"
-	} : { requested: false };
 	const options = {
-		autonomy,
-		json: args.includes("--json"),
-		fast: args.includes("--fast-all") ? "fast-all" : args.includes("--fast") ? "fast" : "standard",
-		plan,
-		...maxSubagents === void 0 ? {} : { maxSubagents }
+		autonomy: parsed.autonomy,
+		fast: parsed.fast,
+		json: parsed.json,
+		plan: parsed.plan,
+		...parsed.maxSubagents === void 0 ? {} : { maxSubagents: parsed.maxSubagents }
 	};
-	if (command === "doctor") {
+	if (parsed.command === "doctor") {
 		const result = await doctor();
-		process$1.stdout.write(options.json ? `${JSON.stringify(result)}\n` : renderDoctor(result, stdoutColor));
+		process$1.stdout.write(parsed.json ? `${JSON.stringify(result)}\n` : renderDoctor(result, stdoutColor));
 		if (!result.healthy) process$1.exitCode = 1;
 		return;
 	}
-	if (autonomy.requested && autonomy.mode === "dangerous") process$1.stderr.write(renderNotice("warning", "Dangerous autonomy disables approvals and filesystem sandboxing.", stderrColor));
-	const result = command === "install" ? await install(options) : command === "cleanup" ? await cleanup(options) : void 0;
-	if (result === void 0) {
-		process$1.stderr.write(renderError(`Unknown command: ${command ?? args[0] ?? ""}`, stderrColor));
-		process$1.exitCode = 1;
-		return;
-	}
-	process$1.stdout.write(options.json ? `${JSON.stringify(result)}\n` : renderRunResult(result, stdoutColor));
+	if (parsed.autonomy.requested && parsed.autonomy.mode === "dangerous") process$1.stderr.write(renderNotice("warning", "Dangerous autonomy disables approvals and filesystem sandboxing.", stderrColor));
+	const result = parsed.command === "install" ? await install(options) : await cleanup(options);
+	process$1.stdout.write(parsed.json ? `${JSON.stringify(result)}\n` : renderRunResult(result, stdoutColor));
 }
 try {
 	await main();
 } catch (error) {
-	const stderrColor = supportsColor(process$1.stderr.isTTY, process$1.env.NO_COLOR);
-	process$1.stderr.write(renderError(formatCliError(error), stderrColor));
+	const color = supportsColor(process$1.stderr.isTTY, process$1.env.NO_COLOR);
+	process$1.stderr.write(renderError(formatCliError(error), color));
 	process$1.exitCode = 1;
 }
 //#endregion

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "holycodex",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "Lean Codex-only agent toolkit installer and doctor",
   "keywords": [
     "agents",
     "chatgpt",
     "codex",
-    "mcp"
+    "developer-tools"
   ],
   "homepage": "https://github.com/davidbasilefilho/holycodex#readme",
   "bugs": {
@@ -39,10 +39,10 @@
     "prepack": "vp run --workspace-root build"
   },
   "dependencies": {
-    "@holycodex/plugin": "0.11.0",
+    "@holycodex/plugin": "0.11.2",
     "zod": "^4.4.3"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=26 <27"
   }
 }