holycodex 0.13.6 → 0.13.7

package/dist/cli.js

@@ -1,7 +1,7 @@
 import process$1 from "node:process";
 import { access, copyFile, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
-import { delimiter, dirname, join, resolve } from "node:path";
+import { delimiter, dirname, join, resolve, sep } from "node:path";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { Buffer } from "node:buffer";
@@ -4391,11 +4391,12 @@ function superRefine(fn, params) {
 }
 //#endregion
 //#region packages/cli/src/catalog.ts
-var VERSION = "0.13.6";
+var VERSION = "0.13.7";
 var SKILLS = [
 	"ast-grep",
 	"babysit-ci",
 	"code-review",
+	"commit",
 	"compress",
 	"context7-cli",
 	"debugging",
@@ -4408,7 +4409,8 @@ var SKILLS = [
 	"refactor",
 	"remove-slop",
 	"rules",
-	"workflows"
+	"workflows",
+	"writing-for-agents"
 ];
 var AGENTS = _enum([
 	"explorer",
@@ -5077,6 +5079,12 @@ var INSTALL_FLAGS = /* @__PURE__ */ new Set([
 	"--dangerous-codex-autonomous",
 	"--computer-use",
 	"--no-computer-use",
+	"--work",
+	"--no-work",
+	"--web",
+	"--no-web",
+	"--security",
+	"--no-security",
 	"--no-tui",
 	"--fast",
 	"--fast-all",
@@ -5139,6 +5147,14 @@ function parseCliArguments(args) {
 	if (fastFlags.length > 1) throw new Error(`Conflicting Fast flags: ${fastFlags.join(", ")}`);
 	const computerUseFlags = ["--computer-use", "--no-computer-use"].filter((flag) => values.has(flag));
 	if (computerUseFlags.length > 1) throw new Error(`Conflicting Computer Use flags: ${computerUseFlags.join(", ")}`);
+	for (const [label, flags] of [
+		["Work", ["--work", "--no-work"]],
+		["Web", ["--web", "--no-web"]],
+		["Security", ["--security", "--no-security"]]
+	]) {
+		const selected = flags.filter((flag) => values.has(flag));
+		if (selected.length > 1) throw new Error(`Conflicting ${label} flags: ${selected.join(", ")}`);
+	}
 	const planValue = values.get("--plan");
 	const plan = planValue === void 0 ? void 0 : PlanNameSchema.safeParse(planValue);
 	if (plan !== void 0 && !plan.success) throw new Error(`Unknown plan: ${String(planValue)}. Valid plans: ${PLAN_NAMES.join(", ")}.`);
@@ -5156,6 +5172,10 @@ function parseCliArguments(args) {
 	} : { requested: false };
 	const fast = FastModeSchema.parse(values.has("--fast-all") ? "fast-all" : values.has("--fast") ? "fast" : "standard");
 	const computerUse = values.has("--computer-use") ? "enabled" : values.has("--no-computer-use") ? "disabled" : void 0;
+	const choice = (enabled, disabled) => values.has(enabled) ? "enabled" : values.has(disabled) ? "disabled" : void 0;
+	const work = choice("--work", "--no-work");
+	const web = choice("--web", "--no-web");
+	const security = choice("--security", "--no-security");
 	return {
 		action: "run",
 		command,
@@ -5165,6 +5185,9 @@ function parseCliArguments(args) {
 		...maxValue === void 0 ? {} : { maxSubagents: Number(maxValue) },
 		autonomy,
 		...computerUse === void 0 ? {} : { computerUse },
+		...work === void 0 ? {} : { work },
+		...web === void 0 ? {} : { web },
+		...security === void 0 ? {} : { security },
 		fast,
 		verbose: values.has("--verbose")
 	};
@@ -5572,19 +5595,83 @@ function deduplicate(candidates) {
 	return result;
 }
 //#endregion
-//#region packages/cli/src/codex-security.ts
-var CODEX_SECURITY_PLUGIN = {
-	id: "codex-security@openai-curated",
-	marketplace: "openai-curated"
+//#region packages/cli/src/specializations.ts
+var SPECIALIZATION_NAMES = [
+	"work",
+	"web",
+	"security"
+];
+var SPECIALIZATIONS = {
+	work: {
+		label: "Work",
+		plugins: [
+			{
+				id: "documents@openai-primary-runtime",
+				marketplace: "openai-primary-runtime"
+			},
+			{
+				id: "pdf@openai-primary-runtime",
+				marketplace: "openai-primary-runtime"
+			},
+			{
+				id: "presentations@openai-primary-runtime",
+				marketplace: "openai-primary-runtime"
+			},
+			{
+				id: "spreadsheets@openai-primary-runtime",
+				marketplace: "openai-primary-runtime"
+			},
+			{
+				id: "template-creator@openai-primary-runtime",
+				marketplace: "openai-primary-runtime"
+			}
+		],
+		sourceDirectory: "profile-skills/work",
+		instruction: "For document, PDF, presentation, spreadsheet, or reusable-template tasks, use the available Work specialization skills and official plugins."
+	},
+	web: {
+		label: "Web",
+		plugins: [{
+			id: "build-web-apps@openai-curated",
+			marketplace: "openai-curated"
+		}],
+		sourceDirectory: "profile-skills/web",
+		instruction: "For frontend applications, dashboards, games, creative websites, or visual UI work, use the available Web specialization skills and official plugins."
+	},
+	security: {
+		label: "Security",
+		plugins: [{
+			id: "codex-security@openai-curated",
+			marketplace: "openai-curated"
+		}],
+		sourceDirectory: "profile-skills/security",
+		instruction: "For authorized security reviews, audits, scans, threat models, vulnerabilities, or attack paths, use the available Security specialization skills and official plugins."
+	}
+};
+var FRESH_SPECIALIZATION_STATE = {
+	work: "disabled",
+	web: "disabled",
+	security: "disabled"
 };
+var LEGACY_SPECIALIZATION_STATE = {
+	work: "disabled",
+	web: "enabled",
+	security: "enabled"
+};
+/** Returns the enabled specialization names in registry order. */
+function enabledSpecializations(state) {
+	return SPECIALIZATION_NAMES.filter((name) => state[name] === "enabled");
+}
+/** Returns the instruction fragments for enabled specializations. */
+function specializationInstructions(names) {
+	return names.map((name) => SPECIALIZATIONS[name].instruction);
+}
+({ ...SPECIALIZATIONS.security.plugins[0] });
 var COMPUTER_USE_PLUGIN = {
 	id: "computer-use@openai-bundled",
 	marketplace: "openai-bundled"
 };
-var BUILD_WEB_APPS_PLUGIN = {
-	id: "build-web-apps@openai-curated",
-	marketplace: "openai-curated"
-};
+({ ...SPECIALIZATIONS.web.plugins[0] });
 var CODEX_PLUGIN_OPERATIONAL_TIMEOUT_MS = 15e3;
 var CODEX_PACKAGE_BOOTSTRAP_TIMEOUT_MS = 12e4;
 var MAX_CODEX_CATALOG_DIAGNOSTIC_CHARS = 256 * 1024;
@@ -5624,18 +5711,10 @@ var FATAL_POLICY_CODES = /* @__PURE__ */ new Set([
 	"PERMISSION_DENIED",
 	"POLICY_REJECTED"
 ]);
-/** 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 the official Build Web Apps plugin without failing HolyCodex installation. */
-async function installBuildWebApps(runProcess = runManagedProcess, platform = process.platform, env = process.env, options = {}) {
-	return installOfficialPlugin(BUILD_WEB_APPS_PLUGIN, runProcess, platform, env, options);
-}
 /** Verifies one official plugin without installing or enabling it. */
 async function verifyOfficialPlugin(plugin, runProcess = runManagedProcess, platform = process.platform, env = process.env, options = {}) {
 	const runtimeFacts = options.runtimeFacts ?? (runProcess === runManagedProcess ? defaultCodexLauncherRuntimeFacts(platform) : void 0);
@@ -6382,6 +6461,7 @@ var PLAN_PREFIX = "# holycodex plan: ";
 var FAST_MODE_PREFIX = "# holycodex fast: ";
 var WORKFLOW_POLICY_PREFIX = "# holycodex workflow-policy: ";
 var COMPUTER_USE_PREFIX = "# holycodex computer-use: ";
+var SPECIALIZATION_PREFIX = "# holycodex specialization-";
 var OLD_NAMESPACES = [
 	"marketplaces.sisyphuslabs",
 	"plugins.\"omo@sisyphuslabs\"",
@@ -6505,6 +6585,24 @@ function readManagedComputerUse(input) {
 	const value = new RegExp(`^${COMPUTER_USE_PREFIX}(.+)$`, "m").exec(input)?.[1]?.trim();
 	return value === "enabled" || value === "disabled" ? value : void 0;
 }
+/** Reads the explicit managed choice for one optional specialization. */
+function readManagedSpecialization(input, name) {
+	const value = new RegExp(`^${SPECIALIZATION_PREFIX}${name}: (enabled|disabled)$`, "m").exec(input)?.[1];
+	return value === "enabled" || value === "disabled" ? value : void 0;
+}
+/** Reads all explicitly recorded managed specialization choices. */
+function readManagedSpecializations(input) {
+	return Object.fromEntries(SPECIALIZATION_NAMES.flatMap((name) => {
+		const choice = readManagedSpecialization(input, name);
+		return choice === void 0 ? [] : [[name, choice]];
+	}));
+}
+/** Resolves explicit flags, stored choices, and fresh or legacy defaults. */
+function resolveSpecializations(input, choices = {}) {
+	const stored = readManagedSpecializations(input);
+	const defaults = input.includes(START) ? LEGACY_SPECIALIZATION_STATE : FRESH_SPECIALIZATION_STATE;
+	return Object.fromEntries(SPECIALIZATION_NAMES.map((name) => [name, choices[name] ?? stored[name] ?? defaults[name]]));
+}
 /** 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];
@@ -6585,10 +6683,11 @@ function mergedStatusLine(original) {
 	return `[${items.map((item) => JSON.stringify(item)).join(", ")}]`;
 }
 /** Installs config. */
-function installConfig(input, mode, _platform, requestedPlan, maxSubagents, fastMode = "standard", computerUse) {
+function installConfig(input, mode, _platform, requestedPlan, maxSubagents, fastMode = "standard", computerUse, specializations = {}) {
 	const request = normalizeRequestedAutonomy(mode);
 	const plan = requestedPlan ?? readManagedPlan(input) ?? "plus";
 	const effectiveComputerUse = computerUse ?? readManagedComputerUse(input) ?? "disabled";
+	const effectiveSpecializations = resolveSpecializations(input, specializations);
 	const priorAutonomy = readAutonomyMetadata(input);
 	const previousOriginalRoot = readOriginalRootMetadata(input);
 	const legacyGeneratedRoot = readLegacyGeneratedRoot(input);
@@ -6647,7 +6746,7 @@ function installConfig(input, mode, _platform, requestedPlan, maxSubagents, fast
 		limits: workflow.limits,
 		projectedUsage: workflow.projectedUsage,
 		softSizeGuidance: workflow.softSizeGuidance
-	})}\n${AUTONOMY_METADATA_PREFIX}${effectiveAutonomy}\n${COMPUTER_USE_PREFIX}${effectiveComputerUse}\n${original}${originalPermissionMetadata(permissionLines)}${model}${effort}web_search = ${JSON.stringify(webSearch)}\nmodel_verbosity = "low"\nservice_tier = "${rootServiceTier}"\n${rootPermissionLines.join("\n")}\n${END}`;
+	})}\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];
 	configured = injectTableKeys(configured, "features", [
@@ -6755,20 +6854,23 @@ 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` instead own their exact heading and intent as the first visible block; no other mode prints a heading. Do not conceal orchestration. Give concise updates naming each specialist type and what it will do, such as \"Explorer maps X\", \"Librarian verifies Y\", or \"Worker implements Z\". Do not disclose Root orchestration mechanics or explain why delegation is running unless asked. Skills govern method only. Root owns interaction, intent, scope, architecture, product choices, ambiguity, integration, external state, and final judgment and verification. Root is not another implementation branch: evaluate specialist output against scope, fixed architecture, user decisions, repository conventions, and proof; reject or repair weak output and integrate only accepted work. On every plan other than Go, use a CLI workflow for substantive discovery, implementation, verification, multi-file work, risky changes, or architecture-sensitive work. Root may work directly for genuinely small bounded operations such as repository synchronization, one quick mechanical edit, or an equivalent one-off change. State when the direct-work exception applies, and never use it to bypass delegation for broader work. Never invoke regular Codex collaboration subagents. If a required workflow is unavailable or cannot perform the operation, report the blocker instead of bypassing delegation. Missing task-child visibility is not a reason to avoid workflows. Go does not support workflows, so Root works directly without specialist subagents. A task may contain multiple sequential workflows. Prefer the smallest useful fan-out, stop discovery when evidence is sufficient, and avoid duplicate investigation. The selected plan is authoritative: enforce its permitted model routes for each agent and stage, low verbosity, Fast as the only service-tier variation, concurrency, soft target calls, hard maximum calls, workflow depth, retries, loop iterations, fan-out, projected usage, and soft-size guidance. Root should remain near target calls and exceed them only when intermediate evidence justifies more work; the hard maximum is only a safety and quota ceiling. Larger plans do not automatically consume larger allowances. Keep explorer, librarian, and worker selectable only where the plan permits. Root owns workflow integration and final proof. After any code or manifest implementation, Root loads `code-review` exactly once before final response; it also loads `code-review` for a user-requested snippet, file, directory, diff, patch, or PR review. That skill owns the final audit, repair, proportional checks and reruns, reinspection, diff, and status. Classify unknowns: delegate facts, ask material decisions, and state and use safe reversible defaults. Whenever Root needs user input or would ask any question, it must use `request_user_input` when that tool is available, in every scenario and mode. Root must never stop or reply with a plain-text question when the tool is available. If the tool is unavailable, use a safe reversible default where possible or report a non-question blocker. Never repeat questions or ask discoverable facts. Root must use `request_user_input` immediately before committing, pushing, creating or moving tags, building or compiling, publishing, deploying, destructive or irreversible actions, permission changes, financial actions, sending, or any other externally visible action. Earlier general authorization does not replace this immediate approval unless the user explicitly authorized that exact action in the current turn. Root controls browser and native desktop UI itself. Explorer is repository-read-only, Librarian research-only, and Worker cannot alter dashboards, accounts, permissions, or external state. Specialists never delegate, broaden, review, or make final judgments.";
-var NATIVE_IO_INSTRUCTIONS = "For `plan` and `plan-review` headings, never print provisionally. 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, moves, and deletion. Use available native read or shell tools for file inspection and repository search. Do not re-read files only to verify a successful `apply_patch` call.";
+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. 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 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: own interaction, scope, architecture, product and risk decisions, workflow integration, material ambiguity, external state, and the final decision. Luna specialists are bounded execution context: Explorer maps sufficient repository facts, Librarian verifies assigned current facts, and Worker implements, integrates, inspects diffs, runs checks, performs mechanical repair and retest, routine review, evidence compression, and optional synthesis. Root trusts successful Luna mechanical evidence without rerunning it; for qualifying work, Root still inspects the actual relevant final diff or hunks and minimal ownership or interface context after Luna review. A specialist claim that architecture, taste, or mergeability is good is insufficient. Material architecture, product, scope, risk, or contradictory-evidence decisions return to Root. When retained context is valid, prefer it with compact outcomes, Luna-local loops and synthesis, sufficient discovery, and genuine concurrency without changing plan quotas. Structured substantive outcomes are the branching contract, not prose parsing. Escalate Luna high to xhigh to max only when the evidence justifies it and the active plan permits the route; max insufficiency returns compact evidence to Root and never creates a Sol specialist.";
-var ROOT_DESIGN_GATE_POLICY = "Use the existing shouldUseRootDesignGate decision for both 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 the owner and seam, data and control flow, stable interfaces, state and policy location, exclusions, duplication seam, errors and recovery, tests, compatibility, and why the chosen shape is preferred when real alternatives exist. After Luna routine review, qualifying work requires Root to inspect actual relevant final diff or hunks with only minimal surrounding ownership or interface context, compare the compact approved design contract with the implementation, and own the complete final judgment: architectural fit, ownership and dependency direction, scope and cohesion, abstraction and API shape, repository-native taste and maintainability, mergeability, and readiness. Root may direct at most one bounded Luna repair within the active plan's existing quotas, followed by affected-diff reinspection. This is a compact constraint gate, not a mandatory extra model call, independent Root review execution, workflow restart, or second plan. Root does not repeatedly narrate unchanged workflow or status snapshots. Repository-native evidence from source, tests, configuration, commands, diff, and status is authoritative for implementation facts. If repository evidence conflicts with the approved constraint, architecture, scope, or another material decision, escalate to Root rather than resolving it silently.";
-var WORKER_BRIEF_POLICY = "Root gives Worker a compact constraint/outcome brief containing a concrete objective and outcome, intended owner and seam, literal scope and exclusions with allowed boundaries, relevant components, existing mechanism to extend, invariants and stable interfaces, required behavior, data and control flow, state and policy location, error and recovery obligations, compatibility, proof obligations and the exact repository-native tests or checks that prove them, the standard structured outcome fields, and stop and escalation conditions when relevant. Valid retained context may avoid repeating unchanged constraints; continuation or repair must identify changed constraints and the exact next action, and workflows must not summarize away required constraints. Worker follows that brief, does not rediscover architecture or make material choices, and returns the unchanged SPECIALIST_OUTCOME_SCHEMA. Luna owns correctness, completeness, regression checks, tests, diagnostics, compatibility, changed-file inspection, bounded repair, local naming, duplication and complexity cleanup, and compact structured evidence. Worker may perform one warranted bounded behavior-preserving diff-level taste pass for clarity, naming, duplication, or avoidable complexity in changed files only; it must preserve behavior, interfaces, ownership, and scope and then stop. Worker routine review and repair stay within that seam. Material architecture, ownership, scope, product, or stable-interface conflicts return needs_root_decision with exact evidence. Root retains final judgment and reports only meaningful lifecycle transitions, errors, decisions, or required user action while suppressing unchanged status narration; existing CLI follow filtering remains unchanged.";
+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. 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_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 compact constraint/outcome brief with concrete objective and outcome, intended owner and seam, literal scope and exclusions with allowed boundaries, relevant components, existing mechanism to extend, invariants and stable interfaces, required behavior, data and control flow, state and policy location, error and recovery obligations, compatibility, proof obligations and the exact repository-native tests or checks that prove them, the standard structured outcome fields, and stop and escalation conditions. Retained context may omit unchanged constraints; continuation or repair must identify changed constraints and the exact next action. Worker follows the brief 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**.";
 /** Gets core instructions with platform and active agent-capacity context. */
-function coreInstructions(platform, capacity, computerUseEnabled = false, pluginRoot) {
+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 does not support workflows, so Root works directly without specialist subagents.`;
+	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 platformInstructions = platform === "win32" ? ` ${WINDOWS_SHELL_POLICY}` : "";
-	return `${CORE_INSTRUCTIONS} ${ROOT_LUNA_POLICY} ${ROOT_DESIGN_GATE_POLICY} ${WORKER_BRIEF_POLICY} ${LITE_WRITING_POLICY} ${CONTEXT7_POLICY} ${NATIVE_IO_INSTRUCTIONS}${computerUseEnabled ? ` ${COMPUTER_USE_INSTRUCTIONS}` : ""} ${CODE_REVIEW_ACTIVATION_POLICY} ${capacityInstructions}${platformInstructions}${pluginRoot === void 0 ? "" : ` ${formatInstalledRuntimeGuidance(pluginRoot)}`}`;
+	const computerUseInstructions = computerUseEnabled ? ` ${COMPUTER_USE_INSTRUCTIONS}` : "";
+	const specializationContext = specializationInstructions(specializations).join(" ");
+	const runtimeGuidance = pluginRoot === void 0 ? "" : ` ${formatInstalledRuntimeGuidance(pluginRoot)}`;
+	return `${CORE_INSTRUCTIONS} ${ROOT_LUNA_POLICY} ${ROOT_DESIGN_GATE_POLICY} ${WORKER_BRIEF_POLICY} ${LITE_WRITING_POLICY} ${CONTEXT7_POLICY} ${NATIVE_IO_INSTRUCTIONS}${computerUseInstructions}${specializationContext ? ` ${specializationContext}` : ""} ${CODE_REVIEW_ACTIVATION_POLICY} ${capacityInstructions}${platformInstructions}${runtimeGuidance}`;
 }
 //#endregion
 //#region packages/cli/src/doctor.ts
@@ -6841,14 +6943,16 @@ async function doctor(home = process.env.CODEX_HOME ?? join(homedir(), ".codex")
 	} catch {
 		checks.push(check("config", "error", "config-missing", `Missing ${configPath}.`, "Run holycodex install."));
 	}
+	const specializationState = resolveSpecializations(config);
 	const missing = await missingFiles(pluginRoot, [
 		".codex-plugin/plugin.json",
 		"hooks/hooks.json",
 		...requiredPackageRuntimes(runtime.platform).map((file) => `runtime/${file}`),
 		...AGENTS.map((name) => `agents/${name}.toml`),
-		...SKILLS.map((name) => `skills/${name}/SKILL.md`)
+		...SKILLS.map((name) => `skills/${name}/SKILL.md`),
+		...enabledSpecializations(specializationState).map((name) => `skills/${name}/SKILL.md`)
 	]);
-	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."));
+	checks.push(missing.length === 0 ? check("package", "ok", "package-ready", `Plugin ${VERSION}, runtimes, agents, and ${SKILLS.length} base 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 computerUse = readManagedComputerUse(config);
@@ -6859,6 +6963,15 @@ async function doctor(home = process.env.CODEX_HOME ?? join(homedir(), ".codex")
 		const verification = instructionsActive ? await verifyComputerUse(runtime) : { status: "missing" };
 		checks.push(!instructionsActive ? check("computer-use", "error", "computer-use-instructions-missing", "Computer Use is enabled, but Root-only Computer Use guidance is not active.", "Reinstall HolyCodex.") : verification.status === "verified" ? check("computer-use", "ok", "computer-use-ready", `Computer Use is enabled and the official plugin is installed and enabled via ${verification.launcherSource}.`) : verification.status === "missing" ? check("computer-use", "error", "computer-use-plugin-missing", "Computer Use is enabled, but the official plugin is not installed and enabled.", "Run holycodex install --computer-use.") : verification.reason === "unsupported" ? check("computer-use", "error", "computer-use-incompatible", "Computer Use is enabled, but the official plugin is incompatible with this Codex runtime or platform.", "Upgrade Codex or disable Computer Use with holycodex install --no-computer-use.") : verification.reason === "marketplace-unavailable" || verification.reason === "timeout" ? check("computer-use", "error", "computer-use-plugin-unavailable", `Computer Use is enabled, but the official marketplace could not be reached (${verification.reason}).`, "Restore Codex marketplace access and run holycodex install --computer-use.") : check("computer-use", "error", "computer-use-installation-failed", `Computer Use is enabled, but installation or verification failed (${verification.reason}).`, "Resolve the reported Codex authentication, permission, configuration, or verification failure and run holycodex install --computer-use."));
 	}
+	for (const name of SPECIALIZATION_NAMES) {
+		if (specializationState[name] === "disabled") {
+			checks.push(check(`${name}-specialization`, "ok", `${name}-disabled`, `${SPECIALIZATIONS[name].label} specialization is explicitly disabled; no official plugin or profile guidance is required.`));
+			continue;
+		}
+		const instructionsActive = !missing.includes(`skills/${name}/SKILL.md`) && coreInstructions(runtime.platform, void 0, false, void 0, [name]).includes(SPECIALIZATIONS[name].instruction);
+		const verification = instructionsActive ? await verifySpecialization(name, runtime) : { status: "missing" };
+		checks.push(!instructionsActive ? check(`${name}-specialization`, "error", `${name}-instructions-missing`, `${SPECIALIZATIONS[name].label} specialization is enabled, but its guidance is not active.`, `Reinstall HolyCodex with --${name}.`) : verification.status === "verified" ? check(`${name}-specialization`, "ok", `${name}-ready`, `${SPECIALIZATIONS[name].label} specialization is enabled and its official plugin is installed and enabled via ${verification.launcherSource}.`) : check(`${name}-specialization`, "error", `${name}-plugin-missing`, `${SPECIALIZATIONS[name].label} specialization is enabled, but its official plugin is not installed and enabled.`, `Run holycodex install --${name}.`));
+	}
 	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."));
@@ -6923,6 +7036,29 @@ async function verifyComputerUse(runtime) {
 	};
 	return verifyOfficialPlugin(COMPUTER_USE_PLUGIN, runProcess, runtime.platform, process.env);
 }
+async function verifySpecialization(name, runtime) {
+	const runProcess = async (input) => {
+		const result = await runtime.command(input.command, input.args, input.env);
+		return {
+			exitCode: result.ok ? 0 : 1,
+			stdout: result.ok ? result.output : "",
+			stderr: result.ok ? "" : result.output,
+			timedOut: false,
+			matched: false,
+			outputTruncated: false
+		};
+	};
+	let verified;
+	for (const plugin of SPECIALIZATIONS[name].plugins) {
+		const result = await verifyOfficialPlugin(plugin, runProcess, runtime.platform, process.env);
+		if (result.status !== "verified") return result;
+		verified = result;
+	}
+	return verified ?? {
+		status: "missing",
+		attemptedLaunchers: []
+	};
+}
 //#endregion
 //#region packages/cli/src/files.ts
 /** Provides exists. */
@@ -7080,6 +7216,7 @@ async function installOnce(options, runtime) {
 	const existingConfig = await readText(target.config);
 	const plan = options.plan ?? readManagedPlan(existingConfig) ?? "plus";
 	const computerUseChoice = resolveComputerUseChoice(options, existingConfig);
+	const specializations = resolveSpecializationState(options, existingConfig);
 	const root = backupRoot();
 	notify(options, "backup", "Backing up existing installation", "running");
 	const configBackup = await backup(target.config, root);
@@ -7096,7 +7233,7 @@ async function installOnce(options, runtime) {
 	notify(options, "configuration", "Preparing configuration", "running");
 	const previousPlan = readManagedPlan(existingConfig);
 	const fastMode = options.fast ?? "standard";
-	const config = installConfig(existingConfig, options.autonomy, runtime.platform, plan, options.maxSubagents, fastMode, computerUseChoice);
+	const config = installConfig(existingConfig, options.autonomy, runtime.platform, plan, options.maxSubagents, fastMode, computerUseChoice, specializations);
 	notify(options, "configuration", "Preparing configuration", "complete", plan);
 	notify(options, "staging", "Staging plugin and agent files", "running");
 	const existingAgentPreferences = await readAgentPreferences(target.agents, previousPlan);
@@ -7104,19 +7241,25 @@ async function installOnce(options, runtime) {
 	const stagedCache = join(staging, "cache");
 	const stagedAgents = join(staging, "agents");
 	const sourcePluginRoot = runtime.pluginRoot ?? pluginRoot;
-	await cp(sourcePluginRoot, stagedCache, { recursive: true });
-	await writeInstalledAgents(join(stagedCache, "agents"), runtime.platform, plan, fastMode);
+	const profileRoot = join(sourcePluginRoot, "profile-skills");
+	await cp(sourcePluginRoot, stagedCache, {
+		recursive: true,
+		filter: (source) => source !== profileRoot && !source.startsWith(`${profileRoot}${sep}`)
+	});
+	await stageSpecializationSkills(stagedCache, sourcePluginRoot, specializations);
+	await writeInstalledAgents(join(stagedCache, "agents"), runtime.platform, plan, fastMode, enabledSpecializations(specializations));
 	await cp(join(sourcePluginRoot, "agents"), stagedAgents, { recursive: true });
-	await writeInstalledAgents(stagedAgents, runtime.platform, plan, fastMode);
+	await writeInstalledAgents(stagedAgents, runtime.platform, plan, fastMode, enabledSpecializations(specializations));
 	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);
+	await validateStaging(stagedCache, stagedAgents, specializations);
 	notify(options, "validation", "Validating staged installation", "complete");
 	const removedLegacy = [];
 	let codexSecurity;
 	let computerUse;
 	let buildWebApps;
+	let work;
 	try {
 		notify(options, "managed-files", "Installing managed files", "running");
 		await atomicWrite(target.config, config);
@@ -7138,7 +7281,7 @@ async function installOnce(options, runtime) {
 		}
 		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);
+		codexSecurity = await installSelectedSpecializationPlugin("security", specializations.security, options.security !== void 0, runtime);
 		notify(options, "codex-security", "Installing Codex Security", "complete", pluginProgressDetail(codexSecurity));
 		notify(options, "computer-use", "Installing Computer Use", "running");
 		if (computerUseChoice === "enabled") {
@@ -7151,8 +7294,11 @@ async function installOnce(options, runtime) {
 			notify(options, "computer-use", "Computer Use disabled", "complete", "disabled");
 		}
 		notify(options, "build-web-apps", "Installing Build Web Apps", "running");
-		buildWebApps = await installBuildWebApps(runtime.runProcess, runtime.platform, process.env);
+		buildWebApps = await installSelectedSpecializationPlugin("web", specializations.web, options.web !== void 0, runtime);
 		notify(options, "build-web-apps", "Installing Build Web Apps", "complete", pluginProgressDetail(buildWebApps));
+		if (specializations.work === "enabled") notify(options, "work", "Installing Work", "running");
+		work = await installWorkSpecialization(specializations.work, options.work !== void 0, runtime);
+		if (specializations.work === "enabled") notify(options, "work", "Installing Work", "complete", work.status === "disabled" ? "disabled" : `${Object.keys(work.plugins).length} plugins`);
 		notify(options, "cleanup", "Removing obsolete caches", "running");
 		await removeObsoleteVersionCaches(target.cacheRoot);
 		notify(options, "cleanup", "Removing obsolete caches", "complete");
@@ -7183,12 +7329,20 @@ async function installOnce(options, runtime) {
 		plan,
 		codexSecurity,
 		computerUse,
-		buildWebApps
+		buildWebApps,
+		work
 	};
 }
 function resolveComputerUseChoice(options, existingConfig) {
 	return options.computerUse ?? readManagedComputerUse(existingConfig) ?? "disabled";
 }
+function resolveSpecializationState(options, existingConfig) {
+	return resolveSpecializations(existingConfig, {
+		...options.work === void 0 ? {} : { work: options.work },
+		...options.web === void 0 ? {} : { web: options.web },
+		...options.security === void 0 ? {} : { security: options.security }
+	});
+}
 function computerUseFailure(result) {
 	const reason = result.reason.replaceAll("-", " ");
 	return /* @__PURE__ */ new Error(`Computer Use is enabled, but the official plugin could not be installed or verified (${reason}). Re-run with --computer-use after resolving the Codex launcher or marketplace issue, or choose --no-computer-use.`);
@@ -7202,23 +7356,64 @@ function notify(options, step, label, status, detail) {
 	});
 }
 function pluginProgressDetail(result) {
+	if (result.status === "disabled") return "disabled";
 	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) {
+async function validateStaging(cache, agents, specializations) {
 	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`))
+		...AGENTS.map((agent) => join(agents, `${agent}.toml`)),
+		...enabledSpecializations(specializations).map((name) => join(cache, "skills", name, "SKILL.md"))
 	];
 	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 stageSpecializationSkills(cache, sourcePluginRoot, state) {
+	const skillsRoot = join(cache, "skills");
+	for (const name of enabledSpecializations(state)) {
+		const source = join(sourcePluginRoot, SPECIALIZATIONS[name].sourceDirectory);
+		if (!await exists(source)) continue;
+		for (const entry of await readdir(source, { withFileTypes: true })) await cp(join(source, entry.name), join(skillsRoot, entry.name), { recursive: true });
+	}
+}
+async function installSelectedSpecializationPlugin(name, choice, explicitlyRequested, runtime) {
+	if (choice === "disabled") return { status: "disabled" };
+	const plugin = SPECIALIZATIONS[name].plugins[0];
+	const result = await installOfficialPluginSafely(plugin.id, plugin, runtime);
+	if (result.status === "skipped" && explicitlyRequested) throw specializationFailure(SPECIALIZATIONS[name].label, name, result);
+	return result;
+}
+async function installWorkSpecialization(choice, explicitlyRequested, runtime) {
+	if (choice === "disabled") return { status: "disabled" };
+	const plugins = {};
+	for (const plugin of SPECIALIZATIONS.work.plugins) {
+		const result = await installOfficialPluginSafely(plugin.id, plugin, runtime);
+		if (result.status === "skipped" && explicitlyRequested) throw specializationFailure(plugin.id, "work", result);
+		plugins[plugin.id] = result;
+	}
+	return {
+		status: "enabled",
+		plugins
+	};
+}
+async function installOfficialPluginSafely(pluginName, plugin, runtime) {
+	try {
+		return await installOfficialPlugin(plugin, runtime.runProcess, runtime.platform, process.env);
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		throw new Error(`Official plugin ${pluginName} could not be installed or verified: ${detail}`);
+	}
+}
+function specializationFailure(name, flag, result) {
+	return /* @__PURE__ */ new Error(`${name} specialization is enabled, but the official plugin could not be installed or verified (${result.reason}). Re-run with --no-${flag} after resolving the Codex launcher or marketplace issue.`);
+}
 async function removeObsoleteVersionCaches(cacheRoot) {
 	if (!await exists(cacheRoot)) return;
-	for (const entry of await readdir(cacheRoot)) if (entry !== "0.13.6") await rm(join(cacheRoot, entry), {
+	for (const entry of await readdir(cacheRoot)) if (entry !== "0.13.7") await rm(join(cacheRoot, entry), {
 		recursive: true,
 		force: true
 	});
@@ -7303,12 +7498,12 @@ 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 writeInstalledAgents(root, platform, plan, fastMode) {
+async function writeInstalledAgents(root, platform, plan, fastMode, specializations) {
 	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 = composeAgentPolicies(source, platform, specializations);
 		source = replaceTomlString(source, "model", route.model);
 		source = replaceTomlString(source, "model_reasoning_effort", route.reasoningEffort);
 		source = replaceTomlString(source, "model_verbosity", "low");
@@ -7316,11 +7511,12 @@ async function writeInstalledAgents(root, platform, plan, fastMode) {
 		await atomicWrite(path, source);
 	}));
 }
-function composeAgentPolicies(input, platform) {
+function composeAgentPolicies(input, platform, specializations) {
 	const policy = [
 		LITE_WRITING_POLICY,
 		CONTEXT7_POLICY,
-		...platform === "win32" ? [WINDOWS_SHELL_POLICY] : []
+		...platform === "win32" ? [WINDOWS_SHELL_POLICY] : [],
+		...specializationInstructions(specializations)
 	].join("\n\n");
 	return input.replace(/(developer_instructions\s*=\s*"""\r?\n)/, `$1${policy}\n\n`);
 }
@@ -7426,12 +7622,18 @@ ${section("OPTIONS")}
   --json                          Print machine-readable output
   --computer-use                  Enable and verify the official Computer Use plugin
   --no-computer-use               Keep Computer Use disabled
+  --work                          Enable Work plugins and skills
+  --no-work                       Keep Work disabled
+  --web                           Enable Web plugins and skills
+  --no-web                        Keep Web disabled
+  --security                      Enable Security plugins and skills
+  --no-security                   Keep Security disabled
 `;
 }
 /** 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)}${text === "Options:" ? "\n  --computer-use                  Enable and verify the official Computer Use plugin\n  --no-computer-use               Keep Computer Use disabled" : ""}`;
+	const section = (text) => `${paint(color, BOLD, text)}${text === "Options:" ? "\n  --computer-use                  Enable and verify the official Computer Use plugin\n  --no-computer-use               Keep Computer Use disabled\n  --work                          Enable Work plugins and skills\n  --no-work                       Keep Work disabled\n  --web                           Enable Web plugins and skills\n  --no-web                        Keep Web disabled\n  --security                      Enable Security plugins and skills\n  --no-security                   Keep Security disabled" : ""}`;
 	return `${title}
 
 ${section("Usage:")}
@@ -7450,6 +7652,12 @@ ${section("Options:")}
   --codex-autonomous              Never ask; keep workspace sandbox
   --no-codex-autonomous           Safe interactive defaults
   --dangerous-codex-autonomous    Never ask; disable filesystem sandbox
+  --work                          Enable Work plugins and skills
+  --no-work                       Keep Work disabled
+  --web                           Enable Web plugins and skills
+  --no-web                        Keep Web disabled
+  --security                      Enable Security plugins and skills
+  --no-security                   Keep Security disabled
   -h, --help                      Show help
 
 Plans provide increasing expected model usage and capability. Fast flags are mutually exclusive.
@@ -7489,15 +7697,22 @@ function renderOfficialPlugins(result) {
 	return [
 		renderOfficialPlugin("Codex Security", result.codexSecurity),
 		renderComputerUse(result.computerUse),
-		renderOfficialPlugin("Build Web Apps", result.buildWebApps)
+		renderOfficialPlugin("Build Web Apps", result.buildWebApps),
+		renderWork(result.work)
 	].join("");
 }
+function renderWork(result) {
+	if (result === void 0) return "";
+	if (result.status === "disabled") return "\n  Work is disabled.";
+	return `\n  Work is enabled (${Object.keys(result.plugins).length} official plugins selected).`;
+}
 function renderComputerUse(result) {
 	if (result?.status === "disabled") return "\n  Computer Use is disabled.";
 	return renderOfficialPlugin("Computer Use", result);
 }
 function renderOfficialPlugin(name, plugin) {
 	if (plugin === void 0) return "";
+	if (plugin.status === "disabled") return `\n  ${name} is disabled.`;
 	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.`;
@@ -7545,6 +7760,9 @@ async function main(args = process$1.argv.slice(2)) {
 	const options = {
 		autonomy: parsed.autonomy,
 		...parsed.computerUse === void 0 ? {} : { computerUse: parsed.computerUse },
+		...parsed.work === void 0 ? {} : { work: parsed.work },
+		...parsed.web === void 0 ? {} : { web: parsed.web },
+		...parsed.security === void 0 ? {} : { security: parsed.security },
 		fast: parsed.fast,
 		json: parsed.json,
 		...parsed.plan === void 0 ? {} : { plan: parsed.plan },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holycodex",
-  "version": "0.13.6",
+  "version": "0.13.7",
   "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.6",
+    "@holycodex/plugin": "0.13.7",
     "zod": "^4.4.3"
   },
   "devDependencies": {