open-multi-agent-kit 0.78.0

package/dist/cli/root.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from "commander";
+interface RootChatLaunchArgsOptions {
+    readonly cliPath: string;
+    readonly runId?: string;
+    readonly workers?: string;
+    readonly mode: string;
+}
+export declare function buildRootChatLaunchArgs(options: RootChatLaunchArgsOptions): string[];
+export declare function configureRootProgram(program: Command, OMK_VERSION: string, OMK_VERSION_FOOTER: string): void;
+export {};

package/dist/cli/root.js

@@ -0,0 +1,118 @@
+import { style } from "../util/theme.js";
+import { t, initI18n } from "../util/i18n.js";
+import { buildCustomHelp } from "../util/help-text.js";
+const OMK_ENTRY_BRAND = "neon-grid";
+const OMK_ENTRY_UI = "neon-grid";
+export function buildRootChatLaunchArgs(options) {
+    const chatArgs = [
+        options.cliPath,
+        "chat",
+        "--layout",
+        "auto",
+        "--brand",
+        OMK_ENTRY_BRAND,
+        "--ui",
+        OMK_ENTRY_UI,
+    ];
+    if (options.runId)
+        chatArgs.push("--run-id", options.runId);
+    if (options.workers)
+        chatArgs.push("--workers", options.workers);
+    chatArgs.push("--mode", options.mode);
+    if (options.mode !== "chat")
+        chatArgs.push("--execution", "ask");
+    return chatArgs;
+}
+export function configureRootProgram(program, OMK_VERSION, OMK_VERSION_FOOTER) {
+    program
+        .name("omk")
+        .description(t("cli.description"))
+        .usage("[options] [command]")
+        .version(OMK_VERSION)
+        .option("-r, --run-id <id>", t("cli.runIdOption"))
+        .option("--workers <n>", t("cmd.parallelWorkersOption"), "auto")
+        .option("--sudo", t("cli.sudoOption"))
+        .addHelpText("before", buildCustomHelp)
+        .addHelpText("afterAll", `\n  ${style.gray(OMK_VERSION_FOOTER)}\n`)
+        .configureOutput({
+        writeErr: (str) => process.stderr.write(style.red(str)),
+        outputError: (str, write) => write(style.red(`✖ ${str}`)),
+    })
+        .hook("preAction", (thisCommand) => {
+        const opts = thisCommand.opts();
+        if (opts.sudo) {
+            process.env.OMK_SUDO = "1";
+            process.env.OMK_CLI_SUDO_REQUEST = "1";
+        }
+    })
+        .allowUnknownOption(false)
+        .argument("[command]", "subcommand to run")
+        .action(async (command) => {
+        await initI18n();
+        const customHelp = buildCustomHelp();
+        if (command) {
+            console.error(t("cli.unknownCommand", command));
+            console.log(customHelp);
+            process.exit(1);
+        }
+        const globalOpts = program.opts();
+        const hasTty = Boolean(process.stdout.isTTY && process.stdin.isTTY);
+        // Check updates before entering the root mode.
+        const updatePromise = (async () => {
+            try {
+                const { checkUpdates, formatStartupUpdateBanner } = await import("../util/update-check.js");
+                const updateStatus = await checkUpdates();
+                const banner = formatStartupUpdateBanner(updateStatus);
+                return { banner, status: updateStatus };
+            }
+            catch {
+                return { banner: "", status: null };
+            }
+        })();
+        const { banner: updateBanner, status } = await updatePromise;
+        if (updateBanner)
+            console.log(updateBanner);
+        // Interactive update prompt when omk is outdated
+        if (status && status.omk.outdated) {
+            const { maybePromptForOmkUpdate } = await import("../util/update-check.js");
+            const result = await maybePromptForOmkUpdate({ status, isTTY: hasTty, source: "root" });
+            if (result.shouldExit)
+                process.exit(result.exitCode ?? 0);
+        }
+        const { getCurrentMode } = await import("../util/mode-preset.js");
+        const selectedMode = await getCurrentMode();
+        const { spawnSync } = await import("child_process");
+        const chatArgs = buildRootChatLaunchArgs({
+            cliPath: process.argv[1],
+            runId: globalOpts.runId,
+            workers: globalOpts.workers,
+            mode: selectedMode,
+        });
+        const childEnv = {
+            ...process.env,
+            OMK_ENTRY_SURFACE: "pi-omk",
+        };
+        const result = spawnSync(process.execPath, chatArgs, { stdio: "inherit", env: childEnv });
+        if (result.status && result.status !== 0) {
+            process.exitCode = result.status;
+        }
+    });
+    program.hook("preAction", async (_thisCommand, _actionCommand) => {
+        const globalOpts = program.opts();
+        if (globalOpts.runId) {
+            process.env.OMK_RUN_ID = globalOpts.runId;
+        }
+    });
+    program.hook("postAction", async (_thisCommand, actionCommand) => {
+        try {
+            const { maybeAskForGitHubStarAfterCommand } = await import("../util/first-run-star.js");
+            await maybeAskForGitHubStarAfterCommand({
+                version: OMK_VERSION,
+                commandName: actionCommand.name(),
+            });
+        }
+        catch {
+            // Swallow star prompt errors so original command success is preserved.
+        }
+    });
+}

package/dist/cli/runtime/capability-selector.d.ts

@@ -0,0 +1,18 @@
+/**
+ * CapabilitySelector — selects capabilities based on classified intent.
+ *
+ * Architecture Doc §4: IntentClassifier → CapabilitySelector → RuntimeSidecar
+ * Maps IntentKind + context → CapabilityPlan (skills, MCP, hooks, tools, promptMode).
+ */
+import type { ClassifiedIntent, CapabilityPlan, CommandEnvelope } from "./types.js";
+/**
+ * Select capabilities based on classified intent and envelope context.
+ *
+ * Flow: role preset → intent overlay → envelope overrides → final plan
+ */
+export declare function selectCapabilities(intent: ClassifiedIntent, envelope?: CommandEnvelope, role?: string): CapabilityPlan;
+/**
+ * Create a minimal CapabilityPlan for sub-agents.
+ * Used by ParallelOrchestrator when dispatching worker tasks.
+ */
+export declare function createSubAgentCapabilityPlan(role: string, extraSkills?: readonly string[], extraMcp?: readonly string[]): CapabilityPlan;

package/dist/cli/runtime/capability-selector.js

@@ -0,0 +1,208 @@
+/**
+ * CapabilitySelector — selects capabilities based on classified intent.
+ *
+ * Architecture Doc §4: IntentClassifier → CapabilitySelector → RuntimeSidecar
+ * Maps IntentKind + context → CapabilityPlan (skills, MCP, hooks, tools, promptMode).
+ */
+/**
+ * Role-based default capability presets.
+ * Each role gets a baseline set of skills, MCP servers, hooks, and tools.
+ */
+const ROLE_PRESETS = {
+    explorer: {
+        skills: ["omk-repo-explorer", "omk-context-broker"],
+        mcpServers: ["omk-project"],
+        hooks: ["subagent-stop-audit.sh"],
+    },
+    researcher: {
+        skills: ["omk-repo-explorer", "omk-research-verify", "omk-context-broker"],
+        mcpServers: ["omk-project", "context7"],
+        hooks: ["subagent-stop-audit.sh"],
+    },
+    planner: {
+        skills: ["omk-plan-first", "omk-context-broker", "omk-industrial-control-loop"],
+        mcpServers: ["omk-project"],
+        hooks: ["subagent-stop-audit.sh"],
+    },
+    architect: {
+        skills: ["omk-plan-first", "omk-design-system", "omk-context-broker"],
+        mcpServers: ["omk-project", "context7"],
+        hooks: ["subagent-stop-audit.sh"],
+    },
+    coder: {
+        skills: ["omk-test-debug-loop", "omk-typescript-strict", "omk-python-typing"],
+        mcpServers: ["omk-project"],
+        hooks: ["protect-secrets.sh", "pre-shell-guard.sh", "post-format.sh"],
+    },
+    reviewer: {
+        skills: ["omk-code-review", "omk-security-review", "omk-evidence-contract"],
+        mcpServers: ["omk-project"],
+        hooks: ["subagent-stop-audit.sh", "stop-verify.sh"],
+    },
+    security: {
+        skills: ["omk-security-review", "omk-secret-guard", "omk-code-review"],
+        mcpServers: ["omk-project"],
+        hooks: ["protect-secrets.sh", "pre-shell-guard.sh"],
+    },
+    qa: {
+        skills: ["omk-quality-gate", "omk-test-debug-loop", "omk-evidence-contract"],
+        mcpServers: ["omk-project"],
+        hooks: ["stop-verify.sh", "pre-shell-guard.sh"],
+    },
+    tester: {
+        skills: ["omk-quality-gate", "omk-test-debug-loop", "omk-evidence-contract"],
+        mcpServers: ["omk-project"],
+        hooks: ["stop-verify.sh", "pre-shell-guard.sh"],
+    },
+    integrator: {
+        skills: ["omk-git-commit-pr", "omk-context-broker", "omk-evidence-contract"],
+        mcpServers: ["omk-project"],
+        hooks: ["branch-diff-snapshot.sh", "stop-verify.sh"],
+    },
+};
+/**
+ * Intent-based capability overlays.
+ * These are applied ON TOP of role presets.
+ */
+const INTENT_OVERLAYS = {
+    debugging: {
+        skills: ["omk-flow-bugfix"],
+        promptMode: "compact",
+        providerHints: { requireToolCalling: true },
+    },
+    review: {
+        skills: ["omk-code-review", "omk-multimodal-ui-review"],
+        promptMode: "full",
+        providerHints: { requireToolCalling: true },
+    },
+    "test-generation": {
+        skills: ["omk-flow-bugfix"],
+        promptMode: "compact",
+        providerHints: { requireToolCalling: true },
+    },
+    refactor: {
+        skills: ["omk-flow-refactor", "omk-flow-feature-dev"],
+        promptMode: "compact",
+        providerHints: { requireToolCalling: true },
+    },
+    research: {
+        skills: ["omk-research-verify"],
+        promptMode: "full",
+        providerHints: { requireMcp: true },
+    },
+    planning: {
+        skills: ["omk-plan-first", "speckit-specify", "speckit-plan"],
+        promptMode: "full",
+        providerHints: {},
+    },
+    documentation: {
+        skills: ["omk-docs-release"],
+        promptMode: "nlp",
+        providerHints: {},
+    },
+    "shell-operation": {
+        promptMode: "minimal",
+        providerHints: { requireToolCalling: true },
+    },
+    coding: {
+        skills: ["omk-flow-feature-dev"],
+        promptMode: "compact",
+        providerHints: { requireToolCalling: true },
+    },
+    chat: {
+        promptMode: "nlp",
+        providerHints: {},
+    },
+    unknown: {
+        promptMode: "nlp",
+        providerHints: {},
+    },
+};
+/**
+ * Merge multiple partial CapabilityPlans into one.
+ * Arrays are concatenated and deduplicated. Last-write wins for scalars.
+ */
+function mergePlans(...plans) {
+    const skills = new Set();
+    const mcpServers = new Set();
+    const hooks = new Set();
+    const tools = new Set();
+    let promptMode = "nlp";
+    const providerHints = {};
+    const rationales = [];
+    for (const plan of plans) {
+        if (plan.skills)
+            for (const s of plan.skills)
+                skills.add(s);
+        if (plan.mcpServers)
+            for (const m of plan.mcpServers)
+                mcpServers.add(m);
+        if (plan.hooks)
+            for (const h of plan.hooks)
+                hooks.add(h);
+        if (plan.tools)
+            for (const t of plan.tools)
+                tools.add(t);
+        if (plan.promptMode)
+            promptMode = plan.promptMode;
+        if (plan.providerHints) {
+            Object.assign(providerHints, plan.providerHints);
+        }
+        if (plan.rationale)
+            rationales.push(plan.rationale);
+    }
+    return {
+        skills: [...skills],
+        mcpServers: [...mcpServers],
+        hooks: [...hooks],
+        tools: [...tools],
+        promptMode,
+        providerHints,
+        rationale: rationales.join("; ") || "default",
+    };
+}
+/**
+ * Select capabilities based on classified intent and envelope context.
+ *
+ * Flow: role preset → intent overlay → envelope overrides → final plan
+ */
+export function selectCapabilities(intent, envelope, role) {
+    const effectiveRole = role ?? inferRole(envelope);
+    const rolePreset = ROLE_PRESETS[effectiveRole] ?? {};
+    const intentOverlay = INTENT_OVERLAYS[intent.kind] ?? {};
+    // Envelope-level overrides
+    const envelopeHints = envelope?.runtime?.provider
+        ? { preferProvider: envelope.runtime.provider }
+        : undefined;
+    const plan = mergePlans({ rationale: `role:${effectiveRole}` }, rolePreset, { rationale: `intent:${intent.kind} (conf=${intent.confidence.toFixed(2)})` }, intentOverlay, ...(envelopeHints ? [{ providerHints: envelopeHints }] : []));
+    return plan;
+}
+/**
+ * Infer role from envelope context.
+ */
+function inferRole(envelope) {
+    if (!envelope)
+        return "coder";
+    switch (envelope.kind) {
+        case "plan": return "planner";
+        case "task": return "coder";
+        case "chat": return "coder";
+        case "run": return "coder";
+        case "provider": return "explorer";
+        case "theme": return "explorer";
+        case "doctor": return "explorer";
+        default: return "coder";
+    }
+}
+/**
+ * Create a minimal CapabilityPlan for sub-agents.
+ * Used by ParallelOrchestrator when dispatching worker tasks.
+ */
+export function createSubAgentCapabilityPlan(role, extraSkills = [], extraMcp = []) {
+    const rolePreset = ROLE_PRESETS[role] ?? ROLE_PRESETS.coder;
+    return mergePlans(rolePreset, {
+        skills: [...extraSkills],
+        mcpServers: [...extraMcp],
+        rationale: `sub-agent role:${role}`,
+    });
+}

package/dist/cli/runtime/cli-runtime.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Phase 1 — CliRuntime
+ * Central execution router. Receives a CommandEnvelope and delegates to the
+ * appropriate controller based on envelope.kind.
+ */
+import type { CommandEnvelope, CliExecutionResult } from "./types.js";
+export interface CliRuntime {
+    execute(envelope: CommandEnvelope): Promise<CliExecutionResult>;
+}
+export declare function createCliRuntime(): CliRuntime;

package/dist/cli/runtime/cli-runtime.js

@@ -0,0 +1,35 @@
+/**
+ * Phase 1 — CliRuntime
+ * Central execution router. Receives a CommandEnvelope and delegates to the
+ * appropriate controller based on envelope.kind.
+ */
+import { handleRunCommand } from "./run-controller.js";
+import { handleTaskCommand } from "./task-controller.js";
+import { handlePlanCommand } from "./plan-controller.js";
+export function createCliRuntime() {
+    return {
+        async execute(envelope) {
+            switch (envelope.kind) {
+                case "run":
+                    return handleRunCommand(envelope);
+                case "task":
+                    return handleTaskCommand(envelope);
+                case "plan":
+                    return handlePlanCommand(envelope);
+                default: {
+                    return {
+                        command: envelope.kind,
+                        success: false,
+                        exitCode: 2,
+                        events: [],
+                        error: {
+                            kind: "usage",
+                            message: `Command "${envelope.kind}" is not yet implemented in the runtime bridge.`,
+                            hint: "Supported commands: run, task, plan",
+                        },
+                    };
+                }
+            }
+        },
+    };
+}

package/dist/cli/runtime/cli-writer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Phase 1 — CliWriter
+ * All CLI output goes through here. No direct console.log/chalk anywhere else.
+ * Wraps the existing OMK theme/style system for backward compatibility.
+ */
+import type { OutputProfile, TaskStatus } from "./types.js";
+export interface CliWriter {
+    info(message: string): void;
+    success(message: string): void;
+    warning(message: string): void;
+    error(message: string): void;
+    agent(agentName: string, message: string): void;
+    task(taskTitle: string, status: TaskStatus): void;
+    trace(message: string): void;
+    rawStdout(content: string): void;
+    rawStderr(content: string): void;
+}
+export declare function createCliWriter(profile: OutputProfile): CliWriter;

package/dist/cli/runtime/cli-writer.js

@@ -0,0 +1,87 @@
+/**
+ * Phase 1 — CliWriter
+ * All CLI output goes through here. No direct console.log/chalk anywhere else.
+ * Wraps the existing OMK theme/style system for backward compatibility.
+ */
+import { appendFileSync } from "node:fs";
+import { style, status } from "../../theme/index.js";
+const STATUS_ICON = {
+    running: "▶",
+    pending: "◯",
+    completed: "✓",
+    failed: "✕",
+};
+function writeLine(stream, text) {
+    stream.write(text + "\n");
+}
+function writeFileLine(path, text) {
+    try {
+        appendFileSync(path, text + "\n", "utf-8");
+    }
+    catch {
+        // silently drop file-write failures; stdout remains the fallback
+    }
+}
+export function createCliWriter(profile) {
+    const isFile = profile.destination === "file" && profile.outputFile;
+    const filePath = profile.outputFile;
+    const out = (text) => {
+        if (isFile && filePath) {
+            writeFileLine(filePath, text);
+        }
+        else {
+            writeLine(process.stdout, text);
+        }
+    };
+    const err = (text) => {
+        if (isFile && filePath) {
+            writeFileLine(filePath, text);
+        }
+        else {
+            writeLine(process.stderr, text);
+        }
+    };
+    const raw = (stream, content) => {
+        if (isFile && filePath) {
+            try {
+                appendFileSync(filePath, content, "utf-8");
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        else {
+            stream.write(content);
+        }
+    };
+    return {
+        info(message) {
+            out(style.blue("ℹ ") + message);
+        },
+        success(message) {
+            out(status.success(message));
+        },
+        warning(message) {
+            err(status.warn(message));
+        },
+        error(message) {
+            err(status.fail(message));
+        },
+        agent(agentName, message) {
+            out(style.purple("● ") + style.bold + agentName + style.reset + ": " + message);
+        },
+        task(taskTitle, taskStatus) {
+            const icon = STATUS_ICON[taskStatus] ?? "?";
+            out(style.cyan(icon + " ") + taskTitle + " " + style.gray(`[${taskStatus}]`));
+        },
+        trace(message) {
+            out(style.dim + message + style.reset);
+        },
+        rawStdout(content) {
+            raw(process.stdout, content);
+        },
+        rawStderr(content) {
+            raw(process.stderr, content);
+        },
+    };
+}

package/dist/cli/runtime/command-bus.d.ts

@@ -0,0 +1,45 @@
+/**
+ * CommandBus — slash command dispatch for the CLI pipeline.
+ *
+ * Architecture Doc §4: User Input → CommandBus → IntentClassifier
+ * Handles slash commands (/model, /status, /theme, /help, etc.)
+ * and routes them to appropriate handlers.
+ */
+import type { CommandEnvelope, CommandKind } from "./types.js";
+export type SlashCommandHandler = (args: string[], envelope: CommandEnvelope) => Promise<SlashCommandResult> | SlashCommandResult;
+export interface SlashCommandResult {
+    readonly handled: boolean;
+    readonly output?: string;
+    readonly exitCode?: 0 | 1;
+    readonly newKind?: CommandKind;
+}
+interface RegisteredCommand {
+    readonly name: string;
+    readonly aliases: readonly string[];
+    readonly description: string;
+    readonly handler: SlashCommandHandler;
+}
+/**
+ * Register a slash command handler.
+ */
+export declare function registerSlashCommand(cmd: RegisteredCommand): void;
+/**
+ * Check if input is a slash command.
+ */
+export declare function isSlashCommand(input: string): boolean;
+/**
+ * Parse slash command from input.
+ */
+export declare function parseSlashCommand(input: string): {
+    name: string;
+    args: string[];
+} | null;
+/**
+ * Dispatch a slash command.
+ */
+export declare function dispatchSlashCommand(input: string, envelope: CommandEnvelope): Promise<SlashCommandResult>;
+/**
+ * List all registered slash commands.
+ */
+export declare function listSlashCommands(): readonly RegisteredCommand[];
+export {};

package/dist/cli/runtime/command-bus.js

@@ -0,0 +1,132 @@
+/**
+ * CommandBus — slash command dispatch for the CLI pipeline.
+ *
+ * Architecture Doc §4: User Input → CommandBus → IntentClassifier
+ * Handles slash commands (/model, /status, /theme, /help, etc.)
+ * and routes them to appropriate handlers.
+ */
+import { readProviderRegistry } from "../../providers/model-registry.js";
+import { renderProviderModelTable } from "../../providers/model-table.js";
+import { formatThinkingModelVariant, nextThinkingLevel, normalizeThinkingLevel, thinkingLevelsFor } from "../../providers/thinking-levels.js";
+const commands = new Map();
+const aliases = new Map();
+/**
+ * Register a slash command handler.
+ */
+export function registerSlashCommand(cmd) {
+    commands.set(cmd.name, cmd);
+    for (const alias of cmd.aliases) {
+        aliases.set(alias, cmd.name);
+    }
+}
+/**
+ * Check if input is a slash command.
+ */
+export function isSlashCommand(input) {
+    return input.trimStart().startsWith("/");
+}
+/**
+ * Parse slash command from input.
+ */
+export function parseSlashCommand(input) {
+    const trimmed = input.trimStart();
+    if (!trimmed.startsWith("/"))
+        return null;
+    const parts = trimmed.slice(1).split(/\s+/);
+    const name = parts[0] ?? "";
+    const args = parts.slice(1);
+    return { name, args };
+}
+/**
+ * Dispatch a slash command.
+ */
+export async function dispatchSlashCommand(input, envelope) {
+    const parsed = parseSlashCommand(input);
+    if (!parsed)
+        return { handled: false };
+    const resolvedName = aliases.get(parsed.name) ?? parsed.name;
+    const cmd = commands.get(resolvedName);
+    if (!cmd) {
+        return {
+            handled: true,
+            output: `Unknown command: /${parsed.name}. Type /help for available commands.`,
+            exitCode: 1,
+        };
+    }
+    return cmd.handler(parsed.args, envelope);
+}
+/**
+ * List all registered slash commands.
+ */
+export function listSlashCommands() {
+    return [...commands.values()];
+}
+// ── Built-in commands ──────────────────────────────────────────
+registerSlashCommand({
+    name: "help",
+    aliases: ["h", "?"],
+    description: "Show available commands",
+    handler: () => {
+        const cmds = listSlashCommands();
+        const lines = ["Available commands:"];
+        for (const cmd of cmds) {
+            const aliasStr = cmd.aliases.length > 0 ? ` (${cmd.aliases.join(", ")})` : "";
+            lines.push(`  /${cmd.name}${aliasStr} — ${cmd.description}`);
+        }
+        return { handled: true, output: lines.join("\n"), exitCode: 0 };
+    },
+});
+registerSlashCommand({
+    name: "status",
+    aliases: ["st"],
+    description: "Show current runtime status",
+    handler: (_args, envelope) => {
+        const lines = [
+            `Command: ${envelope.kind}`,
+            `Provider: ${envelope.runtime.provider ?? "auto"}`,
+            `Theme: ${envelope.theme.name} (${envelope.theme.mode})`,
+            `Output: ${envelope.output.format}`,
+            `Workers: ${envelope.runtime.workers ?? "auto"}`,
+        ];
+        return { handled: true, output: lines.join("\n"), exitCode: 0 };
+    },
+});
+registerSlashCommand({
+    name: "model",
+    aliases: ["m"],
+    description: "Show or switch model",
+    handler: async (args, envelope) => {
+        if (args.length === 0) {
+            const providers = await readProviderRegistry({ env: envelope.config.env });
+            return {
+                handled: true,
+                output: renderProviderModelTable(providers, { currentProvider: envelope.runtime.provider }),
+                exitCode: 0,
+            };
+        }
+        return {
+            handled: true,
+            output: `Model switch requested: ${args[0]}`,
+            exitCode: 0,
+        };
+    },
+});
+registerSlashCommand({
+    name: "think",
+    aliases: ["thinking"],
+    description: "Cycle thinking variant (medium → high → xhigh → max)",
+    handler: (args, envelope) => {
+        const provider = envelope.runtime.provider ?? "auto";
+        const model = envelope.config.env.OMK_PROVIDER_MODEL;
+        const levels = thinkingLevelsFor(provider, model);
+        const requested = args[0]?.toLowerCase();
+        const level = !requested || requested === "next" || requested === "tab"
+            ? nextThinkingLevel(envelope.config.env.OMK_THINKING, provider, model)
+            : normalizeThinkingLevel(requested);
+        if (!level || !levels.includes(level)) {
+            return { handled: true, output: `Supported thinking levels: ${levels.join(" -> ")}`, exitCode: 1 };
+        }
+        const variant = formatThinkingModelVariant(model, level);
+        return { handled: true, output: `Thinking: ${level}\nModel variant: ${variant}\nCycle: ${levels.join(" -> ")}`, exitCode: 0 };
+    },
+});