@kisev/agentomatic 11.0.2 → 12.0.0-dev.113.g1bd7385234c6

package/dist/cli.js

@@ -1,1258 +1,2 @@
 #!/usr/bin/env node
-import { AgentProfileError, applyAgentProfileChange, availableModels, availableModelVariants, FIXED_AGENT_ROLES, listAgentProfiles, previewAgentProfileChange, validateAgentName, validateModel, validateVariant, } from "./agent-profiles.js";
-import { renderConfigSetup, renderDoctor, renderInventory, renderPlan, renderReconcile, scopeArguments, shellCommand, terminalSafe, } from "./cli-output.js";
-import { collectDoctorFacts, doctorExitCode } from "./doctor.js";
-import { CATALOG } from "./catalog.js";
-import { applyConfigSetup, CONFIG_FRAGMENTS, CONFIG_TARGETS, defaultConfigSelection, normalizeConfigSelection, previewConfigSetup, recoverConfigSetup, } from "./config-setup.js";
-import { apply, defaultSelection, InstallerError, normalizeSelection, preview, SELECTABLE_PLUGINS, SKILL_COMMANDS, } from "./installer.js";
-import { LifecycleError } from "./lifecycle.js";
-import { skillsInstallerSpec } from "./package-metadata.js";
-import { applyReconcile, previewReconcile } from "./reconcile.js";
-import { confirmQuestion, promptText, selectOption, selectOptions } from "./terminal-wizard.js";
-import { Command, Option, common, applyConfig, configFileSync, reporter } from "./generated/cli.js";
-let diagnostics;
-let machineOutput = false;
-let diagnosticJSON = false;
-function parseOptions(values) {
-    const parser = common(new Command()
-        .exitOverride()
-        .helpOption(false)
-        .configureOutput({ writeErr: () => { } }), "AGENTOMATIC").argument("[name]");
-    for (const [flags, description] of [
-        ["--global", "global user scope"],
-        ["--dry-run", "preview changes"],
-        ["--yes", "explicitly confirm the displayed operation"],
-        ["--core", "activate core integration"],
-        ["--no-core", "disable core integration"],
-        ["--provider <value>", "provider"],
-        ["--model <value>", "model"],
-        ["--variant <value>", "reasoning variant"],
-        ["--clear-variant", "clear the variant"],
-        ["--no-dependency", "do not provision dependencies"],
-        ["--commands <value>", "command selection"],
-        ["--skill-commands <value>", "command selection alias"],
-        ["--agents <value>", "agent selection"],
-        ["--plugins <value>", "plugin selection"],
-        ["--targets <value>", "config targets"],
-        ["--fragments <value>", "config fragments"],
-    ]) {
-        const option = new Option(flags, description);
-        if (!["--yes", "--core", "--no-core", "--clear-variant", "--no-dependency"].includes(flags))
-            option.env(`AGENTOMATIC_${option
-                .attributeName()
-                .replace(/[A-Z]/g, (char) => `_${char}`)
-                .toUpperCase()}`);
-        parser.addOption(option);
-    }
-    try {
-        for (const flag of ["--global", "--dry-run", "--yes", "--json", "--no-dependency"])
-            if (values.filter((value) => value === flag).length > 1)
-                throw new Error(`${flag} may be supplied once`);
-        if (values.includes("--core") && values.includes("--no-core"))
-            throw new Error("Use only one core integration option");
-        if (values.includes("--variant") && values.includes("--clear-variant"))
-            throw new Error("Use only one variant option");
-        parser.parse(values, { from: "user" });
-        applyConfig(parser, configFileSync(parser.opts().config));
-        const parsed = parser.opts();
-        machineOutput = parsed.json === true;
-        diagnosticJSON = parsed.logFormat === "json";
-        diagnostics ??= reporter({ ...parsed, progress: parsed.progress ?? "never" });
-        diagnostics.emit({
-            phase: "agentomatic",
-            message: "Validated command options",
-            level: "debug",
-        });
-        const list = (value) => value === undefined
-            ? undefined
-            : Array.isArray(value)
-                ? value.map(String)
-                : String(value) === "none"
-                    ? []
-                    : String(value)
-                        .split(",")
-                        .map((item) => item.trim())
-                        .filter(Boolean);
-        return {
-            scope: parsed.global ? "global" : "project",
-            global: parsed.global === true,
-            dryRun: parsed.dryRun === true,
-            json: parsed.json === true,
-            yes: parsed.yes === true,
-            name: parser.args[0],
-            core: ["cli", "env", "config"].includes(parser.getOptionValueSource("core") ?? "")
-                ? parsed.core
-                : undefined,
-            provider: parsed.provider,
-            model: parsed.model,
-            variant: parsed.clearVariant ? null : parsed.variant,
-            noDependency: parsed.dependency === false,
-            commands: list(parsed.commands ?? parsed.skillCommands),
-            agents: list(parsed.agents),
-            plugins: list(parsed.plugins),
-            configTargets: list(parsed.targets),
-            configFragments: list(parsed.fragments),
-            selectionFlag: [
-                "commands",
-                "skillCommands",
-                "agents",
-                "plugins",
-                "targets",
-                "fragments",
-            ].some((key) => parsed[key] !== undefined),
-        };
-    }
-    catch (error) {
-        throw new InstallerError("invalid_input", error instanceof Error ? error.message : String(error));
-    }
-}
-function helpRows(rows) {
-    const width = Math.max(...rows.map(([label]) => label.length));
-    return rows.map(([label, description]) => `  ${label.padEnd(width)}  ${description}`);
-}
-function commonRows() {
-    const parser = common(new Command("agentomatic"), "AGENTOMATIC");
-    const help = parser.createHelp();
-    return parser.options
-        .filter((option) => option.attributeName() !== "json")
-        .map((option) => [help.optionTerm(option), help.optionDescription(option)]);
-}
-function rootHelp() {
-    return [
-        `agentomatic ${CATALOG.version}`,
-        "",
-        "Manage OpenCode integration assets, agents, diagnostics, and migration state.",
-        `Portable Agent Skills are installed separately with npx --yes ${skillsInstallerSpec()}.`,
-        "",
-        "Usage:",
-        "  agentomatic <command> [options]",
-        "  Add --help after any command or command group for focused guidance.",
-        "",
-        "Commands:",
-        ...helpRows([
-            ["install", "Select and deploy skill commands, agents, and plugin wrappers."],
-            [
-                "uninstall",
-                "Archive and remove exact-owned assets while preserving conflicts and user files.",
-            ],
-            ["config", "Connect the package and recommended fragments into user configuration files."],
-            ["doctor", "Inspect versions, ownership, drift, config, archives, tools, and LSP."],
-            ["capabilities", "Print the versioned commands, agents, plugins, and tools catalog as JSON."],
-            ["reconcile", "Classify current and retired assets; archive exact-owned retired entries."],
-            ["agent list", "List profiles, models, ownership, collisions, and drift."],
-            ["agent configure", "Choose an agent model interactively or with explicit options."],
-            ["agent model-set", "Set one agent model directly without the interactive wizard."],
-            ["agent reconcile", "Re-render package-managed agents from saved profile configuration."],
-            ["critic add", "Add a named critic with a selected model."],
-            ["critic remove", "Remove a package-managed additional critic."],
-        ]),
-        "",
-        "Common options:",
-        ...helpRows([
-            ["--global", "Use global scope; project scope is the default."],
-            ["--dry-run", "Preview a mutation without changing anything."],
-            ["--yes", "Apply without the interactive final confirmation (required outside a terminal)."],
-            ["--json", "Emit stable machine-readable output when supported."],
-            ["--help", "Show this help and exit."],
-            ["--version", "Show the package version and exit."],
-            ...commonRows(),
-        ]),
-        "",
-        "Install selection:",
-        ...helpRows([
-            ["--commands <list|none>", "Select adapters for installed portable skills."],
-            ["--skill-commands <list|none>", "Select adapters for installed portable skills."],
-            ["--agents <list|none>", "Select fixed agents."],
-            ["--plugins <list|none>", "Select optional plugin wrappers; rtk is the default."],
-            ["--core / --no-core", "Toggle plugin entry wiring and npm dependency provisioning."],
-            ["--targets <list|none>", "Select config targets for the config command."],
-            ["--fragments <list|none>", "Select config fragments for the config command."],
-        ]),
-        "  Lists are comma-separated. Outside a TTY, provide command selection, --agents, and --plugins;",
-        "  the config command requires --targets and --fragments.",
-        "",
-        "Agent model options:",
-        ...helpRows([
-            ["--provider <id>", "Provider for a model name that is not provider/model."],
-            ["--model <id>", "Exact provider/model or a model paired with --provider."],
-            ["--variant <id>", "Set an optional model variant."],
-            ["--clear-variant", "Remove the configured variant during agent model-set."],
-        ]),
-        "  Used by agent configure, agent model-set, and critic add.",
-        "",
-        "Safe mutation workflow:",
-        "  1. Run the command with --dry-run.",
-        "  2. Review the target, operations, conflicts, and restart requirement.",
-        "  3. Run the command without --dry-run; confirm the summary when asked",
-        "     (add --yes to skip the question or to apply outside a terminal).",
-        "  4. Restart OpenCode when the applied plan requires it.",
-        "  install and uninstall never edit opencode.json; the config command is the",
-        "  confirmed path for configuration fragments. No command installs portable skills.",
-        "",
-        "Scope behavior:",
-        ...helpRows([
-            ["default", "Targets .opencode under the current directory; run from the project root."],
-            ["--global", "Targets ~/.config/opencode and can run from any directory."],
-        ]),
-        "",
-        "Examples:",
-        `  ${shellCommand(["capabilities", "--json"])}`,
-        `  ${shellCommand(["install", "--global", "--dry-run"])}`,
-        `  ${shellCommand(["doctor", "--global"])}`,
-        `  ${shellCommand([
-            "agent",
-            "model-set",
-            "worker",
-            "--global",
-            "--model",
-            "openai/gpt-5",
-            "--variant",
-            "high",
-            "--dry-run",
-        ])}`,
-        "",
-        "Documentation:",
-        "  https://github.com/kisev/skills/blob/main/docs/how-to/opencode-integration.md",
-        "",
-    ].join("\n");
-}
-function commandHelp(topic, summary, usage, options, behavior, examples) {
-    return [
-        `agentomatic ${CATALOG.version} - ${topic}`,
-        "",
-        summary,
-        "",
-        "Usage:",
-        ...usage.map((line) => `  ${line}`),
-        "",
-        "Options:",
-        ...helpRows(options.map(([flag, description]) => {
-            const match = /^--([a-z][a-z-]*)/.exec(flag);
-            const environment = match &&
-                !["yes", "core", "no-core", "no-dependency", "clear-variant", "help"].includes(match[1]);
-            return [
-                flag,
-                environment
-                    ? `${description} (env: AGENTOMATIC_${match[1].replaceAll("-", "_").toUpperCase()})`
-                    : description,
-            ];
-        })),
-        "",
-        ...helpRows(commonRows()),
-        "",
-        "Behavior:",
-        ...behavior.map((line) => `  ${line}`),
-        "",
-        "Examples:",
-        ...examples.map((line) => `  ${line}`),
-        "",
-    ].join("\n");
-}
-function groupHelp(topic, summary, usage, commands, behavior, examples) {
-    return [
-        `agentomatic ${CATALOG.version} - ${topic}`,
-        "",
-        summary,
-        "",
-        "Usage:",
-        `  ${usage}`,
-        "",
-        "Commands:",
-        ...helpRows(commands),
-        "",
-        "Behavior:",
-        ...behavior.map((line) => `  ${line}`),
-        "",
-        "Examples:",
-        ...examples.map((line) => `  ${line}`),
-        "",
-    ].join("\n");
-}
-function contextualHelp(arguments_) {
-    const [domain, operation] = arguments_.filter((value) => value !== "--help");
-    if (domain === "install")
-        return commandHelp("install", "Select and deploy package-owned OpenCode integration assets.", [
-            "agentomatic install [--global] --dry-run [selection options]",
-            "agentomatic install [--global] [--dry-run | --yes] [selection options]",
-        ], [
-            ["--global", "Use global scope; project scope is the default."],
-            ["--dry-run", "Preview operations without changing anything."],
-            ["--yes", "Apply without the interactive final confirmation."],
-            ["--no-dependency", "Skip provisioning the persistent npm dependency for the core plugin."],
-            ["--commands <list|none>", "Select installed-skill adapters."],
-            ["--skill-commands <list|none>", "Select installed-skill adapters."],
-            ["--agents <list|none>", "Select fixed agents."],
-            ["--plugins <list|none>", "Select optional plugin wrappers; rtk is preselected."],
-            ["--core", "Wire the plugin entry and pin the npm dependency in one run."],
-            ["--no-core", "Skip plugin entry wiring and npm dependency provisioning."],
-            ["--json", "Emit stable machine-readable output."],
-            ["--help", "Show this command help and exit."],
-        ], [
-            "Without selection flags, a TTY opens command, agent, plugin, and core selectors.",
-            "Use Up/Down to move, Space to toggle, A/N for all/none, and Enter to confirm.",
-            "Outside a TTY, provide command selection, --agents, and --plugins.",
-            "Confirmed core integration wires the core-plugin fragment in the same run;",
-            "asset writes never touch opencode.json directly.",
-            "Portable skills are installed separately; restart OpenCode after asset changes.",
-        ], [
-            shellCommand(["install", "--global", "--dry-run"]),
-            shellCommand([
-                "install",
-                "--commands",
-                "doctor,reconcile,agent-profiles",
-                "--agents",
-                "manager,architect,mapper,worker,review,critic",
-                "--plugins",
-                "none",
-                "--dry-run",
-            ]),
-        ]);
-    if (domain === "config")
-        return commandHelp("config", "Connect the package and recommended fragments into user configuration files.", [
-            "agentomatic config [--global] --dry-run [selection options]",
-            "agentomatic config [--global] [--dry-run | --yes] [selection options]",
-            "agentomatic config recover [--global] [--dry-run | --yes]",
-        ], [
-            ["--global", "Use global scope; project scope is the default."],
-            ["--dry-run", "Preview config operations without changing anything."],
-            ["--yes", "Apply without the interactive final confirmation."],
-            ["--targets <list|none>", `Select targets: ${CONFIG_TARGETS.join(", ")}.`],
-            [
-                "--fragments <list|none>",
-                `Select fragments: ${CONFIG_FRAGMENTS.map((item) => item.name).join(", ")}.`,
-            ],
-            ["--json", "Emit stable machine-readable output."],
-            ["--help", "Show this command help and exit."],
-        ], [
-            "In a TTY, target and fragment selectors open when flags are omitted.",
-            "Global scope edits opencode.json(c), tui.json, kilo.json(c), and mimocode.json(c).",
-            "Project scope edits the project opencode.json(c) file only.",
-            "Existing entries, comments, and unrelated keys are preserved; only absent keys are added.",
-            "Writes occur only after the exact confirmation; conflicting fragments are skipped as findings.",
-            "Interrupted config transactions require an explicit config recover preview and confirmation.",
-        ], [
-            shellCommand(["config", "--global", "--dry-run"]),
-            shellCommand([
-                "config",
-                "--global",
-                "--targets",
-                "opencode",
-                "--fragments",
-                "core-plugin,skills-state-permissions",
-                "--dry-run",
-            ]),
-        ]);
-    if (domain === "uninstall")
-        return commandHelp("uninstall", "Remove package-owned integration assets safely.", [
-            "agentomatic uninstall [--global] --dry-run",
-            "agentomatic uninstall [--global] [--dry-run | --yes]",
-        ], [
-            ["--global", "Use global scope; project scope is the default."],
-            ["--dry-run", "Preview removals, archives, and conflicts."],
-            ["--yes", "Apply without the interactive final confirmation."],
-            ["--json", "Emit stable machine-readable output."],
-            ["--help", "Show this command help and exit."],
-        ], [
-            "Archives and removes only exact manifest-owned assets after confirmation.",
-            "Preserves modified and user-owned files, worktrees, runtime state, and portable skills.",
-            "Remove the plugin config entry and npm dependency only after managed assets.",
-        ], [
-            shellCommand(["uninstall", "--global", "--dry-run"]),
-            shellCommand(["uninstall", "--dry-run"]),
-        ]);
-    if (domain === "doctor")
-        return commandHelp("doctor", "Inspect integration health without changing state.", ["agentomatic doctor [--global] [--json]"], [
-            ["--global", "Inspect global scope; project scope is the default."],
-            ["--json", "Emit the complete stable machine-readable report."],
-            ["--help", "Show this command help and exit."],
-        ], [
-            "Creates no receipts and starts no recovery, plugin factories, or LSP servers.",
-            "Reports versions, ownership, drift, collisions, config, archives, tools, and LSP facts.",
-            "Exit status: 0 clean, 1 findings, 2 invalid input or incomplete probing.",
-        ], [shellCommand(["doctor"]), shellCommand(["doctor", "--global", "--json"])]);
-    if (domain === "capabilities")
-        return commandHelp("capabilities", "Print the versioned package capability catalog.", ["agentomatic capabilities [--json]"], [
-            ["--json", "Explicitly request stable JSON output; JSON is the default."],
-            ["--help", "Show this command help and exit."],
-        ], [
-            "Requires no scope and performs no mutation.",
-            "Lists exact skills, commands, agents, plugins, and package tools.",
-        ], [shellCommand(["capabilities", "--json"])]);
-    if (domain === "reconcile")
-        return commandHelp("reconcile", "Classify current and historical assets and retire exact-owned entries.", [
-            "agentomatic reconcile [--global] --dry-run",
-            "agentomatic reconcile [--global] [--dry-run | --yes]",
-        ], [
-            ["--global", "Reconcile global scope; project scope is the default."],
-            ["--dry-run", "Preview classifications, archives, and blockers."],
-            ["--yes", "Apply without the interactive final confirmation."],
-            ["--json", "Emit stable machine-readable output."],
-            ["--help", "Show this command help and exit."],
-        ], [
-            "Preview is read-only and blocks Apply on modified managed files or ownership conflicts.",
-            "Confirmed reconcile archives exact-owned retired package assets.",
-            "Portable skills are managed separately by the skills CLI.",
-        ], [
-            shellCommand(["reconcile", "--global", "--dry-run"]),
-            shellCommand(["reconcile", "--dry-run", "--json"]),
-        ]);
-    if (domain === "agent" && operation === "list")
-        return commandHelp("agent list", "List agent profiles, models, ownership, collisions, and drift.", ["agentomatic agent list [--global] [--json]"], [
-            ["--global", "Inspect global scope; project scope is the default."],
-            ["--json", "Emit stable machine-readable inventory."],
-            ["--help", "Show this command help and exit."],
-        ], ["Read-only inventory; creates no receipts and changes no files or configuration."], [shellCommand(["agent", "list", "--global"]), shellCommand(["agent", "list", "--json"])]);
-    if (domain === "agent" && operation === "configure")
-        return commandHelp("agent configure", "Choose an agent model interactively or with explicit options.", [
-            "agentomatic agent configure [name] [--global] --dry-run",
-            "agentomatic agent configure <name> [--global] --model <provider/model> [--variant <id>] --dry-run",
-            "agentomatic agent configure <name> [--global] --model <provider/model> [--variant <id>] [--dry-run | --yes]",
-        ], [
-            ["--global", "Use global scope; project scope is the default."],
-            ["--provider <id>", "Provider when --model is not provider/model."],
-            ["--model <id>", "Exact provider/model or model paired with --provider."],
-            ["--variant <id>", "Set an optional model variant."],
-            ["--clear-variant", "Remove the configured variant."],
-            ["--dry-run", "Preview the profile change."],
-            ["--yes", "Apply without the interactive final confirmation."],
-            ["--json", "Emit stable machine-readable output."],
-            ["--help", "Show this command help and exit."],
-        ], [
-            "Opens a TTY wizard unless the agent and model are explicit.",
-            "Uses the cached OpenCode model catalog and makes no LLM call.",
-            "The preview normally prints an agent model-set Apply command.",
-        ], [
-            shellCommand(["agent", "configure", "manager", "--global", "--dry-run"]),
-            shellCommand([
-                "agent",
-                "configure",
-                "worker",
-                "--global",
-                "--model",
-                "openai/gpt-5",
-                "--variant",
-                "high",
-                "--dry-run",
-            ]),
-        ]);
-    if (domain === "agent" && operation === "model-set")
-        return commandHelp("agent model-set", "Set one agent model and optional variant directly.", [
-            "agentomatic agent model-set <name> [--global] --model <provider/model> [--variant <id>] --dry-run",
-            "agentomatic agent model-set <name> [--global] --model <provider/model> [--variant <id>] [--dry-run | --yes]",
-        ], [
-            ["--global", "Use global scope; project scope is the default."],
-            ["--provider <id>", "Provider when --model is not provider/model."],
-            ["--model <id>", "Exact provider/model or model paired with --provider."],
-            ["--variant <id>", "Set an optional model variant."],
-            ["--clear-variant", "Remove the configured variant."],
-            ["--dry-run", "Preview the profile change."],
-            ["--yes", "Apply without the interactive final confirmation."],
-            ["--json", "Emit stable machine-readable output."],
-            ["--help", "Show this command help and exit."],
-        ], [
-            "Accepts exact provider/model or a provider and model pair.",
-            "Keeps fixed prompts and permissions unchanged and makes no LLM call.",
-            "Writes only after exact confirmation.",
-        ], [
-            shellCommand([
-                "agent",
-                "model-set",
-                "worker",
-                "--global",
-                "--model",
-                "openai/gpt-5",
-                "--variant",
-                "high",
-                "--dry-run",
-            ]),
-            shellCommand([
-                "agent",
-                "model-set",
-                "manager",
-                "--global",
-                "--model",
-                "openai/gpt-5",
-                "--clear-variant",
-                "--dry-run",
-            ]),
-        ]);
-    if (domain === "agent" && operation === "reconcile")
-        return commandHelp("agent reconcile", "Re-render managed agent files from saved profile configuration.", [
-            "agentomatic agent reconcile [--global] --dry-run",
-            "agentomatic agent reconcile [--global] [--dry-run | --yes]",
-        ], [
-            ["--global", "Use global scope; project scope is the default."],
-            ["--dry-run", "Preview rendered agent changes and conflicts."],
-            ["--yes", "Apply without the interactive final confirmation."],
-            ["--json", "Emit stable machine-readable output."],
-            ["--help", "Show this command help and exit."],
-        ], [
-            "Uses saved models and variants while preserving package prompts and permissions.",
-            "Preserves user-owned files and collisions; writes only after confirmation.",
-        ], [
-            shellCommand(["agent", "reconcile", "--global", "--dry-run"]),
-            shellCommand(["agent", "reconcile", "--dry-run", "--json"]),
-        ]);
-    if (domain === "agent")
-        return groupHelp("agent", "Inspect and manage fixed agents and additional critics.", "agentomatic agent <command> [options]", [
-            ["list", "List profiles, models, ownership, collisions, and drift."],
-            ["configure", "Choose an agent model interactively or with explicit options."],
-            ["model-set", "Set one agent model directly without the interactive wizard."],
-            ["reconcile", "Re-render package-managed agents from saved profile configuration."],
-        ], [
-            "Prompts and permissions remain package-owned.",
-            "Profile configuration changes models, variants, and additional critics.",
-            "Mutations use preview and exact confirmation.",
-        ], [shellCommand(["agent", "list", "--global"]), shellCommand(["agent", "model-set", "--help"])]);
-    if (domain === "critic" && operation === "add")
-        return commandHelp("critic add", "Add an additional named critic with a selected model.", [
-            "agentomatic critic add [name] [--global] --dry-run",
-            "agentomatic critic add <name> [--global] --model <provider/model> [--variant <id>] --dry-run",
-            "agentomatic critic add <name> [--global] --model <provider/model> [--variant <id>] [--dry-run | --yes]",
-        ], [
-            ["--global", "Use global scope; project scope is the default."],
-            ["--provider <id>", "Provider when --model is not provider/model."],
-            ["--model <id>", "Exact provider/model or model paired with --provider."],
-            ["--variant <id>", "Set an optional model variant."],
-            ["--dry-run", "Preview critic creation and pool changes."],
-            ["--yes", "Apply without the interactive final confirmation."],
-            ["--json", "Emit stable machine-readable output."],
-            ["--help", "Show this command help and exit."],
-        ], [
-            "Prefixes names with critic- when needed.",
-            "Uses TTY model selection when the model is omitted and makes no LLM call.",
-            "Updates manager and review critic pools after confirmation.",
-        ], [
-            shellCommand([
-                "critic",
-                "add",
-                "security",
-                "--global",
-                "--model",
-                "anthropic/claude-sonnet-4-6",
-                "--dry-run",
-            ]),
-            shellCommand(["critic", "add", "performance", "--global", "--dry-run"]),
-        ]);
-    if (domain === "critic" && operation === "remove")
-        return commandHelp("critic remove", "Remove a package-managed additional critic.", [
-            "agentomatic critic remove <name> [--global] --dry-run",
-            "agentomatic critic remove <name> [--global] [--dry-run | --yes]",
-        ], [
-            ["--global", "Use global scope; project scope is the default."],
-            ["--dry-run", "Preview critic removal and pool changes."],
-            ["--yes", "Apply without the interactive final confirmation."],
-            ["--json", "Emit stable machine-readable output."],
-            ["--help", "Show this command help and exit."],
-        ], [
-            "Accepts the name with or without the critic- prefix.",
-            "Preserves the fixed critic and user-owned files.",
-            "Updates manager and review critic pools after confirmation.",
-        ], [
-            shellCommand(["critic", "remove", "security", "--global", "--dry-run"]),
-            shellCommand(["critic", "remove", "security", "--dry-run"]),
-        ]);
-    if (domain === "critic")
-        return groupHelp("critic", "Manage additional package-owned critic profiles.", "agentomatic critic <command> [options]", [
-            ["add", "Add a named critic with a selected model."],
-            ["remove", "Remove a package-managed additional critic."],
-        ], [
-            "Names use critic-<safe-suffix>.",
-            "Manager and review critic pools update with profile configuration.",
-            "Mutations use preview and exact confirmation.",
-        ], [
-            shellCommand(["critic", "add", "security", "--help"]),
-            shellCommand(["critic", "remove", "security", "--help"]),
-        ]);
-    return undefined;
-}
-async function interactiveInstallerSelection() {
-    if (!process.stdin.isTTY || !process.stderr.isTTY)
-        throw new InstallerError("terminal_required", "install requires explicit selection flags outside a terminal");
-    process.stderr.write([
-        "Portable skills are installed separately through npx skills.",
-        "This installer does not install, update, or remove portable skills.",
-        "Skill command adapters are OpenCode slash commands that load an already-installed skill with the same name.",
-        "Selecting a command adapter does not select or install its skill.",
-        "\n",
-    ].join("\n"));
-    const group = async (label, names, initialSelected) => {
-        const selected = await selectOptions(label, names, initialSelected, process.stdin, process.stderr);
-        if (selected === null)
-            throw new InstallerError("cancelled", "Wizard cancelled");
-        return selected;
-    };
-    const defaults = defaultSelection();
-    const commands = await group("Skill command adapters", SKILL_COMMANDS, SKILL_COMMANDS);
-    const agents = await group("Fixed agents", defaults.agents, defaults.agents);
-    const plugins = await group("Selectable plugins", SELECTABLE_PLUGINS, defaults.plugins);
-    const core = await selectOption("Core integration: wire the plugin entry and pin the npm dependency?", ["Yes", "No"], process.stdin, process.stderr);
-    if (core === null)
-        throw new InstallerError("cancelled", "Wizard cancelled");
-    return normalizeSelection({
-        commands,
-        agents: agents,
-        plugins: plugins,
-        core_activation: core === 0,
-    });
-}
-function installerSelection(options) {
-    return normalizeSelection({
-        commands: options.commands,
-        agents: options.agents,
-        plugins: options.plugins,
-        ...(options.core === undefined ? {} : { core_activation: options.core }),
-    });
-}
-function configSelectionFromOptions(options) {
-    return {
-        targets: options.configTargets,
-        fragments: options.configFragments,
-    };
-}
-function configSelectionArguments(selection) {
-    return [
-        "--targets",
-        selection.targets.join(",") || "none",
-        "--fragments",
-        selection.fragments.join(",") || "none",
-    ];
-}
-async function interactiveConfigSelection(options) {
-    if (!process.stdin.isTTY || !process.stderr.isTTY)
-        throw new InstallerError("terminal_required", "config requires --targets and --fragments outside a terminal");
-    process.stderr.write([
-        "This command edits user-owned configuration files after an exact confirmation.",
-        "Global scope targets opencode.json(c), tui.json, kilo.json(c), and mimocode.json(c).",
-        "Existing entries, comments, and unrelated keys are preserved.",
-        "\n",
-    ].join("\n"));
-    const defaults = await defaultConfigSelection(options.scope);
-    const availableTargets = options.scope === "project" ? ["opencode"] : CONFIG_TARGETS;
-    const targets = await selectOptions("Config targets", [...availableTargets], defaults.targets.filter((target) => availableTargets.includes(target)), process.stdin, process.stderr);
-    if (targets === null)
-        throw new InstallerError("cancelled", "Wizard cancelled");
-    const availableFragments = CONFIG_FRAGMENTS.filter((fragment) => fragment.targets.some((target) => targets.includes(target))).map((fragment) => fragment.name);
-    if (!availableFragments.length)
-        return normalizeConfigSelection(options.scope, {
-            targets: targets,
-            fragments: [],
-        });
-    const fragments = await selectOptions("Config fragments", availableFragments, defaults.fragments.filter((fragment) => availableFragments.includes(fragment)), process.stdin, process.stderr);
-    if (fragments === null)
-        throw new InstallerError("cancelled", "Wizard cancelled");
-    return normalizeConfigSelection(options.scope, {
-        targets: targets,
-        fragments: fragments,
-    });
-}
-function selectionArguments(selection) {
-    return [
-        "--commands",
-        selection.commands.join(",") || "none",
-        "--agents",
-        selection.agents.join(",") || "none",
-        "--plugins",
-        selection.plugins.join(",") || "none",
-    ];
-}
-function interactiveTerminal() {
-    return Boolean(process.stdin.isTTY && process.stderr.isTTY);
-}
-function requireApplyMode(options) {
-    if (options.dryRun && options.yes)
-        throw new InstallerError("invalid_input", "Use either --dry-run or --yes, not both");
-    if (!options.dryRun && !options.yes && !interactiveTerminal())
-        throw new InstallerError("invalid_input", "Applying outside a terminal requires --yes; use --dry-run to preview");
-}
-async function confirmSummary() {
-    const choice = await confirmQuestion("Apply these changes?");
-    if (choice !== true)
-        throw new InstallerError("cancelled", "Cancelled before apply");
-}
-function applyHint(command) {
-    return `${shellCommand(command)} (confirm interactively; add --yes outside a terminal)`;
-}
-function exactModel(options) {
-    if (!options.model)
-        return undefined;
-    if (options.model.includes("/")) {
-        const model = validateModel(options.model);
-        if (options.provider && model.split("/", 1)[0] !== options.provider)
-            throw new InstallerError("invalid_input", "--provider does not match the exact --model value");
-        return model;
-    }
-    if (!options.provider)
-        throw new InstallerError("invalid_input", "--provider is required when --model is not provider/model");
-    return validateModel(`${options.provider}/${options.model}`);
-}
-async function interactiveSelection(options, action = "model-set") {
-    if (!process.stdin.isTTY || !process.stderr.isTTY) {
-        throw new InstallerError("terminal_required", "agent configure requires a terminal or explicit agent <name> and either exact --model provider/model or --provider + --model");
-    }
-    const inventory = await listAgentProfiles(options.scope);
-    const configurable = inventory.profiles.filter((item) => item.ownership !== "user-owned");
-    let name;
-    if (options.name) {
-        name =
-            action === "critic-add" && !options.name.startsWith("critic-")
-                ? validateAgentName(`critic-${options.name}`)
-                : validateAgentName(options.name);
-    }
-    else if (action === "critic-add") {
-        const raw = await promptText("Critic name (critic-<suffix>):");
-        if (raw === null)
-            throw new InstallerError("cancelled", "Wizard cancelled");
-        name = raw.startsWith("critic-") ? raw : `critic-${raw}`;
-        validateAgentName(name);
-    }
-    else {
-        const agentNames = configurable.map((item) => item.name);
-        if (agentNames.length === 0)
-            agentNames.push(...FIXED_AGENT_ROLES);
-        const index = await selectOption("Select agent:", agentNames);
-        if (index === null)
-            throw new InstallerError("cancelled", "Wizard cancelled");
-        name = agentNames[index];
-    }
-    const currentProfile = configurable.find((item) => item.name === name);
-    const currentModel = currentProfile?.model;
-    const currentVariant = currentProfile?.variant;
-    const showTarget = (model, variant) => {
-        process.stderr.write(`Target: ${model}${variant ? ` / ${variant}` : ""}\n`);
-    };
-    if (options.provider && options.model) {
-        const model = exactModel(options);
-        const variant = validateVariant(options.variant);
-        return { name, model, ...(variant ? { variant } : {}) };
-    }
-    while (true) {
-        const actions = [];
-        if (currentModel) {
-            actions.push(`Keep current (${currentModel}${currentVariant ? ` / ${currentVariant}` : ""})`);
-        }
-        actions.push("Change model");
-        if (currentVariant)
-            actions.push("Clear variant");
-        if (!options.name && action === "model-set")
-            actions.push("Back");
-        actions.push("Cancel");
-        const currentLabel = `Agent: ${name}${currentModel ? ` (current: ${currentModel}${currentVariant ? ` / ${currentVariant}` : ""})` : ""}`;
-        const actionIndex = await selectOption(currentLabel, actions);
-        if (actionIndex === null)
-            throw new InstallerError("cancelled", "Wizard cancelled");
-        const chosen = actions[actionIndex];
-        if (chosen.startsWith("Keep current")) {
-            if (!currentModel)
-                throw new InstallerError("invalid_state", "No current model to keep");
-            showTarget(currentModel, currentVariant);
-            return { name, model: currentModel, ...(currentVariant ? { variant: currentVariant } : {}) };
-        }
-        if (chosen === "Change model") {
-            let models;
-            try {
-                models = await availableModels();
-            }
-            catch (error) {
-                if (error instanceof AgentProfileError && error.code === "catalog_unavailable") {
-                    process.stderr.write("\nModel catalog is unavailable.\nUse direct CLI with exact --model provider/model and optional --variant.\n\n");
-                    throw new InstallerError("catalog_unavailable", "Use direct CLI with exact --model provider/model");
-                }
-                throw error;
-            }
-            const providers = [...new Set(models.map((m) => m.split("/", 1)[0]))].sort();
-            const providerIndex = await selectOption("Select provider:", providers);
-            if (providerIndex === null)
-                continue;
-            const provider = providers[providerIndex];
-            const filteredModels = models.filter((m) => m.startsWith(`${provider}/`));
-            const modelIndex = await selectOption("Select model:", filteredModels);
-            if (modelIndex === null)
-                continue;
-            const selectedModel = filteredModels[modelIndex];
-            let selectedVariant;
-            try {
-                const variants = await availableModelVariants(selectedModel);
-                if (variants.length) {
-                    const variantOptions = ["(none)", ...variants];
-                    const variantIndex = await selectOption("Select variant:", variantOptions);
-                    if (variantIndex === null)
-                        continue;
-                    if (variantIndex > 0)
-                        selectedVariant = variantOptions[variantIndex];
-                }
-            }
-            catch (error) {
-                if (error instanceof AgentProfileError && error.code === "catalog_unavailable") {
-                    process.stderr.write("\nModel variant metadata is unavailable.\nUse direct CLI with exact --model provider/model and optional --variant.\n\n");
-                    throw new InstallerError("catalog_unavailable", "Use direct CLI with exact --model provider/model");
-                }
-                throw error;
-            }
-            showTarget(selectedModel, selectedVariant);
-            return {
-                name,
-                model: selectedModel,
-                ...(selectedVariant ? { variant: selectedVariant } : {}),
-            };
-        }
-        if (chosen === "Clear variant") {
-            if (!currentModel)
-                throw new InstallerError("invalid_state", "No model to clear variant for");
-            showTarget(currentModel);
-            return { name, model: currentModel };
-        }
-        if (chosen === "Back") {
-            return interactiveSelection({ ...options, name: undefined }, action);
-        }
-        if (chosen === "Cancel") {
-            throw new InstallerError("cancelled", "Wizard cancelled");
-        }
-    }
-}
-async function runProfile(request, options) {
-    requireApplyMode(options);
-    if (options.dryRun) {
-        const plan = await previewAgentProfileChange(request, options.scope);
-        if (options.json)
-            process.stdout.write(`${JSON.stringify({ status: "ok", applied: false, requires_restart: false, plan }, null, 2)}\n`);
-        else
-            process.stdout.write(renderPlan(plan, {
-                applied: false,
-                applyHint: applyHint(profileApplyArguments(request, options.scope)),
-            }));
-    }
-    else {
-        if (!options.yes) {
-            const plan = await previewAgentProfileChange(request, options.scope);
-            process.stdout.write(renderPlan(plan, { applied: false }));
-            await confirmSummary();
-        }
-        const applied = await applyAgentProfileChange(request, options.scope);
-        if (options.json)
-            process.stdout.write(`${JSON.stringify(applied, null, 2)}\n`);
-        else
-            process.stdout.write(renderPlan(applied.plan, { applied: true }));
-    }
-}
-function profileApplyArguments(request, scope) {
-    if (request.action === "reconcile")
-        return ["agent", "reconcile", ...scopeArguments(scope)];
-    if (request.action === "critic-remove")
-        return ["critic", "remove", request.name, ...scopeArguments(scope)];
-    const command = request.action === "critic-add"
-        ? ["critic", "add", request.name]
-        : ["agent", "model-set", request.name];
-    command.push(...scopeArguments(scope), "--model", request.model);
-    if (request.variant)
-        command.push("--variant", request.variant);
-    else if (request.action === "model-set")
-        command.push("--clear-variant");
-    return command;
-}
-async function run(arguments_) {
-    const removedScope = arguments_.find((value) => value === "--scope" || value.startsWith("--scope="));
-    if (removedScope)
-        throw new InstallerError("invalid_input", "--scope has been removed; omit it for project scope or use --global");
-    if (arguments_.filter((value) => value === "--global").length > 1)
-        throw new InstallerError("invalid_input", "--global may be supplied once");
-    if (arguments_[0] === "capabilities" && arguments_.includes("--global"))
-        throw new InstallerError("invalid_input", "capabilities accepts only --json");
-    if (arguments_.includes("--help")) {
-        const [domain, operation] = arguments_.filter((value) => !value.startsWith("--"));
-        if ((domain === "agent" &&
-            operation &&
-            !["list", "configure", "model-set", "reconcile"].includes(operation)) ||
-            (domain === "critic" && operation && !["add", "remove"].includes(operation)))
-            throw new InstallerError("invalid_input", `Unknown command: ${domain} ${operation}`);
-        const page = contextualHelp(arguments_);
-        if (!page && arguments_[0] !== "--help")
-            throw new InstallerError("invalid_input", `Unknown command: ${arguments_[0]}`);
-        for (const value of arguments_.filter((item) => item.startsWith("--") && item !== "--help"))
-            if (!(page ?? rootHelp()).includes(value))
-                throw new InstallerError("invalid_input", `Unknown argument: ${value}`);
-        process.stdout.write(page ?? rootHelp());
-        return;
-    }
-    if (arguments_.length === 0) {
-        process.stdout.write(rootHelp());
-        return;
-    }
-    if (arguments_.includes("--version")) {
-        if (arguments_.some((value) => value !== "--version" && value !== "--json"))
-            throw new InstallerError("invalid_input", "--version accepts only --json");
-        process.stdout.write(arguments_.includes("--json")
-            ? `${JSON.stringify({ status: "ok", version: CATALOG.version })}\n`
-            : `${CATALOG.version}\n`);
-        return;
-    }
-    const [domain, operation, ...rest] = arguments_;
-    if (domain === "doctor") {
-        if (operation)
-            rest.unshift(operation);
-        const options = parseOptions(rest);
-        if (options.dryRun ||
-            options.yes ||
-            options.name ||
-            options.provider ||
-            options.model ||
-            options.variant !== undefined ||
-            options.selectionFlag)
-            throw new InstallerError("invalid_input", "doctor accepts only --global and --json");
-        const report = await collectDoctorFacts(options.scope);
-        if (options.json)
-            process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-        else
-            process.stdout.write(renderDoctor(report));
-        process.exitCode = doctorExitCode(report);
-        return;
-    }
-    if (domain === "capabilities") {
-        if (operation)
-            rest.unshift(operation);
-        const options = parseOptions(rest);
-        if (options.dryRun ||
-            options.yes ||
-            options.name ||
-            options.provider ||
-            options.model ||
-            options.variant !== undefined ||
-            options.global ||
-            options.selectionFlag)
-            throw new InstallerError("invalid_input", "capabilities accepts only --json");
-        process.stdout.write(`${JSON.stringify({ schema_version: 1, status: "ok", ...CATALOG }, null, 2)}\n`);
-        return;
-    }
-    if (domain === "reconcile") {
-        if (operation)
-            rest.unshift(operation);
-        const options = parseOptions(rest);
-        if (options.name ||
-            options.provider ||
-            options.model ||
-            options.variant !== undefined ||
-            options.selectionFlag)
-            throw new InstallerError("invalid_input", "reconcile accepts only --global, --dry-run, --yes, and --json");
-        requireApplyMode(options);
-        if (options.dryRun) {
-            const plan = await previewReconcile(options.scope);
-            if (options.json)
-                process.stdout.write(`${JSON.stringify({ status: "ok", applied: false, plan }, null, 2)}\n`);
-            else
-                process.stdout.write(renderReconcile(plan, {
-                    applied: false,
-                    applyHint: plan.confirmable
-                        ? applyHint(["reconcile", ...scopeArguments(options.scope)])
-                        : undefined,
-                }));
-        }
-        else {
-            if (!options.yes) {
-                const plan = await previewReconcile(options.scope);
-                process.stdout.write(renderReconcile(plan, { applied: false }));
-                await confirmSummary();
-            }
-            const applied = await applyReconcile(options.scope);
-            if (options.json)
-                process.stdout.write(`${JSON.stringify(applied, null, 2)}\n`);
-            else
-                process.stdout.write(renderReconcile(applied.plan, { applied: true }));
-        }
-        return;
-    }
-    if (domain === "install" || domain === "uninstall") {
-        if (operation?.startsWith("--") || operation === undefined)
-            rest.unshift(...(operation ? [operation] : []));
-        else
-            throw new InstallerError("invalid_input", `Unexpected argument: ${operation}`);
-        const options = parseOptions(rest);
-        const action = domain;
-        if (options.name ||
-            options.provider ||
-            options.model ||
-            options.variant !== undefined ||
-            (action === "uninstall" && options.selectionFlag))
-            throw new InstallerError("invalid_input", action === "install"
-                ? "install does not accept model options or positional arguments"
-                : "uninstall accepts only --global, --dry-run, --yes, and --json");
-        if (action === "install" &&
-            options.selectionFlag &&
-            (options.commands === undefined ||
-                options.agents === undefined ||
-                options.plugins === undefined))
-            throw new InstallerError("invalid_input", "Non-TTY install requires --commands, --agents, and --plugins");
-        const selection = action === "install"
-            ? options.selectionFlag
-                ? installerSelection(options)
-                : await interactiveInstallerSelection()
-            : undefined;
-        const coreSelection = action === "install" && selection?.core_activation
-            ? normalizeConfigSelection(options.scope, {
-                targets: ["opencode"],
-                fragments: ["core-plugin"],
-            })
-            : undefined;
-        const applyCoreIntegration = async () => {
-            if (!coreSelection)
-                return null;
-            try {
-                return await applyConfigSetup(coreSelection, options.scope, process.cwd(), undefined, {
-                    provisionDependency: false,
-                    receipt: corePreview?.receipt,
-                });
-            }
-            catch (error) {
-                const known = error instanceof LifecycleError
-                    ? error
-                    : new InstallerError("internal_error", error instanceof Error ? error.message : String(error));
-                process.stderr.write(`Assets applied, but core integration failed [${known.code}]: ${terminalSafe(known.message)}\nRetry with: ${shellCommand(["config", ...scopeArguments(options.scope), "--targets", "opencode", "--fragments", "core-plugin"])}\n`);
-                process.exitCode = 2;
-                return null;
-            }
-        };
-        requireApplyMode(options);
-        const corePreview = coreSelection
-            ? await previewConfigSetup(coreSelection, options.scope, process.cwd(), undefined, false)
-            : undefined;
-        if (options.dryRun) {
-            const plan = await preview(action, options.scope, process.cwd(), undefined, selection, !options.noDependency);
-            const corePlan = corePreview;
-            if (options.json)
-                process.stdout.write(`${JSON.stringify({ status: "ok", applied: false, requires_restart: plan.requires_restart, plan, ...(corePlan ? { core_integration: corePlan } : {}) }, null, 2)}\n`);
-            else {
-                process.stdout.write(renderPlan(plan, {
-                    applied: false,
-                    applyHint: applyHint([
-                        action,
-                        ...scopeArguments(options.scope),
-                        ...(action === "install" ? selectionArguments(plan.selection) : []),
-                        ...(options.noDependency ? ["--no-dependency"] : []),
-                    ]),
-                }));
-                if (corePlan)
-                    process.stdout.write(renderConfigSetup(corePlan, { applied: false }));
-            }
-        }
-        else {
-            if (!options.yes) {
-                const plan = await preview(action, options.scope, process.cwd(), undefined, selection, !options.noDependency);
-                process.stdout.write(renderPlan(plan, { applied: false }));
-                if (corePreview)
-                    process.stdout.write(renderConfigSetup(corePreview, { applied: false }));
-                await confirmSummary();
-            }
-            const plan = await apply(action, options.scope, process.cwd(), undefined, {}, selection, !options.noDependency);
-            const corePlan = await applyCoreIntegration();
-            if (options.json)
-                process.stdout.write(`${JSON.stringify({ status: "ok", applied: true, requires_restart: plan.requires_restart, plan, ...(corePlan ? { core_integration: corePlan } : {}) }, null, 2)}\n`);
-            else
-                process.stdout.write(renderPlan(plan, {
-                    applied: true,
-                    ...(action === "install" && !corePlan
-                        ? {
-                            hint: `Connect the package into user configs: ${shellCommand(["config", ...scopeArguments(options.scope), "--dry-run"])}`,
-                        }
-                        : {}),
-                }));
-            if (corePlan && !options.json)
-                process.stdout.write(renderConfigSetup(corePlan, { applied: true }));
-        }
-        return;
-    }
-    if (domain === "agent" && operation === "list") {
-        const options = parseOptions(rest);
-        if (options.dryRun ||
-            options.yes ||
-            options.name ||
-            options.provider ||
-            options.model ||
-            options.variant !== undefined ||
-            options.selectionFlag)
-            throw new InstallerError("invalid_input", "agent list accepts only --global and --json");
-        const inventory = await listAgentProfiles(options.scope);
-        if (options.json)
-            process.stdout.write(`${JSON.stringify({ status: "ok", inventory }, null, 2)}\n`);
-        else
-            process.stdout.write(renderInventory(inventory));
-        return;
-    }
-    if (domain === "agent" && operation === "configure") {
-        const options = parseOptions(rest);
-        if (options.selectionFlag)
-            throw new InstallerError("invalid_input", "agent configure does not accept selection options");
-        requireApplyMode(options);
-        const model = exactModel(options);
-        const selected = options.name && model
-            ? {
-                name: validateAgentName(options.name),
-                model,
-                ...(validateVariant(options.variant)
-                    ? { variant: validateVariant(options.variant) }
-                    : {}),
-            }
-            : await interactiveSelection(options, "model-set");
-        await runProfile({ action: "model-set", ...selected, variant: selected.variant ?? null }, options);
-        return;
-    }
-    if (domain === "agent" && operation === "model-set") {
-        const options = parseOptions(rest);
-        if (options.selectionFlag)
-            throw new InstallerError("invalid_input", "agent model-set does not accept selection options");
-        const name = validateAgentName(options.name ?? "");
-        const model = exactModel(options);
-        if (!model)
-            throw new InstallerError("invalid_input", "agent model-set requires --provider and --model, or exact --model provider/model");
-        await runProfile({ action: "model-set", name, model, variant: options.variant ?? null }, options);
-        return;
-    }
-    if (domain === "agent" && operation === "reconcile") {
-        const options = parseOptions(rest);
-        if (options.name ||
-            options.provider ||
-            options.model ||
-            options.variant !== undefined ||
-            options.selectionFlag)
-            throw new InstallerError("invalid_input", "agent reconcile accepts only --global, --dry-run, --yes, and --json");
-        await runProfile({ action: "reconcile" }, options);
-        return;
-    }
-    if (domain === "critic" && (operation === "add" || operation === "remove")) {
-        const options = parseOptions(rest);
-        if (options.selectionFlag)
-            throw new InstallerError("invalid_input", `critic ${operation} does not accept selection options`);
-        const name = options.name === "critic" || options.name?.startsWith("critic-")
-            ? options.name
-            : `critic-${options.name ?? ""}`;
-        if (operation === "add") {
-            if (options.variant === null)
-                throw new InstallerError("invalid_input", "critic add does not accept --clear-variant");
-            const model = exactModel(options);
-            if (!model) {
-                const selected = await interactiveSelection(options, "critic-add");
-                await runProfile({
-                    action: "critic-add",
-                    name: selected.name,
-                    model: selected.model,
-                    variant: selected.variant ?? null,
-                }, options);
-            }
-            else {
-                await runProfile({ action: "critic-add", name, model, variant: options.variant ?? null }, options);
-            }
-        }
-        else {
-            if (options.provider ||
-                options.model ||
-                options.variant !== undefined ||
-                options.selectionFlag)
-                throw new InstallerError("invalid_input", "critic remove does not accept model options");
-            await runProfile({ action: "critic-remove", name }, options);
-        }
-        return;
-    }
-    if (domain === "config" && operation === "recover") {
-        if (rest.some((value) => !["--global", "--dry-run", "--yes", "--json"].includes(value)))
-            throw new InstallerError("invalid_input", "config recover accepts only --global, --dry-run, --yes, and --json");
-        const options = parseOptions(rest);
-        requireApplyMode(options);
-        const preview = await recoverConfigSetup(options.scope, true);
-        if (!options.json)
-            process.stdout.write(`Config recovery restores these interrupted transaction paths:\n${preview.paths.map((path) => `  ${terminalSafe(path)}`).join("\n")}\n`);
-        if (!options.dryRun && !options.yes && preview.paths.length)
-            await confirmSummary();
-        const result = options.dryRun
-            ? preview
-            : await recoverConfigSetup(options.scope, false, process.cwd(), undefined, preview.digest);
-        if (options.json)
-            process.stdout.write(`${JSON.stringify(result)}\n`);
-        else
-            process.stdout.write(options.dryRun
-                ? "Apply with config recover and confirmation.\n"
-                : "Recovery complete; request a fresh config preview.\n");
-        return;
-    }
-    if (domain === "config") {
-        if (operation?.startsWith("--") || operation === undefined)
-            rest.unshift(...(operation ? [operation] : []));
-        else
-            throw new InstallerError("invalid_input", `Unexpected argument: ${operation}`);
-        const options = parseOptions(rest);
-        if (options.name ||
-            options.provider ||
-            options.model ||
-            options.variant !== undefined ||
-            options.commands !== undefined ||
-            options.agents !== undefined ||
-            options.plugins !== undefined)
-            throw new InstallerError("invalid_input", "config accepts only --global, --targets, --fragments, --dry-run, --yes, and --json");
-        if (options.selectionFlag &&
-            (options.configTargets === undefined || options.configFragments === undefined))
-            throw new InstallerError("invalid_input", "Non-TTY config requires both --targets and --fragments");
-        const selection = options.selectionFlag
-            ? normalizeConfigSelection(options.scope, configSelectionFromOptions(options))
-            : await interactiveConfigSelection(options);
-        requireApplyMode(options);
-        if (options.dryRun) {
-            const plan = await previewConfigSetup(selection, options.scope);
-            if (options.json)
-                process.stdout.write(`${JSON.stringify({ status: "ok", applied: false, plan }, null, 2)}\n`);
-            else
-                process.stdout.write(renderConfigSetup(plan, {
-                    applied: false,
-                    applyHint: plan.confirmable
-                        ? applyHint([
-                            "config",
-                            ...scopeArguments(options.scope),
-                            ...configSelectionArguments(plan.selection),
-                        ])
-                        : undefined,
-                }));
-        }
-        else {
-            const preview = await previewConfigSetup(selection, options.scope);
-            if (!options.yes) {
-                process.stdout.write(renderConfigSetup(preview, { applied: false }));
-                await confirmSummary();
-            }
-            const plan = await applyConfigSetup(selection, options.scope, process.cwd(), undefined, {
-                receipt: preview.receipt,
-            });
-            if (options.json)
-                process.stdout.write(`${JSON.stringify({ status: "ok", applied: true, requires_restart: plan.requires_restart, plan }, null, 2)}\n`);
-            else
-                process.stdout.write(renderConfigSetup(plan, {
-                    applied: true,
-                    hint: `Restart OpenCode, Kilo Code, and MiMo Code when their configs changed.`,
-                }));
-        }
-        return;
-    }
-    throw new InstallerError("invalid_input", "Use install, uninstall, doctor, capabilities, reconcile, config, agent list|configure|model-set|reconcile, or critic add|remove");
-}
-async function main() {
-    try {
-        let args = process.argv
-            .slice(2)
-            .map((value) => (value === "-h" ? "--help" : value === "-V" ? "--version" : value));
-        if (args[0] === "help")
-            args = [...args.slice(1), "--help"];
-        await run(args);
-    }
-    catch (error) {
-        const known = error instanceof LifecycleError
-            ? error
-            : new InstallerError("internal_error", error instanceof Error ? error.message : String(error));
-        if (process.argv.includes("--json") || machineOutput)
-            process.stdout.write(`${JSON.stringify({ status: "error", error: { code: known.code, message: known.message } })}\n`);
-        else if (diagnosticJSON)
-            process.stderr.write(`${JSON.stringify({ level: "error", phase: "agentomatic.error", code: known.code, message: known.message })}\n`);
-        else
-            process.stderr.write(`Error [${known.code}]: ${terminalSafe(known.message)}\n`);
-        process.exitCode = 2;
-    }
-    finally {
-        diagnostics?.emit({ phase: "agentomatic.done", message: "Command finished", level: "debug" });
-        diagnostics?.close();
-    }
-}
-void main();
+import "./command-cli.js";