holycodex 0.13.8-dev.225.1 → 0.14.0

package/dist/cli.js

@@ -1751,62 +1751,6 @@ var $ZodUnion = /*@__PURE__*/ $constructor("$ZodUnion", (inst, def) => {
 		});
 	};
 });
-var $ZodDiscriminatedUnion = /*@__PURE__*/ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
-	def.inclusive = false;
-	$ZodUnion.init(inst, def);
-	const _super = inst._zod.parse;
-	defineLazy(inst._zod, "propValues", () => {
-		const propValues = {};
-		for (const option of def.options) {
-			const pv = option._zod.propValues;
-			if (!pv || Object.keys(pv).length === 0) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
-			for (const [k, v] of Object.entries(pv)) {
-				if (!propValues[k]) propValues[k] = /* @__PURE__ */ new Set();
-				for (const val of v) propValues[k].add(val);
-			}
-		}
-		return propValues;
-	});
-	const disc = cached(() => {
-		const opts = def.options;
-		const map = /* @__PURE__ */ new Map();
-		for (const o of opts) {
-			const values = o._zod.propValues?.[def.discriminator];
-			if (!values || values.size === 0) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
-			for (const v of values) {
-				if (map.has(v)) throw new Error(`Duplicate discriminator value "${String(v)}"`);
-				map.set(v, o);
-			}
-		}
-		return map;
-	});
-	inst._zod.parse = (payload, ctx) => {
-		const input = payload.value;
-		if (!isObject(input)) {
-			payload.issues.push({
-				code: "invalid_type",
-				expected: "object",
-				input,
-				inst
-			});
-			return payload;
-		}
-		const opt = disc.value.get(input?.[def.discriminator]);
-		if (opt) return opt._zod.run(payload, ctx);
-		if (def.unionFallback || ctx.direction === "backward") return _super(payload, ctx);
-		payload.issues.push({
-			code: "invalid_union",
-			errors: [],
-			note: "No matching discriminator",
-			discriminator: def.discriminator,
-			options: Array.from(disc.value.keys()),
-			input,
-			path: [def.discriminator],
-			inst
-		});
-		return payload;
-	};
-});
 var $ZodIntersection = /*@__PURE__*/ $constructor("$ZodIntersection", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
@@ -1998,115 +1942,6 @@ function handleTupleResults(itemResults, final, items, input, optoutStart) {
 	else break;
 	return final;
 }
-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);
@@ -3410,39 +3245,6 @@ var tupleProcessor = (schema, ctx, _json, params) => {
 	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;
-	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);
@@ -4086,6 +3888,13 @@ var ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
 		}
 	});
 });
+function object(shape, params) {
+	return new ZodObject({
+		type: "object",
+		shape: shape ?? {},
+		...normalizeParams(params)
+	});
+}
 function strictObject(shape, params) {
 	return new ZodObject({
 		type: "object",
@@ -4107,18 +3916,6 @@ function union(options, params) {
 		...normalizeParams(params)
 	});
 }
-var ZodDiscriminatedUnion = /*@__PURE__*/ $constructor("ZodDiscriminatedUnion", (inst, def) => {
-	ZodUnion.init(inst, def);
-	$ZodDiscriminatedUnion.init(inst, def);
-});
-function discriminatedUnion(discriminator, options, params) {
-	return new ZodDiscriminatedUnion({
-		type: "union",
-		options,
-		discriminator,
-		...normalizeParams(params)
-	});
-}
 var ZodIntersection = /*@__PURE__*/ $constructor("ZodIntersection", (inst, def) => {
 	$ZodIntersection.init(inst, def);
 	ZodType.init(inst, def);
@@ -4149,27 +3946,6 @@ function tuple(items, _paramsOrRest, _params) {
 		...normalizeParams(hasRest ? _params : _paramsOrRest)
 	});
 }
-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);
@@ -4391,7 +4167,7 @@ function superRefine(fn, params) {
 }
 //#endregion
 //#region packages/cli/src/catalog.ts
-var VERSION = "0.13.8-dev.225.1";
+var VERSION = "0.14.0";
 var SKILLS = [
 	"ast-grep",
 	"babysit-ci",
@@ -4415,7 +4191,8 @@ var SKILLS = [
 var AGENTS = _enum([
 	"explorer",
 	"librarian",
-	"worker"
+	"worker",
+	"reviewer"
 ]).options;
 var PlanNameSchema = _enum([
 	"go",
@@ -4438,64 +4215,59 @@ var FastModeSchema = _enum([
 	"fast",
 	"fast-all"
 ]);
-var ModelRouteSchema = discriminatedUnion("model", [
-	strictObject({
-		model: literal("gpt-5.6-luna"),
-		reasoningEffort: ReasoningEffortSchema
-	}),
-	strictObject({
-		model: literal("gpt-5.6-terra"),
-		reasoningEffort: ReasoningEffortSchema
-	}),
-	strictObject({
-		model: literal("gpt-5.6-sol"),
-		reasoningEffort: ReasoningEffortSchema
-	})
-]);
-var WORKFLOW_STAGES = [
-	"analysis",
+var ModelRouteSchema = strictObject({
+	model: _enum(["gpt-5.6-luna", "gpt-5.6-sol"]),
+	reasoningEffort: ReasoningEffortSchema
+});
+_enum([
+	"lookup",
+	"trace",
 	"research",
+	"mechanical",
 	"implementation",
-	"verification"
-];
-var WorkflowStageSchema = _enum(WORKFLOW_STAGES);
-var WorkflowLimitsSchema = strictObject({
-	concurrency: number().int().positive(),
-	targetCalls: number().int().positive(),
-	maxCalls: number().int().positive(),
-	workflowDepth: number().int().positive(),
-	retries: number().int().nonnegative(),
-	loopIterations: number().int().positive(),
-	fanOut: number().int().positive()
-});
-var ProjectedUsageRangeSchema = strictObject({
-	minimum: number().positive(),
-	maximum: number().positive()
+	"integration",
+	"operations",
+	"plan",
+	"code",
+	"artifact"
+]);
+var TaskRouteTableSchema = object({
+	explorer: object({
+		lookup: ModelRouteSchema,
+		trace: ModelRouteSchema
+	}).strict(),
+	librarian: object({
+		lookup: ModelRouteSchema,
+		research: ModelRouteSchema
+	}).strict(),
+	worker: object({
+		mechanical: ModelRouteSchema,
+		implementation: ModelRouteSchema,
+		integration: ModelRouteSchema,
+		operations: ModelRouteSchema
+	}).strict(),
+	reviewer: object({
+		plan: ModelRouteSchema,
+		code: ModelRouteSchema,
+		artifact: ModelRouteSchema
+	}).strict()
 });
-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"),
+var WorkflowPolicySchema = union([strictObject({ enabled: literal(false) }), strictObject({
+	enabled: literal(true),
+	costTarget: number().positive(),
+	costMax: number().positive(),
+	maxCalls: number().int().positive(),
+	maxConcurrency: number().int().positive(),
 	serviceTiers: tuple([literal("default"), literal("fast")]),
-	limits: WorkflowLimitsSchema,
-	projectedUsage: strictObject({
-		standard: ProjectedUsageRangeSchema,
-		fast: ProjectedUsageRangeSchema
-	}),
-	softSizeGuidance: strictObject({
-		maxInputTokens: number().int().positive(),
-		maxScriptBytes: number().int().positive()
-	})
-});
+	taskRoutes: TaskRouteTableSchema
+})]);
 var RoutingPresetSchema = strictObject({
 	root: ModelRouteSchema,
 	agents: strictObject({
 		explorer: ModelRouteSchema,
 		librarian: ModelRouteSchema,
-		worker: ModelRouteSchema
+		worker: ModelRouteSchema,
+		reviewer: ModelRouteSchema
 	}),
 	workflow: WorkflowPolicySchema
 });
@@ -4507,547 +4279,178 @@ var ModelRoutingPlansSchema = strictObject({
 	"pro-5x": RoutingPresetSchema,
 	"pro-20x": RoutingPresetSchema
 });
-function workflowFor(permittedRoutes, limits, projectedUsage, maxInputTokens) {
+var LUNA = (reasoningEffort) => ({
+	model: "gpt-5.6-luna",
+	reasoningEffort
+});
+var SOL = (reasoningEffort) => ({
+	model: "gpt-5.6-sol",
+	reasoningEffort
+});
+function taskRoutes(explorer, librarian, worker, reviewer) {
 	return {
-		permittedRoutes,
-		verbosity: "low",
-		serviceTiers: ["default", "fast"],
-		limits,
-		projectedUsage: {
-			standard: projectedUsage,
-			fast: {
-				minimum: projectedUsage.minimum * 2,
-				maximum: projectedUsage.maximum * 2
-			}
+		explorer: {
+			lookup: LUNA(explorer[0]),
+			trace: LUNA(explorer[1])
+		},
+		librarian: {
+			lookup: LUNA(librarian[0]),
+			research: LUNA(librarian[1])
+		},
+		worker: {
+			mechanical: LUNA(worker[0]),
+			implementation: LUNA(worker[1]),
+			integration: LUNA(worker[2]),
+			operations: LUNA(worker[3])
 		},
-		softSizeGuidance: {
-			maxInputTokens,
-			maxScriptBytes: Math.min(maxInputTokens, 4 * 1024 * 1024)
+		reviewer: {
+			plan: LUNA(reviewer[0]),
+			code: LUNA(reviewer[1]),
+			artifact: LUNA(reviewer[2])
 		}
 	};
 }
-var DEFAULT_PLAN = "plus";
-var LUNA_HIGH = {
-	model: "gpt-5.6-luna",
-	reasoningEffort: "high"
-};
-var LUNA_XHIGH = {
-	model: "gpt-5.6-luna",
-	reasoningEffort: "xhigh"
-};
-var LUNA_MAX = {
-	model: "gpt-5.6-luna",
-	reasoningEffort: "max"
-};
-var SOL_HIGH = {
-	model: "gpt-5.6-sol",
-	reasoningEffort: "high"
-};
-function uniformStageRoutes(...routes) {
-	return Object.fromEntries(WORKFLOW_STAGES.map((stage) => [stage, [...routes]]));
+function workflow(costTarget, costMax, maxCalls, maxConcurrency, routes) {
+	return {
+		enabled: true,
+		costTarget,
+		costMax,
+		maxCalls,
+		maxConcurrency,
+		serviceTiers: ["default", "fast"],
+		taskRoutes: routes
+	};
 }
+var DEFAULT_PLAN = "plus";
 var MODEL_ROUTING_PLANS = ModelRoutingPlansSchema.parse({
 	go: {
-		root: SOL_HIGH,
+		root: SOL("high"),
 		agents: {
-			explorer: LUNA_HIGH,
-			librarian: LUNA_HIGH,
-			worker: LUNA_HIGH
+			explorer: LUNA("high"),
+			librarian: LUNA("high"),
+			worker: LUNA("high"),
+			reviewer: LUNA("high")
 		},
-		workflow: workflowFor({
-			explorer: uniformStageRoutes(LUNA_HIGH),
-			librarian: uniformStageRoutes(LUNA_HIGH),
-			worker: uniformStageRoutes(LUNA_HIGH)
-		}, {
-			concurrency: 1,
-			targetCalls: 2,
-			maxCalls: 4,
-			workflowDepth: 2,
-			retries: 0,
-			loopIterations: 1,
-			fanOut: 1
-		}, {
-			minimum: .2,
-			maximum: .35
-		}, 2e4)
+		workflow: { enabled: false }
 	},
 	"plus-low": {
-		root: {
-			model: "gpt-5.6-sol",
-			reasoningEffort: "low"
-		},
+		root: SOL("low"),
 		agents: {
-			explorer: {
-				model: "gpt-5.6-luna",
-				reasoningEffort: "high"
-			},
-			librarian: {
-				model: "gpt-5.6-luna",
-				reasoningEffort: "high"
-			},
-			worker: {
-				model: "gpt-5.6-luna",
-				reasoningEffort: "high"
-			}
+			explorer: LUNA("medium"),
+			librarian: LUNA("medium"),
+			worker: LUNA("high"),
+			reviewer: LUNA("high")
 		},
-		workflow: workflowFor({
-			explorer: uniformStageRoutes(LUNA_HIGH),
-			librarian: uniformStageRoutes(LUNA_HIGH),
-			worker: uniformStageRoutes(LUNA_HIGH)
-		}, {
-			concurrency: 3,
-			targetCalls: 4,
-			maxCalls: 12,
-			workflowDepth: 3,
-			retries: 1,
-			loopIterations: 2,
-			fanOut: 3
-		}, {
-			minimum: 1,
-			maximum: 1
-		}, 3e4)
+		workflow: workflow(1, 1.5, 10, 3, taskRoutes(["medium", "high"], ["medium", "high"], [
+			"high",
+			"high",
+			"xhigh",
+			"high"
+		], [
+			"high",
+			"xhigh",
+			"high"
+		]))
 	},
 	plus: {
-		root: {
-			model: "gpt-5.6-sol",
-			reasoningEffort: "medium"
-		},
+		root: SOL("medium"),
 		agents: {
-			explorer: {
-				model: "gpt-5.6-luna",
-				reasoningEffort: "high"
-			},
-			librarian: {
-				model: "gpt-5.6-luna",
-				reasoningEffort: "high"
-			},
-			worker: {
-				model: "gpt-5.6-luna",
-				reasoningEffort: "high"
-			}
+			explorer: LUNA("high"),
+			librarian: LUNA("high"),
+			worker: LUNA("xhigh"),
+			reviewer: LUNA("xhigh")
 		},
-		workflow: workflowFor({
-			explorer: uniformStageRoutes(LUNA_HIGH),
-			librarian: uniformStageRoutes(LUNA_HIGH),
-			worker: {
-				analysis: [LUNA_HIGH, LUNA_XHIGH],
-				research: [LUNA_HIGH],
-				implementation: [LUNA_HIGH, LUNA_XHIGH],
-				verification: [LUNA_XHIGH]
-			}
-		}, {
-			concurrency: 3,
-			targetCalls: 6,
-			maxCalls: 16,
-			workflowDepth: 4,
-			retries: 2,
-			loopIterations: 3,
-			fanOut: 3
-		}, {
-			minimum: 1.4,
-			maximum: 1.7
-		}, 5e4)
+		workflow: workflow(1.6, 2.5, 16, 3, taskRoutes(["medium", "high"], ["medium", "high"], [
+			"high",
+			"xhigh",
+			"xhigh",
+			"high"
+		], [
+			"high",
+			"xhigh",
+			"high"
+		]))
 	},
 	"plus-high": {
-		root: {
-			model: "gpt-5.6-sol",
-			reasoningEffort: "high"
-		},
+		root: SOL("high"),
 		agents: {
-			explorer: {
-				model: "gpt-5.6-luna",
-				reasoningEffort: "high"
-			},
-			librarian: {
-				model: "gpt-5.6-luna",
-				reasoningEffort: "high"
-			},
-			worker: {
-				model: "gpt-5.6-luna",
-				reasoningEffort: "xhigh"
-			}
+			explorer: LUNA("xhigh"),
+			librarian: LUNA("xhigh"),
+			worker: LUNA("xhigh"),
+			reviewer: LUNA("xhigh")
 		},
-		workflow: workflowFor({
-			explorer: uniformStageRoutes(LUNA_HIGH, LUNA_XHIGH),
-			librarian: uniformStageRoutes(LUNA_HIGH, LUNA_XHIGH),
-			worker: {
-				analysis: [LUNA_XHIGH],
-				research: [LUNA_XHIGH],
-				implementation: [LUNA_XHIGH, LUNA_MAX],
-				verification: [LUNA_MAX]
-			}
-		}, {
-			concurrency: 4,
-			targetCalls: 8,
-			maxCalls: 24,
-			workflowDepth: 5,
-			retries: 3,
-			loopIterations: 4,
-			fanOut: 4
-		}, {
-			minimum: 2.4,
-			maximum: 3.1
-		}, 7e4)
+		workflow: workflow(3, 4.5, 24, 4, taskRoutes(["medium", "xhigh"], ["medium", "xhigh"], [
+			"high",
+			"xhigh",
+			"max",
+			"xhigh"
+		], [
+			"xhigh",
+			"max",
+			"xhigh"
+		]))
 	},
 	"pro-5x": {
-		root: {
-			model: "gpt-5.6-sol",
-			reasoningEffort: "high"
-		},
+		root: SOL("high"),
 		agents: {
-			explorer: {
-				model: "gpt-5.6-luna",
-				reasoningEffort: "xhigh"
-			},
-			librarian: {
-				model: "gpt-5.6-luna",
-				reasoningEffort: "xhigh"
-			},
-			worker: {
-				model: "gpt-5.6-luna",
-				reasoningEffort: "xhigh"
-			}
+			explorer: LUNA("xhigh"),
+			librarian: LUNA("xhigh"),
+			worker: LUNA("max"),
+			reviewer: LUNA("max")
 		},
-		workflow: workflowFor({
-			explorer: uniformStageRoutes(LUNA_XHIGH),
-			librarian: uniformStageRoutes(LUNA_XHIGH),
-			worker: {
-				analysis: [LUNA_XHIGH, LUNA_MAX],
-				research: [LUNA_XHIGH],
-				implementation: [LUNA_MAX],
-				verification: [LUNA_MAX]
-			}
-		}, {
-			concurrency: 6,
-			targetCalls: 12,
-			maxCalls: 40,
-			workflowDepth: 6,
-			retries: 3,
-			loopIterations: 5,
-			fanOut: 5
-		}, {
-			minimum: 4,
-			maximum: 5
-		}, 1e5)
+		workflow: workflow(5, 7.5, 40, 6, taskRoutes(["high", "xhigh"], ["high", "xhigh"], [
+			"high",
+			"max",
+			"max",
+			"xhigh"
+		], [
+			"xhigh",
+			"max",
+			"xhigh"
+		]))
 	},
 	"pro-20x": {
-		root: {
-			model: "gpt-5.6-sol",
-			reasoningEffort: "high"
-		},
+		root: SOL("xhigh"),
 		agents: {
-			explorer: {
-				model: "gpt-5.6-luna",
-				reasoningEffort: "xhigh"
-			},
-			librarian: {
-				model: "gpt-5.6-luna",
-				reasoningEffort: "xhigh"
-			},
-			worker: {
-				model: "gpt-5.6-luna",
-				reasoningEffort: "max"
-			}
+			explorer: LUNA("xhigh"),
+			librarian: LUNA("xhigh"),
+			worker: LUNA("max"),
+			reviewer: LUNA("max")
 		},
-		workflow: workflowFor({
-			explorer: uniformStageRoutes(LUNA_XHIGH, LUNA_MAX),
-			librarian: uniformStageRoutes(LUNA_XHIGH, LUNA_MAX),
-			worker: uniformStageRoutes(LUNA_MAX)
-		}, {
-			concurrency: 8,
-			targetCalls: 20,
-			maxCalls: 80,
-			workflowDepth: 8,
-			retries: 4,
-			loopIterations: 8,
-			fanOut: 8
-		}, {
-			minimum: 8,
-			maximum: 12
-		}, 15e4)
+		workflow: workflow(12, 20, 64, 8, taskRoutes(["high", "xhigh"], ["high", "max"], [
+			"xhigh",
+			"max",
+			"max",
+			"xhigh"
+		], [
+			"max",
+			"max",
+			"max"
+		]))
 	}
 });
 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]));
+Object.fromEntries(PLAN_NAMES.map((plan) => {
+	const workflow = MODEL_ROUTING_PLANS[plan].workflow;
+	return [plan, workflow.enabled ? {
+		maxCalls: workflow.maxCalls,
+		maxConcurrency: workflow.maxConcurrency,
+		maxRetries: 1,
+		maxFanOut: workflow.maxConcurrency + workflow.maxCalls,
+		workflowDepth: 8,
+		maxMemoryBytes: 16 * 1024 * 1024,
+		maxStackBytes: 1 * 1024 * 1024,
+		maxScriptBytes: 64 * 1024
+	} : {}];
+}));
 MODEL_ROUTING_PLANS[DEFAULT_PLAN].root;
 MODEL_ROUTING_PLANS[DEFAULT_PLAN].agents;
-var LEGACY_MANAGED_AGENT_MODEL_HISTORY = {
-	go: {
-		explorer: [{
-			model: "gpt-5.6-luna",
-			reasoningEffort: "low"
-		}, {
-			model: "gpt-5.6-terra",
-			reasoningEffort: "low"
-		}],
-		librarian: [{
-			model: "gpt-5.6-luna",
-			reasoningEffort: "low"
-		}, {
-			model: "gpt-5.6-terra",
-			reasoningEffort: "low"
-		}],
-		worker: [
-			{
-				model: "gpt-5.6-luna",
-				reasoningEffort: "xhigh"
-			},
-			{
-				model: "gpt-5.6-terra",
-				reasoningEffort: "low"
-			},
-			{
-				model: "gpt-5.6-terra",
-				reasoningEffort: "medium"
-			}
-		]
-	},
-	"plus-low": {
-		explorer: [{
-			model: "gpt-5.6-luna",
-			reasoningEffort: "low"
-		}],
-		librarian: [{
-			model: "gpt-5.6-luna",
-			reasoningEffort: "medium"
-		}],
-		worker: [{
-			model: "gpt-5.6-luna",
-			reasoningEffort: "xhigh"
-		}, {
-			model: "gpt-5.6-terra",
-			reasoningEffort: "medium"
-		}]
-	},
-	plus: {
-		explorer: [{
-			model: "gpt-5.6-luna",
-			reasoningEffort: "low"
-		}, {
-			model: "gpt-5.6-luna",
-			reasoningEffort: "medium"
-		}],
-		librarian: [
-			{
-				model: "gpt-5.6-luna",
-				reasoningEffort: "xhigh"
-			},
-			{
-				model: "gpt-5.6-luna",
-				reasoningEffort: "low"
-			},
-			{
-				model: "gpt-5.6-terra",
-				reasoningEffort: "low"
-			},
-			{
-				model: "gpt-5.6-terra",
-				reasoningEffort: "medium"
-			}
-		],
-		worker: [{
-			model: "gpt-5.6-luna",
-			reasoningEffort: "xhigh"
-		}, {
-			model: "gpt-5.6-terra",
-			reasoningEffort: "high"
-		}]
-	},
-	"plus-high": {
-		explorer: [{
-			model: "gpt-5.6-luna",
-			reasoningEffort: "xhigh"
-		}, {
-			model: "gpt-5.6-terra",
-			reasoningEffort: "medium"
-		}],
-		librarian: [{
-			model: "gpt-5.6-luna",
-			reasoningEffort: "xhigh"
-		}, {
-			model: "gpt-5.6-terra",
-			reasoningEffort: "medium"
-		}],
-		worker: [
-			{
-				model: "gpt-5.6-luna",
-				reasoningEffort: "max"
-			},
-			{
-				model: "gpt-5.6-terra",
-				reasoningEffort: "high"
-			},
-			{
-				model: "gpt-5.6-sol",
-				reasoningEffort: "low"
-			}
-		]
-	},
-	"pro-5x": {
-		explorer: [
-			{
-				model: "gpt-5.6-luna",
-				reasoningEffort: "high"
-			},
-			{
-				model: "gpt-5.6-luna",
-				reasoningEffort: "xhigh"
-			},
-			{
-				model: "gpt-5.6-terra",
-				reasoningEffort: "medium"
-			},
-			{
-				model: "gpt-5.6-terra",
-				reasoningEffort: "high"
-			}
-		],
-		librarian: [
-			{
-				model: "gpt-5.6-luna",
-				reasoningEffort: "high"
-			},
-			{
-				model: "gpt-5.6-luna",
-				reasoningEffort: "xhigh"
-			},
-			{
-				model: "gpt-5.6-terra",
-				reasoningEffort: "high"
-			}
-		],
-		worker: [
-			{
-				model: "gpt-5.6-luna",
-				reasoningEffort: "max"
-			},
-			{
-				model: "gpt-5.6-terra",
-				reasoningEffort: "high"
-			},
-			{
-				model: "gpt-5.6-sol",
-				reasoningEffort: "medium"
-			}
-		]
-	},
-	"pro-20x": {
-		explorer: [
-			{
-				model: "gpt-5.6-luna",
-				reasoningEffort: "high"
-			},
-			{
-				model: "gpt-5.6-luna",
-				reasoningEffort: "max"
-			},
-			{
-				model: "gpt-5.6-sol",
-				reasoningEffort: "medium"
-			}
-		],
-		librarian: [
-			{
-				model: "gpt-5.6-luna",
-				reasoningEffort: "high"
-			},
-			{
-				model: "gpt-5.6-luna",
-				reasoningEffort: "max"
-			},
-			{
-				model: "gpt-5.6-terra",
-				reasoningEffort: "high"
-			},
-			{
-				model: "gpt-5.6-sol",
-				reasoningEffort: "medium"
-			}
-		],
-		worker: [
-			{
-				model: "gpt-5.6-terra",
-				reasoningEffort: "xhigh"
-			},
-			{
-				model: "gpt-5.6-terra",
-				reasoningEffort: "high"
-			},
-			{
-				model: "gpt-5.6-luna",
-				reasoningEffort: "medium"
-			},
-			{
-				model: "gpt-5.6-sol",
-				reasoningEffort: "high"
-			}
-		]
-	}
-};
-function managedPlanAgentModels(plan) {
-	return {
-		explorer: [MODEL_ROUTING_PLANS[plan].agents.explorer, ...LEGACY_MANAGED_AGENT_MODEL_HISTORY[plan].explorer],
-		librarian: [MODEL_ROUTING_PLANS[plan].agents.librarian, ...LEGACY_MANAGED_AGENT_MODEL_HISTORY[plan].librarian],
-		worker: [MODEL_ROUTING_PLANS[plan].agents.worker, ...LEGACY_MANAGED_AGENT_MODEL_HISTORY[plan].worker]
-	};
-}
-var MANAGED_AGENT_MODEL_HISTORY_BY_PLAN = {
-	go: managedPlanAgentModels("go"),
-	"plus-low": managedPlanAgentModels("plus-low"),
-	plus: managedPlanAgentModels("plus"),
-	"plus-high": managedPlanAgentModels("plus-high"),
-	"pro-5x": managedPlanAgentModels("pro-5x"),
-	"pro-20x": managedPlanAgentModels("pro-20x")
-};
-function managedAgentModels(agent) {
-	return PLAN_NAMES.flatMap((plan) => MANAGED_AGENT_MODEL_HISTORY_BY_PLAN[plan][agent]);
+function currentAgentModels(plan) {
+	return Object.fromEntries(AGENTS.map((agent) => [agent, [MODEL_ROUTING_PLANS[plan].agents[agent]]]));
 }
-var MANAGED_AGENT_MODEL_HISTORY = {
-	explorer: managedAgentModels("explorer"),
-	librarian: managedAgentModels("librarian"),
-	worker: managedAgentModels("worker")
-};
-var LEGACY_MANAGED_ROOT_MODEL_HISTORY = {
-	go: [
-		{
-			model: "gpt-5.6-luna",
-			reasoningEffort: "xhigh"
-		},
-		{
-			model: "gpt-5.6-sol",
-			reasoningEffort: "low"
-		},
-		{
-			model: "gpt-5.6-terra",
-			reasoningEffort: "medium"
-		}
-	],
-	"plus-low": [],
-	plus: [],
-	"plus-high": [{
-		model: "gpt-5.6-sol",
-		reasoningEffort: "medium"
-	}],
-	"pro-5x": [{
-		model: "gpt-5.6-sol",
-		reasoningEffort: "medium"
-	}],
-	"pro-20x": [{
-		model: "gpt-5.6-sol",
-		reasoningEffort: "xhigh"
-	}]
-};
-function managedPlanRootModels(plan) {
-	return [MODEL_ROUTING_PLANS[plan].root, ...LEGACY_MANAGED_ROOT_MODEL_HISTORY[plan]];
-}
-var MANAGED_ROOT_MODEL_HISTORY_BY_PLAN = {
-	go: managedPlanRootModels("go"),
-	"plus-low": managedPlanRootModels("plus-low"),
-	plus: managedPlanRootModels("plus"),
-	"plus-high": managedPlanRootModels("plus-high"),
-	"pro-5x": managedPlanRootModels("pro-5x"),
-	"pro-20x": managedPlanRootModels("pro-20x")
-};
+var MANAGED_AGENT_MODEL_HISTORY_BY_PLAN = Object.fromEntries(PLAN_NAMES.map((plan) => [plan, currentAgentModels(plan)]));
+var MANAGED_AGENT_MODEL_HISTORY = Object.fromEntries(AGENTS.map((agent) => [agent, PLAN_NAMES.flatMap((plan) => MANAGED_AGENT_MODEL_HISTORY_BY_PLAN[plan][agent])]));
+var MANAGED_ROOT_MODEL_HISTORY_BY_PLAN = Object.fromEntries(PLAN_NAMES.map((plan) => [plan, [MODEL_ROUTING_PLANS[plan].root]]));
 var GENERATED_RUNTIMES = [
 	"agent-capacity.js",
 	"bootstrap.js",
@@ -5065,7 +4468,6 @@ var GENERATED_RUNTIMES = [
 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. plus-low favors retained context, compact structured outcomes, Luna-local loops and synthesis, sufficient discovery, and genuine concurrency without budget changes. 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");
 }
@@ -6612,15 +6014,11 @@ function readManagedWorkflowPolicy(input) {
 		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 size = record.softSizeGuidance;
-		if (plan === void 0 || typeof limits !== "object" || limits === null || typeof usage !== "object" || usage === null || typeof size !== "object" || size === null) return void 0;
+		const workflow = record.workflow;
+		if (plan === void 0 || typeof workflow !== "object" || workflow === null) return void 0;
 		return {
 			plan,
-			limits,
-			projectedUsage: usage,
-			softSizeGuidance: size
+			workflow
 		};
 	} catch {
 		return;
@@ -6743,9 +6141,7 @@ function installConfig(input, mode, _platform, requestedPlan, maxSubagents, fast
 	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,
-		softSizeGuidance: workflow.softSizeGuidance
+		workflow
 	})}\n${AUTONOMY_METADATA_PREFIX}${effectiveAutonomy}\n${COMPUTER_USE_PREFIX}${effectiveComputerUse}\n${SPECIALIZATION_NAMES.map((name) => `${SPECIALIZATION_PREFIX}${name}: ${effectiveSpecializations[name]}`).join("\n")}\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];
@@ -6754,7 +6150,7 @@ function installConfig(input, mode, _platform, requestedPlan, maxSubagents, fast
 		["multi_agent", "true"],
 		...legacyMultiAgentV2 === void 0 ? [] : [["multi_agent_v2", legacyMultiAgentV2]]
 	]);
-	configured = injectTableKeys(configured, "agents", [["max_concurrent_threads_per_session", String((maxSubagents ?? workflow.limits.concurrency) + 1)]]);
+	configured = injectTableKeys(configured, "agents", [["max_concurrent_threads_per_session", String((maxSubagents ?? (workflow.enabled ? workflow.maxConcurrency : 0)) + 1)]]);
 	configured = injectTableKeys(configured, "tui", [["status_line", statusLine]]);
 	if (effectiveAutonomy !== "dangerous") configured = injectTableKeys(configured, "sandbox_workspace_write", [["network_access", "true"]]);
 	configured = injectTableKeys(configured, "desktop", [["show-context-window-usage", "true"]]);
@@ -6854,10 +6250,10 @@ function formatInstalledRuntimeGuidance(pluginRoot) {
 	return `Use the installed HolyCodex workflow runtime with an absolute path: node ${quotedPath}. For help, run node ${quotedPath} --help.`;
 }
 /** Shared HolyCodex root instructions. */
-var CORE_INSTRUCTIONS = "HolyCodex: Root is user-facing. Before updates, classify intent and load required skills. Start with \"I detect [intent] intent - [action].\" Choose the accurate intent naturally; no fixed intent taxonomy applies. `plan` and `plan-review` own their exact heading and intent as the first visible block; other modes do not print a heading. Name each specialist type and its bounded outcome in concise updates. Root owns interaction, scope, architecture, product choices, ambiguity, integration, external state, and final judgment and verification. Root evaluates specialist evidence against user decisions, repository conventions, approved constraints, and proof, then integrates only accepted work. Before Root writes or reviews prompts, delegations, Worker briefs, handoffs, or workflows, load and apply `writing-for-agents`; delegation is instruction design. On every plan other than Go, use the CLI workflow for substantive discovery, implementation, verification, multi-file, risky, or architecture-sensitive work; genuinely small bounded operations may remain direct. Go works directly without specialists. Keep the active plan authoritative for routes, effort, verbosity, service tier, concurrency, target calls, hard maximum calls, depth, retries, loops, fan-out, and projected usage. Select only permitted Explorer, Librarian, and Worker capabilities. After code or manifest implementation, load `code-review` exactly once; that skill owns routine final audit mechanics while Root owns the final judgment. Classify unknowns as facts for specialists, material decisions for `request_user_input`, and safe reversible defaults. Use `request_user_input` immediately before commits, pushes, tags, builds, compiles, packages, publication, deployment, destructive changes, permission changes, financial actions, sending, reruns, or other externally visible actions. Explorer is repository-read-only, Librarian is research-only, and Worker cannot alter dashboards, accounts, permissions, or external state. Specialists do not delegate, broaden scope, or make final judgments.";
+var CORE_INSTRUCTIONS = "HolyCodex: Root is user-facing. Before updates, classify intent and load required skills. Start with \"I detect [intent] intent - [action].\" Choose the accurate intent naturally; no fixed intent taxonomy applies. `plan` and `plan-review` own their exact heading and intent as the first visible block; other modes do not print a heading. Root owns interaction, scope, architecture, product choices, ambiguity, integration, external state, and final judgment and verification. Root evaluates specialist evidence against user decisions, repository conventions, approved constraints, and proof, then integrates only accepted work. Before Root writes or reviews prompts, delegations, Worker briefs, handoffs, or workflows, load and apply `writing-for-agents`; delegation is instruction design. On every plan other than Go, use the CLI workflow for substantive discovery, implementation, verification, multi-file, risky, or architecture-sensitive work; genuinely small bounded operations may remain direct. Go works directly without specialists. Keep the active plan authoritative for cost target, hard cost maximum, maxCalls, maxConcurrency, and the plan × agent × broad task type route table. Choose only permitted Explorer, Librarian, Worker, and Reviewer capabilities and task types. After code or manifest implementation, load `code-review` exactly once; Reviewer owns routine adversarial review and bounded repair while Root owns architecture and final readiness. Classify unknowns as facts for specialists, material decisions for `request_user_input`, and safe reversible defaults. Use `request_user_input` immediately before commits, pushes, tags, builds, compiles, packages, publication, deployment, destructive changes, permission changes, financial actions, sending, reruns, or other externally visible actions. Explorer is repository-read-only, Librarian is research-only, Worker executes bounded implementation and operations after approval, and Reviewer performs bounded fixed-point review. Specialists do not delegate, broaden scope, or make final judgments. After an approved Worker/operations push or tag succeeds, Worker/operations immediately loads `babysit-ci` for terminal required-job evidence.";
 var NATIVE_IO_INSTRUCTIONS = "Use exact `plan` and `plan-review` headings only in those modes. Never delegate browser or computer control. For frontend creation, redesign, or visual verification, use installed Build Web Apps `frontend-app-builder` for concept, approval, implementation, and visual verification. For authorized security reviews, audits, scans, threat models, vulnerabilities, or attack paths, use matching installed Codex Security plugin skills. Use these capabilities instead of manual-click instructions, shell-as-GUI, or public research as a substitute for authenticated control. Use Codex native `apply_patch` for workspace file creation, updates, and deletion. Use native read or shell tools for file inspection and repository search. Do not reread files only to verify a successful `apply_patch` call.";
 var COMPUTER_USE_INSTRUCTIONS = "For native desktop tasks, use the available Computer Use capability.";
-var ROOT_LUNA_POLICY = "Root is the judgment and control plane for interaction, scope, architecture, product, risk, workflow integration, ambiguity, external state, and final decisions. Sol derives each assignment from the final outcome, specialist contribution, evidence needed back, authority boundary, and completion criterion, so Luna can execute without re-deciding architecture. Luna is bounded execution: Explorer maps repository facts, Librarian verifies assigned current facts, and Worker implements, integrates, inspects diffs, runs checks, repairs bounded defects, retests, compresses evidence, and synthesizes only when asked. Root accepts successful mechanical evidence without rerunning routine mechanics, then inspects actual relevant final diff or hunks for qualifying work. Material architecture, product, scope, risk, or contradictory evidence returns to Root. Structured outcomes drive branching; retained context is reused only when its owner, scope, permissions, and task class remain valid. Root does not repeatedly narrate unchanged workflow or status snapshots. Escalate Luna effort only when evidence and the active plan permit it; no route creates a Sol specialist.";
+var ROOT_LUNA_POLICY = "Root is the judgment and control plane for interaction, scope, architecture, product, risk, workflow integration, ambiguity, external state, and final decisions. Sol derives each assignment from the final outcome, specialist contribution, evidence needed back, authority boundary, and completion criterion, so Luna can execute without re-deciding architecture. Luna is bounded execution: Explorer maps repository facts, Librarian verifies assigned current facts, Worker implements, integrates, owns approved operations, runs checks, repairs bounded defects, retests, compresses evidence, and synthesizes only when asked. Reviewer inspects and repairs reviewer-owned defects to a fixed point, then returns structured evidence. Root accepts successful mechanical evidence without rerunning routine mechanics, then inspects actual relevant final diff or hunks for qualifying work. Material architecture, product, scope, risk, or contradictory evidence returns to Root. Structured outcomes drive branching; retained context is reused only when its owner, scope, permissions, and task class remain valid. Root does not repeatedly narrate unchanged workflow or status snapshots. Escalate Luna effort only when evidence and the active plan permit it; no route creates a Sol specialist.";
 var ROOT_DESIGN_GATE_POLICY = "Use the existing shouldUseRootDesignGate decision for pre-work constraints and post-review final Root inspection. Qualifying work is architecture-sensitive, substantive, or meaningfully multi-file; trivial, one-off mechanical, and genuinely small single-file work remains exempt. Record owner and seam, data and control flow, stable interfaces, state and policy, exclusions, duplication seam, errors and recovery, tests, compatibility, and the preferred shape when real alternatives exist. After Luna routine review, Root inspects actual relevant final diff or hunks with minimal ownership or interface context and judges architecture, dependency direction, scope, cohesion, abstraction, repository-native taste, mergeability, and readiness. Root may direct at most one bounded Luna repair within active plan quotas followed by affected-diff reinspection. This is a compact constraint gate, not an unconditional model call, independent review, workflow restart, or second plan. Repository-native source, tests, configuration, commands, diff, and status are authoritative. Escalate conflicting evidence or constraints to Root.";
 var WORKER_BRIEF_POLICY = "Root gives Worker a literal assignment with objective and outcome, scope and exclusions, output and evidence, authority boundary, completion criterion, and the minimum seam-specific constraints needed for interfaces, flow, policy, recovery, compatibility, and proof. These boundaries keep execution reviewable and leave material choices with Root. Retained context may omit unchanged constraints; continuation or repair must identify changed constraints and the exact next action. Worker follows the assignment without rediscovering architecture or making material choices. Luna owns correctness, completeness, regression checks, diagnostics, compatibility, changed-file inspection, bounded repair, and compact structured evidence. Worker may make one warranted bounded diff-level taste/simplification pass for clarity, naming, duplication, or avoidable complexity in changed files only; it preserves behavior, interfaces, ownership, and scope, then stops. Material conflicts return `needs_root_decision` with exact evidence. Root retains final judgment and reports meaningful lifecycle changes only.";
 var CODE_REVIEW_ACTIVATION_POLICY = "After loading `code-review`, its first visible line is **CODE REVIEW MODE ACTIVATED**.";
@@ -6865,7 +6261,7 @@ var CODE_REVIEW_ACTIVATION_POLICY = "After loading `code-review`, its first visi
 function coreInstructions(platform, capacity, computerUseEnabled = false, pluginRoot, specializations = []) {
 	const threads = capacity?.maxThreads;
 	const depth = capacity?.maxDepth;
-	const capacityInstructions = threads === void 0 || depth === void 0 ? "Before delegation, use active collaboration tool instructions as the authoritative agent-capacity limit." : `Host agent capacity: agents.max_concurrent_threads_per_session=${threads} includes Root. The host nesting limit is ${depth}; the active plan's maxCalls is the hard workflow call ceiling and targetCalls is soft planning guidance. Its lower concurrency, depth, and fan-out limits remain authoritative. Substantive, multi-file, risky, and architecture-sensitive work uses a CLI workflow; genuinely small bounded operations may remain direct. Report a blocker when a required workflow runtime is unavailable. Go works directly without specialists.`;
+	const capacityInstructions = threads === void 0 || depth === void 0 ? "Before delegation, use active collaboration tool instructions as the authoritative agent-capacity limit." : `Host agent capacity: agents.max_concurrent_threads_per_session=${threads} includes Root. The active plan's costMax is the hard spend ceiling, maxCalls is the structural call ceiling, and maxConcurrency is the specialist concurrency ceiling. Runtime depth, retry, memory, stack, source-size, and fan-out safety invariants are universal. Substantive, multi-file, risky, and architecture-sensitive work uses a CLI workflow; genuinely small bounded operations may remain direct. Report a blocker when a required workflow runtime is unavailable. Go works directly without specialists.`;
 	const platformInstructions = platform === "win32" ? ` ${WINDOWS_SHELL_POLICY}` : "";
 	const computerUseInstructions = computerUseEnabled ? ` ${COMPUTER_USE_INSTRUCTIONS}` : "";
 	const specializationContext = specializationInstructions(specializations).join(" ");
@@ -6996,13 +6392,11 @@ async function doctor(home = process.env.CODEX_HOME ?? join(homedir(), ".codex")
 	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 ? 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 task-type 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,
-		softSizeGuidance: MODEL_ROUTING_PLANS[plan].workflow.softSizeGuidance
-	}) ? check("workflow", "ok", "workflow-settings-ready", `${plan} workflow target and maximum limits, projected usage, and size guidance match the catalog.`) : check("workflow", "error", "workflow-settings-drift", `${plan} workflow settings do not match the authoritative catalog.`, "Reinstall HolyCodex."));
+		workflow: MODEL_ROUTING_PLANS[plan].workflow
+	}) ? check("workflow", "ok", "workflow-settings-ready", `${plan} workflow budgets and task-type routes 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);
@@ -7413,7 +6807,7 @@ function specializationFailure(name, flag, result) {
 }
 async function removeObsoleteVersionCaches(cacheRoot) {
 	if (!await exists(cacheRoot)) return;
-	for (const entry of await readdir(cacheRoot)) if (entry !== "0.13.8-dev.225.1") await rm(join(cacheRoot, entry), {
+	for (const entry of await readdir(cacheRoot)) if (entry !== "0.14.0") await rm(join(cacheRoot, entry), {
 		recursive: true,
 		force: true
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holycodex",
-  "version": "0.13.8-dev.225.1",
+  "version": "0.14.0",
   "description": "HolyCodex installer, doctor, and cleanup CLI for durable Codex workflows",
   "keywords": [
     "agents",
@@ -42,7 +42,7 @@
     "prepack": "vp run --workspace-root build"
   },
   "dependencies": {
-    "@holycodex/plugin": "0.13.8-dev.225.1",
+    "@holycodex/plugin": "0.14.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {