holycodex 0.11.0 → 0.11.3-dev.155.1

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,6 +1906,98 @@ function handleIntersectionResults(result, left, right) {
 	result.value = merged.data;
 	return result;
 }
+var $ZodTuple = /*@__PURE__*/ $constructor("$ZodTuple", (inst, def) => {
+	$ZodType.init(inst, def);
+	const items = def.items;
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!Array.isArray(input)) {
+			payload.issues.push({
+				input,
+				inst,
+				expected: "tuple",
+				code: "invalid_type"
+			});
+			return payload;
+		}
+		payload.value = [];
+		const proms = [];
+		const optinStart = getTupleOptStart(items, "optin");
+		const optoutStart = getTupleOptStart(items, "optout");
+		if (!def.rest) {
+			if (input.length < optinStart) {
+				payload.issues.push({
+					code: "too_small",
+					minimum: optinStart,
+					inclusive: true,
+					input,
+					inst,
+					origin: "array"
+				});
+				return payload;
+			}
+			if (input.length > items.length) payload.issues.push({
+				code: "too_big",
+				maximum: items.length,
+				inclusive: true,
+				input,
+				inst,
+				origin: "array"
+			});
+		}
+		const itemResults = new Array(items.length);
+		for (let i = 0; i < items.length; i++) {
+			const r = items[i]._zod.run({
+				value: input[i],
+				issues: []
+			}, ctx);
+			if (r instanceof Promise) proms.push(r.then((rr) => {
+				itemResults[i] = rr;
+			}));
+			else itemResults[i] = r;
+		}
+		if (def.rest) {
+			let i = items.length - 1;
+			const rest = input.slice(items.length);
+			for (const el of rest) {
+				i++;
+				const result = def.rest._zod.run({
+					value: el,
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((r) => handleTupleResult(r, payload, i)));
+				else handleTupleResult(result, payload, i);
+			}
+		}
+		if (proms.length) return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input, optoutStart));
+		return handleTupleResults(itemResults, payload, items, input, optoutStart);
+	};
+});
+function getTupleOptStart(items, key) {
+	for (let i = items.length - 1; i >= 0; i--) if (items[i]._zod[key] !== "optional") return i + 1;
+	return 0;
+}
+function handleTupleResult(result, final, index) {
+	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
+	final.value[index] = result.value;
+}
+function handleTupleResults(itemResults, final, items, input, optoutStart) {
+	for (let i = 0; i < items.length; i++) {
+		const r = itemResults[i];
+		const isPresent = i < input.length;
+		if (r.issues.length) {
+			if (!isPresent && i >= optoutStart) {
+				final.value.length = i;
+				break;
+			}
+			final.issues.push(...prefixIssues(i, r.issues));
+		}
+		final.value[i] = r.value;
+	}
+	for (let i = final.value.length - 1; i >= input.length; i--) if (items[i]._zod.optout === "optional" && final.value[i] === void 0) final.value.length = i;
+	else break;
+	return final;
+}
 var $ZodRecord = /*@__PURE__*/ $constructor("$ZodRecord", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
@@ -3281,6 +3372,44 @@ 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 tupleProcessor = (schema, ctx, _json, params) => {
+	const json = _json;
+	const def = schema._zod.def;
+	json.type = "array";
+	const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
+	const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
+	const prefixItems = def.items.map((x, i) => process$2(x, ctx, {
+		...params,
+		path: [
+			...params.path,
+			prefixPath,
+			i
+		]
+	}));
+	const rest = def.rest ? process$2(def.rest, ctx, {
+		...params,
+		path: [
+			...params.path,
+			restPath,
+			...ctx.target === "openapi-3.0" ? [def.items.length] : []
+		]
+	}) : null;
+	if (ctx.target === "draft-2020-12") {
+		json.prefixItems = prefixItems;
+		if (rest) json.items = rest;
+	} else if (ctx.target === "openapi-3.0") {
+		json.items = { anyOf: prefixItems };
+		if (rest) json.items.anyOf.push(rest);
+		json.minItems = prefixItems.length;
+		if (!rest) json.maxItems = prefixItems.length;
+	} else {
+		json.items = prefixItems;
+		if (rest) json.additionalItems = rest;
+	}
+	const { minimum, maximum } = schema._zod.bag;
+	if (typeof minimum === "number") json.minItems = minimum;
+	if (typeof maximum === "number") json.maxItems = maximum;
+};
 var recordProcessor = (schema, ctx, _json, params) => {
 	const json = _json;
 	const def = schema._zod.def;
@@ -3965,14 +4094,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,6 +4131,24 @@ function intersection(left, right) {
 		right
 	});
 }
+var ZodTuple = /*@__PURE__*/ $constructor("ZodTuple", (inst, def) => {
+	$ZodTuple.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => tupleProcessor(inst, ctx, json, params);
+	inst.rest = (rest) => inst.clone({
+		...inst._zod.def,
+		rest
+	});
+});
+function tuple(items, _paramsOrRest, _params) {
+	const hasRest = _paramsOrRest instanceof $ZodType;
+	return new ZodTuple({
+		type: "tuple",
+		items,
+		rest: hasRest ? _paramsOrRest : null,
+		...normalizeParams(hasRest ? _params : _paramsOrRest)
+	});
+}
 var ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
 	$ZodRecord.init(inst, def);
 	ZodType.init(inst, def);
@@ -4252,13 +4391,13 @@ function superRefine(fn, params) {
 }
 //#endregion
 //#region packages/cli/src/catalog.ts
-var VERSION = "0.11.0";
+var VERSION = "0.11.3-dev.155.1";
 var SKILLS = [
 	"ast-grep",
 	"babysit-ci",
-	"caveman",
 	"code-review",
 	"compress",
+	"context7-cli",
 	"debugging",
 	"handoff",
 	"lsp",
@@ -4268,7 +4407,8 @@ var SKILLS = [
 	"programming",
 	"refactor",
 	"remove-slop",
-	"rules"
+	"rules",
+	"workflows"
 ];
 var AGENTS = _enum([
 	"explorer",
@@ -4310,6 +4450,46 @@ var ModelRouteSchema = discriminatedUnion("model", [
 		reasoningEffort: ReasoningEffortSchema
 	})
 ]);
+var WORKFLOW_STAGES = [
+	"analysis",
+	"research",
+	"implementation",
+	"verification"
+];
+var WorkflowStageSchema = _enum(WORKFLOW_STAGES);
+var WorkflowLimitsSchema = strictObject({
+	concurrency: number().int().positive(),
+	totalCalls: number().int().positive(),
+	workflowDepth: number().int().positive(),
+	retries: number().int().nonnegative(),
+	loopIterations: number().int().positive(),
+	fanOut: number().int().positive(),
+	maxConcurrency: number().int().positive(),
+	maxCalls: number().int().positive(),
+	maxRetries: number().int().nonnegative()
+});
+var WorkflowPolicySchema = strictObject({
+	permittedRoutes: strictObject({
+		explorer: record(WorkflowStageSchema, array(ModelRouteSchema).min(1)),
+		librarian: record(WorkflowStageSchema, array(ModelRouteSchema).min(1)),
+		worker: record(WorkflowStageSchema, array(ModelRouteSchema).min(1))
+	}),
+	verbosity: literal("low"),
+	serviceTiers: tuple([literal("default"), literal("fast")]),
+	limits: WorkflowLimitsSchema,
+	projectedUsage: strictObject({
+		standard: number().positive(),
+		fast: number().positive()
+	}),
+	runtime: strictObject({
+		maxSeconds: number().int().positive(),
+		maxRuntimeMs: number().int().positive()
+	}),
+	softSizeGuidance: strictObject({
+		maxInputTokens: number().int().positive(),
+		maxScriptBytes: number().int().positive()
+	})
+});
 var RoutingPresetSchema = strictObject({
 	root: ModelRouteSchema,
 	agents: strictObject({
@@ -4317,10 +4497,7 @@ var RoutingPresetSchema = strictObject({
 		librarian: ModelRouteSchema,
 		worker: ModelRouteSchema
 	}),
-	usage: strictObject({
-		maxSubagents: number().int().nonnegative(),
-		maxDepth: literal(1)
-	})
+	workflow: WorkflowPolicySchema
 });
 var ModelRoutingPlansSchema = strictObject({
 	go: RoutingPresetSchema,
@@ -4330,6 +4507,31 @@ var ModelRoutingPlansSchema = strictObject({
 	"pro-5x": RoutingPresetSchema,
 	"pro-20x": RoutingPresetSchema
 });
+function workflowFor(agents, limits, projectedUsage, maxSeconds, maxInputTokens) {
+	return {
+		permittedRoutes: Object.fromEntries(AGENTS.map((agent) => [agent, Object.fromEntries(WORKFLOW_STAGES.map((stage) => [stage, [agents[agent]]]))])),
+		verbosity: "low",
+		serviceTiers: ["default", "fast"],
+		limits: {
+			...limits,
+			maxConcurrency: limits.concurrency,
+			maxCalls: limits.totalCalls,
+			maxRetries: limits.retries
+		},
+		projectedUsage: {
+			standard: projectedUsage,
+			fast: projectedUsage * 2
+		},
+		runtime: {
+			maxSeconds,
+			maxRuntimeMs: maxSeconds * 1e3
+		},
+		softSizeGuidance: {
+			maxInputTokens,
+			maxScriptBytes: Math.min(maxInputTokens, 4 * 1024 * 1024)
+		}
+	};
+}
 var DEFAULT_PLAN = "plus";
 var MODEL_ROUTING_PLANS = ModelRoutingPlansSchema.parse({
 	go: {
@@ -4351,10 +4553,27 @@ var MODEL_ROUTING_PLANS = ModelRoutingPlansSchema.parse({
 				reasoningEffort: "high"
 			}
 		},
-		usage: {
-			maxSubagents: 0,
-			maxDepth: 1
-		}
+		workflow: workflowFor({
+			explorer: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "high"
+			},
+			librarian: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "high"
+			},
+			worker: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "high"
+			}
+		}, {
+			concurrency: 1,
+			totalCalls: 4,
+			workflowDepth: 2,
+			retries: 0,
+			loopIterations: 1,
+			fanOut: 1
+		}, 4, 120, 2e4)
 	},
 	"plus-low": {
 		root: {
@@ -4375,10 +4594,27 @@ var MODEL_ROUTING_PLANS = ModelRoutingPlansSchema.parse({
 				reasoningEffort: "high"
 			}
 		},
-		usage: {
-			maxSubagents: 2,
-			maxDepth: 1
-		}
+		workflow: workflowFor({
+			explorer: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "high"
+			},
+			librarian: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "high"
+			},
+			worker: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "high"
+			}
+		}, {
+			concurrency: 2,
+			totalCalls: 8,
+			workflowDepth: 3,
+			retries: 1,
+			loopIterations: 2,
+			fanOut: 2
+		}, 8, 300, 3e4)
 	},
 	plus: {
 		root: {
@@ -4399,10 +4635,27 @@ var MODEL_ROUTING_PLANS = ModelRoutingPlansSchema.parse({
 				reasoningEffort: "high"
 			}
 		},
-		usage: {
-			maxSubagents: 2,
-			maxDepth: 1
-		}
+		workflow: workflowFor({
+			explorer: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "high"
+			},
+			librarian: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "high"
+			},
+			worker: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "high"
+			}
+		}, {
+			concurrency: 3,
+			totalCalls: 16,
+			workflowDepth: 4,
+			retries: 2,
+			loopIterations: 3,
+			fanOut: 3
+		}, 16, 600, 5e4)
 	},
 	"plus-high": {
 		root: {
@@ -4423,10 +4676,27 @@ var MODEL_ROUTING_PLANS = ModelRoutingPlansSchema.parse({
 				reasoningEffort: "xhigh"
 			}
 		},
-		usage: {
-			maxSubagents: 2,
-			maxDepth: 1
-		}
+		workflow: workflowFor({
+			explorer: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "high"
+			},
+			librarian: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "high"
+			},
+			worker: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "xhigh"
+			}
+		}, {
+			concurrency: 4,
+			totalCalls: 24,
+			workflowDepth: 5,
+			retries: 3,
+			loopIterations: 4,
+			fanOut: 4
+		}, 24, 900, 7e4)
 	},
 	"pro-5x": {
 		root: {
@@ -4447,10 +4717,27 @@ var MODEL_ROUTING_PLANS = ModelRoutingPlansSchema.parse({
 				reasoningEffort: "xhigh"
 			}
 		},
-		usage: {
-			maxSubagents: 2,
-			maxDepth: 1
-		}
+		workflow: workflowFor({
+			explorer: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "high"
+			},
+			librarian: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "high"
+			},
+			worker: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "xhigh"
+			}
+		}, {
+			concurrency: 6,
+			totalCalls: 40,
+			workflowDepth: 6,
+			retries: 3,
+			loopIterations: 5,
+			fanOut: 5
+		}, 40, 1200, 1e5)
 	},
 	"pro-20x": {
 		root: {
@@ -4471,12 +4758,31 @@ var MODEL_ROUTING_PLANS = ModelRoutingPlansSchema.parse({
 				reasoningEffort: "max"
 			}
 		},
-		usage: {
-			maxSubagents: 2,
-			maxDepth: 1
-		}
+		workflow: workflowFor({
+			explorer: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "high"
+			},
+			librarian: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "high"
+			},
+			worker: {
+				model: "gpt-5.6-luna",
+				reasoningEffort: "max"
+			}
+		}, {
+			concurrency: 8,
+			totalCalls: 80,
+			workflowDepth: 8,
+			retries: 4,
+			loopIterations: 8,
+			fanOut: 8
+		}, 80, 2400, 15e4)
 	}
 });
+Object.fromEntries(PLAN_NAMES.map((plan) => [plan, MODEL_ROUTING_PLANS[plan].workflow]));
+Object.fromEntries(PLAN_NAMES.map((plan) => [plan, MODEL_ROUTING_PLANS[plan].workflow.limits]));
 MODEL_ROUTING_PLANS[DEFAULT_PLAN].root;
 MODEL_ROUTING_PLANS[DEFAULT_PLAN].agents;
 var LEGACY_MANAGED_AGENT_MODEL_HISTORY = {
@@ -4739,37 +5045,125 @@ var GENERATED_RUNTIMES = [
 	"git-bash.js",
 	"git-bash-resolver.js",
 	"LICENSE-LSP-MIT.txt",
+	"LICENSE-QUICKJS-EMSCRIPTEN-MIT.txt",
 	"lsp.js",
-	"mcp-stdio-core.js",
-	"rules.js"
+	"rules.js",
+	"workflow.js",
+	"workflow-evaluator.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",
+	"--verbose"
+]);
+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 === "-v") {
+			if (!allowed.has("--verbose")) throw new Error(`Option -v is not valid for ${command}.`);
+			if (values.has("--verbose")) throw new Error("Repeated option: --verbose");
+			values.set("--verbose", true);
+			continue;
+		}
+		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,
+		verbose: values.has("--verbose")
+	};
+}
+function base(action) {
+	return {
+		action,
+		json: false,
+		plan: DEFAULT_PLAN,
+		autonomy: { requested: false },
+		fast: "standard",
+		verbose: false
+	};
+}
+//#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 +5244,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 +5309,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 +5334,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 +5366,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", [
@@ -5224,7 +5624,7 @@ var ORIGINAL_ROOT = "# holycodex original root: ";
 var ORIGINAL_TABLE_KEY = "# holycodex original table key: ";
 var PLAN_PREFIX = "# holycodex plan: ";
 var FAST_MODE_PREFIX = "# holycodex fast: ";
-var MAX_SUBAGENTS_PREFIX = "# holycodex max-subagents: ";
+var WORKFLOW_POLICY_PREFIX = "# holycodex workflow-policy: ";
 var OLD_NAMESPACES = [
 	"marketplaces.sisyphuslabs",
 	"plugins.\"omo@sisyphuslabs\"",
@@ -5311,6 +5711,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];
@@ -5336,38 +5743,57 @@ function readManagedFastMode(input) {
 	const value = new RegExp(`^${FAST_MODE_PREFIX}(.+)$`, "m").exec(input)?.[1]?.trim();
 	return FastModeSchema.safeParse(value).data;
 }
-/** Reads an explicit managed direct-subagent override. */
-function readManagedMaxSubagents(input) {
-	const raw = new RegExp(`^${MAX_SUBAGENTS_PREFIX}(.*)$`, "m").exec(input)?.[1]?.trim();
-	if (raw === void 0) return { configured: false };
-	if (!/^\d+$/.test(raw)) return { configured: true };
-	return {
-		configured: true,
-		value: Number(raw)
-	};
+/** Reads the plan-authoritative workflow policy metadata from managed configuration. */
+function readManagedWorkflowPolicy(input) {
+	const raw = new RegExp(`^${WORKFLOW_POLICY_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(.+)$`, "m").exec(input)?.[1];
+	if (raw === void 0) return void 0;
+	try {
+		const value = JSON.parse(raw);
+		if (typeof value !== "object" || value === null) return void 0;
+		const record = value;
+		const plan = PLAN_NAMES.find((name) => name === record.plan);
+		const limits = record.limits;
+		const usage = record.projectedUsage;
+		const runtime = record.runtime;
+		const size = record.softSizeGuidance;
+		if (plan === void 0 || typeof limits !== "object" || limits === null || typeof usage !== "object" || usage === null || typeof runtime !== "object" || runtime === null || typeof size !== "object" || size === null) return void 0;
+		return {
+			plan,
+			limits,
+			projectedUsage: usage,
+			runtime,
+			softSizeGuidance: size
+		};
+	} catch {
+		return;
+	}
 }
 /** Identifies explicit Root route overrides preserved from active managed configuration. */
 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 +5804,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;
@@ -5395,7 +5825,7 @@ function mergedStatusLine(original) {
 	return `[${items.map((item) => JSON.stringify(item)).join(", ")}]`;
 }
 /** Installs config. */
-function installConfig(input, mode, _platform, plan = DEFAULT_PLAN, maxSubagents, fastMode = "standard") {
+function installConfig(input, mode, _platform, plan = DEFAULT_PLAN, _legacyMaxSubagents, fastMode = "standard") {
 	const request = normalizeRequestedAutonomy(mode);
 	const priorAutonomy = readAutonomyMetadata(input);
 	const previousOriginalRoot = readOriginalRootMetadata(input);
@@ -5416,6 +5846,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 +5857,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",
@@ -5439,79 +5871,143 @@ function installConfig(input, mode, _platform, plan = DEFAULT_PLAN, maxSubagents
 	const hasModel = /^\s*model\s*=/m.test(preservedRoot);
 	const hasEffort = /^\s*model_reasoning_effort\s*=/m.test(preservedRoot);
 	const rootRoute = MODEL_ROUTING_PLANS[plan].root;
-	const effectiveMaxSubagents = maxSubagents ?? MODEL_ROUTING_PLANS[plan].usage.maxSubagents;
 	const model = hasModel ? "" : `model = "${rootRoute.model}"\n`;
 	const effort = hasEffort ? "" : `model_reasoning_effort = "${rootRoute.reasoningEffort}"\n`;
 	const originalSource = previousOriginalRoot === void 0 ? priorAutonomy === void 0 && legacyGeneratedRoot === void 0 ? originalControlled : "" : removePermissionLines(previousOriginalRoot);
 	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 workflow = MODEL_ROUTING_PLANS[plan].workflow;
+	const rootBlock = `${START}\n${PLAN_PREFIX}${plan}\n${FAST_MODE_PREFIX}${fastMode}\n${WORKFLOW_POLICY_PREFIX}${JSON.stringify({
+		plan,
+		limits: workflow.limits,
+		projectedUsage: workflow.projectedUsage,
+		runtime: workflow.runtime,
+		softSizeGuidance: workflow.softSizeGuidance
+	})}\n${AUTONOMY_METADATA_PREFIX}${effectiveAutonomy}\n${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(workflow.limits.concurrency + 1)]]);
+	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 DOCTOR_LSP_IDLE_SHUTDOWN_MS = 1e3;
+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 +6019,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 +6028,93 @@ 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 tableBody(config, table) {
+	return new RegExp(`^\\s*\\[${table.replaceAll(".", "\\.")}]\\s*$([\\s\\S]*?)(?=^\\s*\\[|(?![\\s\\S]))`, "m").exec(config)?.[1];
 }
-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 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: String(DOCTOR_LSP_IDLE_SHUTDOWN_MS),
+		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 workflow = readManagedWorkflowPolicy(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} workflow policy is active with permitted stage routes.`));
+	checks.push(plan === void 0 || workflow === void 0 ? check("workflow", "error", "workflow-settings-missing", "Managed workflow settings are missing or invalid.", "Reinstall HolyCodex.") : JSON.stringify(workflow) === JSON.stringify({
+		plan,
+		limits: MODEL_ROUTING_PLANS[plan].workflow.limits,
+		projectedUsage: MODEL_ROUTING_PLANS[plan].workflow.projectedUsage,
+		runtime: MODEL_ROUTING_PLANS[plan].workflow.runtime,
+		softSizeGuidance: MODEL_ROUTING_PLANS[plan].workflow.softSizeGuidance
+	}) ? check("workflow", "ok", "workflow-settings-ready", `${plan} workflow limits, projected usage, runtime, and size guidance match the catalog.`) : check("workflow", "error", "workflow-settings-drift", `${plan} workflow settings do not match the authoritative catalog.`, "Reinstall HolyCodex."));
+	checks.push(missing.includes("runtime/workflow.js") ? check("workflow-runtime", "error", "workflow-runtime-missing", "The isolated workflow runtime is missing.", "Reinstall HolyCodex.") : check("workflow-runtime", "ok", "workflow-runtime-ready", "The isolated workflow runtime is present."));
+	const manifest = await readFile(join(pluginRoot, ".codex-plugin", "plugin.json"), "utf8").catch(() => "");
+	const mcpManifest = await access(join(pluginRoot, ".mcp.json")).then(() => true).catch(() => false);
+	checks.push(!mcpManifest && !manifest.includes("mcpServers") && !manifest.includes("MCP Tools") ? check("mcp", "ok", "mcp-free", "The installation does not declare MCP servers or tools.") : check("mcp", "error", "mcp-declared", "The installation declares MCP servers or tools.", "Reinstall HolyCodex from a MCP-free package."));
+	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
 	};
 }
@@ -5821,8 +6264,14 @@ function deduplicate(candidates) {
 }
 //#endregion
 //#region packages/cli/src/codex-security.ts
-var CODEX_SECURITY_PLUGIN = "codex-security@openai-curated";
-var CODEX_SECURITY_MARKETPLACE = "openai-curated";
+var CODEX_SECURITY_PLUGIN = {
+	id: "codex-security@openai-curated",
+	marketplace: "openai-curated"
+};
+var COMPUTER_USE_PLUGIN = {
+	id: "computer-use@openai-bundled",
+	marketplace: "openai-bundled"
+};
 var CODEX_PLUGIN_OPERATIONAL_TIMEOUT_MS = 15e3;
 var CODEX_PACKAGE_BOOTSTRAP_TIMEOUT_MS = 12e4;
 var MAX_CODEX_CATALOG_DIAGNOSTIC_CHARS = 256 * 1024;
@@ -5863,6 +6312,14 @@ var FATAL_POLICY_CODES = /* @__PURE__ */ new Set([
 ]);
 /** Installs or enables the official Codex Security plugin without failing HolyCodex installation. */
 async function installCodexSecurity(runProcess = runManagedProcess, platform = process.platform, env = process.env, options = {}) {
+	return installOfficialPlugin(CODEX_SECURITY_PLUGIN, runProcess, platform, env, options);
+}
+/** Installs or enables the official Computer Use plugin without failing HolyCodex installation. */
+async function installComputerUse(runProcess = runManagedProcess, platform = process.platform, env = process.env, options = {}) {
+	return installOfficialPlugin(COMPUTER_USE_PLUGIN, runProcess, platform, env, options);
+}
+/** Installs or enables one official Codex plugin through a verified catalog entry. */
+async function installOfficialPlugin(plugin, runProcess = runManagedProcess, platform = process.platform, env = process.env, options = {}) {
 	const runtimeFacts = options.runtimeFacts ?? (runProcess === runManagedProcess ? defaultCodexLauncherRuntimeFacts(platform) : void 0);
 	const candidates = createCodexLauncherCandidates({
 		...options.injected === void 0 ? {} : { injected: options.injected },
@@ -5882,7 +6339,7 @@ async function installCodexSecurity(runProcess = runManagedProcess, platform = p
 			continue;
 		}
 		if (installedOutcome.kind === "fatal") return skipped(installedOutcome.reason, attemptedLaunchers);
-		const installedPlugin = findPlugin(installedOutcome.catalog);
+		const installedPlugin = findPlugin(installedOutcome.catalog, plugin.id);
 		if (installedPlugin?.installed === true && installedPlugin.enabled === true) return {
 			status: "already-installed",
 			launcherSource: launcher.source
@@ -5900,7 +6357,7 @@ async function installCodexSecurity(runProcess = runManagedProcess, platform = p
 				continue;
 			}
 			if (catalogOutcome.kind === "fatal") return skipped(catalogOutcome.reason, attemptedLaunchers);
-			if (findPlugin(catalogOutcome.catalog) === void 0) {
+			if (findPlugin(catalogOutcome.catalog, plugin.id) === void 0) {
 				const marketplaceOutcome = inspectMarketplaceResult(await runCodexPlugin(runProcess, launcher, [
 					"plugin",
 					"marketplace",
@@ -5912,14 +6369,14 @@ async function installCodexSecurity(runProcess = runManagedProcess, platform = p
 					continue;
 				}
 				if (marketplaceOutcome.kind === "fatal") return skipped(marketplaceOutcome.reason, attemptedLaunchers);
-				fallbackReasons.push(marketplaceOutcome.marketplaces.includes(CODEX_SECURITY_MARKETPLACE) ? "plugin-not-offered" : "marketplace-unavailable");
+				fallbackReasons.push(marketplaceOutcome.marketplaces.includes(plugin.marketplace) ? "plugin-not-offered" : "marketplace-unavailable");
 				continue;
 			}
 		}
 		const addOutcome = inspectAddResult(await runCodexPlugin(runProcess, launcher, [
 			"plugin",
 			"add",
-			CODEX_SECURITY_PLUGIN,
+			plugin.id,
 			"--json"
 		], platform, env, "add"), launcher);
 		if (addOutcome.kind === "fallback") {
@@ -5937,7 +6394,7 @@ async function installCodexSecurity(runProcess = runManagedProcess, platform = p
 			continue;
 		}
 		if (verification.kind === "fatal") return skipped(verification.reason, attemptedLaunchers);
-		const verifiedPlugin = findPlugin(verification.catalog);
+		const verifiedPlugin = findPlugin(verification.catalog, plugin.id);
 		if (verifiedPlugin?.installed !== true || verifiedPlugin.enabled !== true) {
 			fallbackReasons.push("verification-failed");
 			continue;
@@ -6024,8 +6481,8 @@ function inspectMarketplaceResult(result, launcher) {
 		marketplaces
 	};
 }
-function findPlugin(catalog) {
-	return catalog.plugins.find(({ id }) => id === CODEX_SECURITY_PLUGIN);
+function findPlugin(catalog, pluginId) {
+	return catalog.plugins.find(({ id }) => id === pluginId);
 }
 function classifyFailure(result, launcher) {
 	if (result.error !== void 0) {
@@ -6363,6 +6820,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");
@@ -6390,43 +6848,87 @@ function assertGitBashReady(platform, resolution) {
 }
 /** Provides install. */
 async function install(options, runtime = defaultRuntime) {
+	notify(options, "prerequisites", "Checking prerequisites", "running");
 	assertGitBashReady(runtime.platform, runtime.gitBash());
+	notify(options, "prerequisites", "Checking prerequisites", "complete");
 	const plan = options.plan ?? "plus";
 	const target = paths();
 	const root = backupRoot();
+	notify(options, "backup", "Backing up existing installation", "running");
+	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);
+	notify(options, "backup", "Backing up existing installation", "complete", `${backups.length} saved`);
+	notify(options, "configuration", "Preparing configuration", "running");
 	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);
+	notify(options, "configuration", "Preparing configuration", "complete", plan);
+	notify(options, "staging", "Staging plugin and agent files", "running");
 	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);
+	notify(options, "staging", "Staging plugin and agent files", "complete");
+	notify(options, "validation", "Validating staged installation", "running");
+	await validateStaging(stagedCache, stagedAgents);
+	notify(options, "validation", "Validating staged installation", "complete");
 	const removedLegacy = [];
-	for (const path of target.legacy) {
-		if (!await exists(path)) continue;
-		await rm(path, { recursive: true });
-		removedLegacy.push(path);
+	let codexSecurity;
+	let computerUse;
+	try {
+		notify(options, "managed-files", "Installing managed files", "running");
+		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);
+		}
+		notify(options, "managed-files", "Installing managed files", "complete");
+		notify(options, "codex-security", "Installing Codex Security", "running");
+		codexSecurity = await installCodexSecurity(runtime.runProcess, runtime.platform, process.env);
+		notify(options, "codex-security", "Installing Codex Security", "complete", pluginProgressDetail(codexSecurity));
+		notify(options, "computer-use", "Installing Computer Use", "running");
+		computerUse = await installComputerUse(runtime.runProcess, runtime.platform, process.env);
+		notify(options, "computer-use", "Installing Computer Use", "complete", pluginProgressDetail(computerUse));
+		notify(options, "cleanup", "Removing obsolete caches", "running");
+		await removeObsoleteVersionCaches(target.cacheRoot);
+		notify(options, "cleanup", "Removing obsolete caches", "complete");
+	} 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: [
@@ -6438,9 +6940,55 @@ async function install(options, runtime = defaultRuntime) {
 		backups,
 		plan,
 		codexSecurity,
-		...options.maxSubagents === void 0 ? {} : { maxSubagents: options.maxSubagents }
+		computerUse
 	};
 }
+function notify(options, step, label, status, detail) {
+	options.onProgress?.({
+		step,
+		label,
+		status,
+		...detail === void 0 ? {} : { detail }
+	});
+}
+function pluginProgressDetail(result) {
+	if (result.status === "skipped") return `skipped: ${result.reason}`;
+	return result.launcherSource === void 0 ? result.status : `${result.status} via ${result.launcherSource}`;
+}
+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.3-dev.155.1") 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 +6996,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 +7060,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();
@@ -6596,17 +7144,21 @@ function renderHelp(version, color) {
 	const title = paint(color, `${BOLD}${CYAN}`, `HolyCodex ${version}`);
 	const section = (text) => paint(color, BOLD, text);
 	const muted = (text) => paint(color, DIM, text);
-	return `${title}\n${muted("Lean Codex toolkit installer and doctor")}\n\n${section("USAGE")}\n  holycodex <command> [options]\n\n${section("COMMANDS")}\n  install                         Install or update HolyCodex\n  cleanup                         Remove HolyCodex-owned state\n  doctor                          Diagnose installation and runtime\n\n${section("OPTIONS")}\n  --plan <plan>                   Model routing plan for install: ${PLAN_HELP}\n                                   Default: ${DEFAULT_PLAN}\n  --max-subagents <count>          Override concurrent direct subagents for install\n  --fast                          Use Fast for generated subagents only\n  --fast-all                      Use Fast for Root and generated subagents\n  --no-fast                       Use Standard for Root and generated subagents\n  -h, --help                      Show help\n  -v, --version                   Show version\n  --no-tui                        Accepted; commands remain noninteractive\n  --codex-autonomous              Never ask; keep workspace sandbox\n  --no-codex-autonomous           Safe interactive defaults\n  --dangerous-codex-autonomous    Never ask; disable filesystem sandbox\n  --json                          Print machine-readable output\n`;
+	return `${title}\n${muted("Lean Codex toolkit installer and doctor")}\n\n${section("USAGE")}\n  holycodex <command> [options]\n\n${section("COMMANDS")}\n  install                         Install or update HolyCodex\n  cleanup                         Remove HolyCodex-owned state\n  doctor                          Diagnose installation and runtime\n\n${section("OPTIONS")}\n  --plan <plan>                   Model routing plan for install: ${PLAN_HELP}\n                                   Default: ${DEFAULT_PLAN}\n  --max-subagents <count>          Override concurrent direct subagents for install\n  --fast                          Use Fast for generated subagents only\n  --fast-all                      Use Fast for Root and generated subagents\n  --no-fast                       Use Standard for Root and generated subagents\n  -h, --help                      Show help\n  -v, --version                   Show version\n  --no-tui                        Accepted; commands remain noninteractive\n  --codex-autonomous              Never ask; keep workspace sandbox\n  --no-codex-autonomous           Safe interactive defaults\n  --dangerous-codex-autonomous    Never ask; disable filesystem sandbox\n  install --verbose              Show detailed install steps
+  --json                          Print machine-readable output\n`;
 }
 /** Renders install-specific model plan and option help. */
 function renderInstallHelp(version, color) {
 	const title = paint(color, `${BOLD}${CYAN}`, `HolyCodex ${version}`);
 	const section = (text) => paint(color, BOLD, text);
-	return `${title}\n\n${section("Usage:")}\n  holycodex install [options]\n\n${section("Options:")}\n  --plan <plan>                   Model routing plan: ${PLAN_HELP}\n                                   Default: ${DEFAULT_PLAN}\n  --max-subagents <count>          Override concurrent direct subagents\n  --fast                          Use Fast for generated subagents only\n  --fast-all                      Use Fast for Root and generated subagents\n  --no-fast                       Use Standard for Root and generated subagents\n  --json                          Print machine-readable output\n  --no-tui                        Accepted; install remains noninteractive\n  --codex-autonomous              Never ask; keep workspace sandbox\n  --no-codex-autonomous           Safe interactive defaults\n  --dangerous-codex-autonomous    Never ask; disable filesystem sandbox\n  -h, --help                      Show help\n\nPlans provide increasing expected model usage and capability. Fast flags are mutually exclusive.\n\n${section("Examples:")}\n  bunx holycodex install\n  bunx holycodex install --plan go\n  bunx holycodex install --plan plus-low --fast\n  bunx holycodex install --plan plus-high\n  bunx holycodex install --plan pro-5x --fast-all\n  bunx holycodex install --plan pro-20x --no-fast\n`;
+	return `${title}\n\n${section("Usage:")}\n  holycodex install [options]\n\n${section("Options:")}\n  --plan <plan>                   Model routing plan: ${PLAN_HELP}\n                                   Default: ${DEFAULT_PLAN}\n  --max-subagents <count>          Override concurrent direct subagents\n  --fast                          Use Fast for generated subagents only\n  --fast-all                      Use Fast for Root and generated subagents\n  --no-fast                       Use Standard for Root and generated subagents\n  -v, --verbose                   Show detailed install steps
+  --json                          Print machine-readable output\n  --no-tui                        Accepted; install remains noninteractive\n  --codex-autonomous              Never ask; keep workspace sandbox\n  --no-codex-autonomous           Safe interactive defaults\n  --dangerous-codex-autonomous    Never ask; disable filesystem sandbox\n  -h, --help                      Show help\n\nPlans provide increasing expected model usage and capability. Fast flags are mutually exclusive.\n\n${section("Examples:")}\n  bunx holycodex install\n  bunx holycodex install --plan go\n  bunx holycodex install --plan plus-low --fast\n  bunx holycodex install --plan plus-high\n  bunx holycodex install --plan pro-5x --fast-all\n  bunx holycodex install --plan pro-20x --no-fast\n`;
 }
 /** Renders error. */
 function renderError(message, color) {
-	return `${paint(color, `${BOLD}${RED}`, "✗ ERROR")}  ${message}\n  ${paint(color, DIM, "Run holycodex --help for usage.")}\n`;
+	const label = paint(color, `${BOLD}${RED}`, "✗ ERROR");
+	const hint = paint(color, DIM, "Run holycodex --help for usage.");
+	return `${color ? "\r\x1B[2K" : ""}${label}  ${message}\n  ${hint}\n`;
 }
 /** Renders doctor. */
 function renderDoctor(result, color) {
@@ -6622,14 +7174,17 @@ function renderRunResult(result, color) {
 	const action = result.action === "install" ? "Updated" : "Removed";
 	const empty = result.action === "install" ? "changes" : "removal";
 	const backup = result.backups.length === 0 ? "" : `\n  Existing HolyCodex files were backed up before ${result.action === "install" ? "replacement" : "cleanup"}.`;
-	return `${title}\n  ${result.changed.length === 0 ? `No HolyCodex-managed files needed ${empty}.` : `${action} HolyCodex configuration, plugin files, and agent profiles.`}${backup}${renderCodexSecurity(result)}\n`;
+	return `${title}\n  ${result.changed.length === 0 ? `No HolyCodex-managed files needed ${empty}.` : `${action} HolyCodex configuration, plugin files, and agent profiles.`}${backup}${renderOfficialPlugins(result)}\n`;
+}
+function renderOfficialPlugins(result) {
+	return [renderOfficialPlugin("Codex Security", result.codexSecurity), renderOfficialPlugin("Computer Use", result.computerUse)].join("");
 }
-function renderCodexSecurity(result) {
-	if (result.codexSecurity === void 0) return "";
-	if (result.codexSecurity.status === "installed") return "\n  Installed official Codex Security plugin.";
-	if (result.codexSecurity.status === "enabled") return "\n  Enabled existing official Codex Security plugin.";
-	if (result.codexSecurity.status === "already-installed") return "\n  Official Codex Security plugin is already installed and enabled.";
-	return `\n  Skipped official Codex Security plugin: ${CODEX_SECURITY_SKIP_MESSAGES[result.codexSecurity.reason]}`;
+function renderOfficialPlugin(name, plugin) {
+	if (plugin === void 0) return "";
+	if (plugin.status === "installed") return `\n  Installed official ${name} plugin.`;
+	if (plugin.status === "enabled") return `\n  Enabled existing official ${name} plugin.`;
+	if (plugin.status === "already-installed") return `\n  Official ${name} plugin is already installed and enabled.`;
+	return `\n  Skipped official ${name} plugin: ${CODEX_SECURITY_SKIP_MESSAGES[plugin.reason]}`;
 }
 var CODEX_SECURITY_SKIP_MESSAGES = {
 	"codex-unavailable": "no usable Codex launcher was found.",
@@ -6645,6 +7200,13 @@ var CODEX_SECURITY_SKIP_MESSAGES = {
 	unsupported: "the available Codex launchers do not support plugin installation.",
 	"download-failed": "the latest Codex package could not be downloaded."
 };
+/** Renders one concise installation progress transition. */
+function renderInstallProgress(event, color, isTTY, verbose) {
+	const detail = verbose && event.detail !== void 0 ? `  ${paint(color, DIM, event.detail)}` : "";
+	if (event.status === "running") return isTTY ? `\r${paint(color, CYAN, "●")} ${event.label}` : "";
+	const line = `${paint(color, GREEN, "✓")} ${event.label}${detail}`;
+	return isTTY ? `\r\u001B[2K${line}\n` : `  ${line}\n`;
+}
 /** Renders notice. */
 function renderNotice(kind, message, color) {
 	return `${paint(color, kind === "warning" ? RED : YELLOW, `! ${kind === "warning" ? "WARNING" : "NOTICE"}`)}  ${message}\n`;
@@ -6652,88 +7214,41 @@ 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,
+		verbose: parsed.verbose,
+		...parsed.command === "install" && !parsed.json ? { onProgress: (event) => process$1.stdout.write(renderInstallProgress(event, stdoutColor, process$1.stdout.isTTY === true, parsed.verbose)) } : {},
+		...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