open-multi-agent-kit 0.78.0

package/dist/commands/chat/slash/commands/diagnostics.js

@@ -0,0 +1,64 @@
+import { readdir } from "fs/promises";
+import { join } from "path";
+import { runShell } from "../../../../util/shell.js";
+import { style } from "../../../../util/theme.js";
+import { okSlashResult } from "../result.js";
+export function buildDiagnosticsSlashCommands() {
+    return [
+        {
+            name: "/runs",
+            aliases: ["/history"],
+            group: "diagnostics",
+            summary: "List recent runs",
+            usage: "/runs",
+            examples: ["/runs"],
+            handler: async (ctx) => {
+                try {
+                    const runsDir = join(ctx.input.root, ".omk", "runs");
+                    const entries = await readdir(runsDir, { withFileTypes: true });
+                    const recent = entries
+                        .filter((entry) => entry.isDirectory())
+                        .map((entry) => entry.name)
+                        .filter((name) => name.startsWith("chat-"))
+                        .sort()
+                        .reverse()
+                        .slice(0, 10);
+                    const lines = [style.phosphorBold("\n  Recent Chats:")];
+                    for (const run of recent)
+                        lines.push(style.phosphorDim(`    • ${run}`));
+                    if (recent.length === 0)
+                        lines.push(style.phosphorDim("    (none)"));
+                    lines.push("");
+                    return okSlashResult({ text: lines.join("\n") });
+                }
+                catch {
+                    return okSlashResult({ text: style.phosphorDim("\n  No runs found.\n") });
+                }
+            },
+        },
+        {
+            name: "/doctor",
+            aliases: [],
+            group: "diagnostics",
+            summary: "Run omk doctor",
+            usage: "/doctor",
+            examples: ["/doctor"],
+            handler: async (ctx) => {
+                try {
+                    const result = await runShell(process.execPath, ["dist/cli.js", "doctor", "--json"], {
+                        cwd: ctx.input.root,
+                        env: ctx.env,
+                        timeout: 30000,
+                    });
+                    const output = (result.stdout || result.stderr || `doctor exited with code ${result.exitCode}`).slice(0, 2000);
+                    const suffix = result.failed ? `\n${style.metricsRed(`Doctor exited with code ${result.exitCode}`)}` : "";
+                    return okSlashResult({ text: `${style.phosphorDim("\n  Running doctor...\n")}${output}${suffix}` });
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    return okSlashResult({ text: style.metricsRed(`Doctor failed: ${message}`) });
+                }
+            },
+        },
+    ];
+}

package/dist/commands/chat/slash/commands/harness.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommandSpec } from "../types.js";
+export declare function buildHarnessSlashCommands(): SlashCommandSpec[];

package/dist/commands/chat/slash/commands/harness.js

@@ -0,0 +1,21 @@
+import { style } from "../../../../util/theme.js";
+import { okSlashResult } from "../result.js";
+export function buildHarnessSlashCommands() {
+    return [
+        {
+            name: "/parallel",
+            aliases: ["/pa"],
+            group: "harness",
+            summary: "Run parallel orchestrator with prompt",
+            usage: "/parallel <prompt>",
+            examples: ["/parallel \"inspect harness health\""],
+            handler: async (ctx, args) => {
+                const prompt = args.positional.join(" ").trim();
+                if (!prompt)
+                    return okSlashResult({ text: style.phosphorDim("\n  Usage: /parallel <prompt>\n") });
+                const exitCode = await ctx.services?.runParallelTurn?.(prompt, ctx.renderer);
+                return okSlashResult({ text: exitCode === undefined ? style.metricsRed("Parallel runner is unavailable.") : undefined });
+            },
+        },
+    ];
+}

package/dist/commands/chat/slash/commands/index.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommandSpec } from "../types.js";
+export declare function buildNativeChatSlashCommands(): SlashCommandSpec[];

package/dist/commands/chat/slash/commands/index.js

@@ -0,0 +1,18 @@
+import { buildControlPlaneSlashCommands } from "./control.js";
+import { buildDiagnosticsSlashCommands } from "./diagnostics.js";
+import { buildHarnessSlashCommands } from "./harness.js";
+import { buildRoutingSlashCommands } from "./routing.js";
+import { buildSessionSlashCommands } from "./session.js";
+import { buildToolPlaneSlashCommands } from "./tool-plane.js";
+import { buildUiSlashCommands } from "./ui.js";
+export function buildNativeChatSlashCommands() {
+    return [
+        ...buildSessionSlashCommands(),
+        ...buildRoutingSlashCommands(),
+        ...buildControlPlaneSlashCommands(),
+        ...buildToolPlaneSlashCommands(),
+        ...buildUiSlashCommands(),
+        ...buildDiagnosticsSlashCommands(),
+        ...buildHarnessSlashCommands(),
+    ];
+}

package/dist/commands/chat/slash/commands/routing.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommandSpec } from "../types.js";
+export declare function buildRoutingSlashCommands(): SlashCommandSpec[];

package/dist/commands/chat/slash/commands/routing.js

@@ -0,0 +1,355 @@
+import { buildAuthCenterReport } from "../../../auth.js";
+import { KNOWN_PROVIDER_IDS, listUserModelAliases, normalizeProviderId, parseProviderModelArg, readProviderRegistry, resolveUserModelAlias, } from "../../../../providers/model-registry.js";
+import { groupProviderModelsByProvider, renderProviderModelTable } from "../../../../providers/model-table.js";
+import { formatThinkingModelVariant, nextThinkingLevel, normalizeThinkingLevel, normalizeThinkingVariant, thinkingLevelsFor } from "../../../../providers/thinking-levels.js";
+import { resolveRuntimeBootstrap } from "../../../../runtime/runtime-bootstrap.js";
+import { style } from "../../../../util/theme.js";
+import { errorSlashResult, okSlashResult } from "../result.js";
+export function buildRoutingSlashCommands() {
+    return [
+        {
+            name: "/auth",
+            aliases: ["/login"],
+            group: "routing",
+            summary: "Show provider auth status",
+            usage: "/auth [provider] [--setup] [--doctor]",
+            examples: ["/auth", "/auth codex --doctor"],
+            handler: async (ctx, args) => {
+                const target = args.positional.find((token) => !token.startsWith("-"));
+                const report = await buildAuthCenterReport(target, { env: ctx.env });
+                if (args.flags.json)
+                    return okSlashResult({ json: report });
+                return okSlashResult({
+                    text: renderAuthReport(report, Boolean(args.flags.setup || args.flags.doctor)),
+                });
+            },
+        },
+        {
+            name: "/providers",
+            aliases: [":providers"],
+            group: "routing",
+            summary: "List providers",
+            usage: "/providers",
+            examples: ["/providers"],
+            handler: async (ctx) => {
+                const providers = await readProviderRegistry({ env: ctx.env });
+                return okSlashResult({ text: renderProviderModelTable(providers, { currentProvider: ctx.state.provider, currentModel: ctx.state.model, currentThinking: ctx.state.thinking, compactAliases: true, activeProviderTab: ctx.state.activeProviderTab }) });
+            },
+        },
+        {
+            name: "/provider",
+            aliases: ["/p"],
+            group: "routing",
+            summary: "Switch provider for this session",
+            usage: "/provider <name>",
+            examples: ["/provider codex"],
+            handler: async (ctx, args) => {
+                const provider = String(args.positional[0] ?? "")
+                    .trim()
+                    .toLowerCase();
+                const valid = ["auto", ...KNOWN_PROVIDER_IDS];
+                const normalized = normalizeProviderId(provider);
+                if (!provider || !valid.includes(normalized)) {
+                    return okSlashResult({
+                        text: `${style.phosphorDim(`\n  Available: ${valid.join(", ")}`)}\n${style.phosphorDim("  Usage: /provider codex\n")}`,
+                    });
+                }
+                return applyProviderOverride(ctx, normalized);
+            },
+        },
+        {
+            name: "/models",
+            aliases: [":models"],
+            group: "routing",
+            summary: "List model aliases",
+            usage: "/models",
+            examples: ["/models"],
+            handler: async (ctx) => {
+                const aliases = await listUserModelAliases({ env: ctx.env });
+                const lines = [style.phosphorBold("\n  User Model Aliases:")];
+                const entries = Object.entries(aliases);
+                if (entries.length === 0)
+                    lines.push(style.phosphorDim("    (none)"));
+                for (const [alias, target] of entries)
+                    lines.push(style.phosphorDim(`    ${alias} -> ${target}`));
+                lines.push(style.phosphorDim("  Use `omk model alias add fast deepseek/flash` to persist aliases.\n"));
+                return okSlashResult({ text: lines.join("\n") });
+            },
+        },
+        {
+            name: "/model",
+            aliases: ["/m"],
+            group: "routing",
+            summary: "Show or set model [+thinking variant] for this session",
+            usage: "/model [provider/model|model[:level]]",
+            examples: ["/model", "/model codex/codex-cli", "/model deepseek/pro:max", "/model kimi/k2.6:high", "/model deepseek-v4-pro:max", "/think variant code-high"],
+            handler: async (ctx, args) => {
+                const raw = args.positional.join(" ").trim();
+                if (!raw) {
+                    const providers = await readProviderRegistry({ env: ctx.env });
+                    const providerGroups = groupProviderModelsByProvider(providers);
+                    if (args.flags.json) {
+                        return okSlashResult({
+                            json: {
+                                schema: "omk.slash.model-groups.v1",
+                                currentProvider: ctx.state.provider,
+                                currentModel: ctx.state.model,
+                                currentThinking: ctx.state.thinking,
+                                providerGroups,
+                            },
+                        });
+                    }
+                    return okSlashResult({
+                        text: renderProviderModelTable(providers, {
+                            currentProvider: ctx.state.provider,
+                            currentModel: ctx.state.model,
+                            currentThinking: ctx.state.thinking,
+                            activeProviderTab: ctx.state.activeProviderTab,
+                        }),
+                    });
+                }
+                // Parse model + optional :thinkingLevel
+                const parsed = parseProviderModelArg(raw);
+                const ref = modelRefFromParsed(parsed, raw);
+                const thinking = parsed.thinkingLevel
+                    ? await validateThinkingOverride(ctx, ref, parsed.thinkingLevel)
+                    : undefined;
+                if (thinking && !thinking.ok)
+                    return thinking.result;
+                const result = await applyModelOverride(ctx, ref);
+                return thinking?.ok
+                    ? applyThinkingOverride(ctx, result, thinking.level, thinking.levels)
+                    : result;
+            },
+        },
+        {
+            name: "/think",
+            aliases: ["/thinking", ":think"],
+            group: "routing",
+            summary: "Show, cycle, or set model thinking variant",
+            usage: "/think [next|medium|high|xhigh|max|variant <name>]",
+            examples: ["/think", "/think next", "/think high", "/think variant code-high", "/think varint review-xhigh"],
+            handler: async (ctx, args) => {
+                const requested = args.positional[0]?.trim().toLowerCase();
+                const levels = thinkingLevelsFor(ctx.state.provider, ctx.state.model);
+                const wantsCustomVariant = requested === "variant" || requested === "varint" || requested === "v";
+                const customVariant = wantsCustomVariant ? normalizeThinkingVariant(args.positional[1]) : undefined;
+                if (wantsCustomVariant) {
+                    if (!customVariant) {
+                        return okSlashResult({
+                            text: style.phosphorDim(`\n  Usage: /think variant <name>\n  Example: /think variant code-high\n  Alias: /think varint <name>\n  Allowed: letters, numbers, dot, underscore, colon, hyphen.\n`),
+                        });
+                    }
+                    ctx.env.OMK_THINKING = customVariant;
+                    ctx.env.OMK_MODEL_VARIANT = formatThinkingModelVariant(ctx.state.model, customVariant);
+                    return okSlashResult({
+                        statePatch: { thinking: customVariant, updatedAt: new Date().toISOString() },
+                        text: [
+                            style.phosphor(`\n  Thinking variant: ${customVariant}`),
+                            style.phosphorDim("  Mode: custom variant"),
+                            style.phosphorDim(`  Active: ${ctx.env.OMK_MODEL_VARIANT}`),
+                            style.phosphorDim(`  Level cycle still available: ${levels.join(" → ")}\n`),
+                        ].join("\n"),
+                    });
+                }
+                const level = !requested || requested === "next" || requested === "tab"
+                    ? nextThinkingLevel(ctx.state.thinking ?? ctx.env.OMK_THINKING, ctx.state.provider, ctx.state.model)
+                    : normalizeThinkingLevel(requested);
+                if (!level || !levels.includes(level)) {
+                    return okSlashResult({
+                        text: style.phosphorDim(`\n  Supported thinking levels for ${ctx.state.provider}/${ctx.state.model ?? "auto"}: ${levels.join(" → ")}\n  Usage: /think next | ${levels.join(" | ")} | variant <name>\n  Shortcut: /model ${ctx.state.provider ?? "kimi"}/${ctx.state.model ?? "auto"}:${levels[0]}\n`),
+                    });
+                }
+                ctx.env.OMK_THINKING = level;
+                ctx.env.OMK_MODEL_VARIANT = formatThinkingModelVariant(ctx.state.model, level);
+                return okSlashResult({
+                    statePatch: { thinking: level, updatedAt: new Date().toISOString() },
+                    text: [
+                        style.phosphor(`\n  Thinking variant: ${level}`),
+                        style.phosphorDim(`  Cycle: ${levels.join(" → ")}`),
+                        style.phosphorDim(`  Active: ${ctx.env.OMK_MODEL_VARIANT}`),
+                        style.phosphorDim(`  Shortcut: /model ${ctx.state.provider ?? "kimi"}/${ctx.state.model ?? "auto"}:${level}`),
+                        style.phosphorDim("  Custom variant: /think variant code-high  (alias: /think varint code-high)\n"),
+                    ].join("\n"),
+                });
+            },
+        },
+        {
+            name: "/use",
+            aliases: [":use"],
+            group: "routing",
+            summary: "Switch provider/model [+thinking] by alias",
+            usage: "/use <ref>[:level]",
+            examples: ["/use codex/codex-cli", "/use fast", "/use deepseek/pro:max"],
+            handler: async (ctx, args) => {
+                const raw = args.positional.join(" ").trim();
+                if (!raw)
+                    return okSlashResult({
+                        text: style.phosphorDim("\n  Usage: /use codex/codex-cli or /use fast or /use deepseek/pro:max\n"),
+                    });
+                const parsed = parseProviderModelArg(raw);
+                const ref = modelRefFromParsed(parsed, raw);
+                const thinking = parsed.thinkingLevel
+                    ? await validateThinkingOverride(ctx, ref, parsed.thinkingLevel)
+                    : undefined;
+                if (thinking && !thinking.ok)
+                    return thinking.result;
+                const result = await applyModelOverride(ctx, ref);
+                return thinking?.ok
+                    ? applyThinkingOverride(ctx, result, thinking.level, thinking.levels)
+                    : result;
+            },
+        },
+    ];
+}
+function modelRefFromParsed(parsed, raw) {
+    return `${parsed.provider ? `${parsed.provider}/` : ""}${parsed.model ?? raw}`;
+}
+async function validateThinkingOverride(ctx, ref, requestedThinking) {
+    const level = normalizeThinkingLevel(requestedThinking);
+    const resolved = await resolveUserModelAlias(ref, { env: ctx.env });
+    const nextProvider = resolved.provider ?? ctx.state.provider;
+    const nextModel = resolved.model ?? ctx.state.model;
+    const levels = thinkingLevelsFor(nextProvider, nextModel);
+    if (!level || !levels.includes(level)) {
+        return {
+            ok: false,
+            result: errorSlashResult([
+                style.metricsRed(`\n  Unsupported thinking level: ${requestedThinking}`),
+                style.phosphorDim(`  Target: ${nextProvider ?? "auto"}/${nextModel ?? "auto"}`),
+                style.phosphorDim(`  Supported: ${levels.join(" → ")}`),
+                style.phosphorDim(`  Usage: /model ${ref}:${levels.join("|")}\n`),
+            ].join("\n")),
+        };
+    }
+    return { ok: true, level, levels };
+}
+function applyThinkingOverride(ctx, result, level, levels) {
+    const nextModel = result.statePatch?.model ?? ctx.state.model;
+    if (!nextModel)
+        return result;
+    ctx.env.OMK_THINKING = level;
+    ctx.env.OMK_MODEL_VARIANT = formatThinkingModelVariant(nextModel, level);
+    const statePatch = result.statePatch ?? {};
+    result.statePatch = {
+        ...statePatch,
+        thinking: level,
+        updatedAt: new Date().toISOString(),
+    };
+    result.text = [
+        result.text?.trimEnd(),
+        style.phosphorDim(`  Thinking: ${level}  (cycle: ${levels.join(" → ")})`),
+    ].filter(Boolean).join("\n");
+    return result;
+}
+async function applyProviderOverride(ctx, provider, model) {
+    const bootstrap = await resolveRuntimeBootstrap({
+        provider,
+        model: model ?? ctx.state.model,
+        cwd: ctx.input.root,
+        env: ctx.env,
+    });
+    if (!bootstrap.ok) {
+        const lines = [style.metricsRed(`\n  Provider not ready: ${provider}`)];
+        if (bootstrap.reason)
+            lines.push(style.phosphorDim(`  ${bootstrap.reason}`));
+        for (const hint of bootstrap.setupHints.slice(0, 3))
+            lines.push(style.phosphorDim(`  - ${hint}`));
+        lines.push(style.phosphorDim(`  Restart/setup: omk auth ${provider} --setup\n`));
+        return okSlashResult({ text: lines.join("\n") });
+    }
+    const statePatch = {
+        bootstrap,
+        provider: bootstrap.provider,
+        model: bootstrap.selectedModel,
+        updatedAt: new Date().toISOString(),
+    };
+    if (bootstrap.selectedModel)
+        ctx.env.OMK_PROVIDER_MODEL = bootstrap.selectedModel;
+    else
+        delete ctx.env.OMK_PROVIDER_MODEL;
+    return okSlashResult({
+        statePatch,
+        text: [
+            style.phosphor(`\n  Provider switched for this session: ${bootstrap.provider}`),
+            style.phosphorDim(`  Runtime: ${bootstrap.selectedRuntimeId ?? "auto"} | Model: ${bootstrap.selectedModel ?? "auto"}`),
+            style.phosphorDim("  Persistent default unchanged; use `omk provider use` to persist.\n"),
+        ].join("\n"),
+    });
+}
+async function applyModelOverride(ctx, ref) {
+    const resolved = await resolveUserModelAlias(ref, { env: ctx.env });
+    const updatedAt = new Date().toISOString();
+    const lines = [
+        style.phosphor(`\n  Model override for this session: ${ref} → ${resolved.model}`),
+    ];
+    if (resolved.provider)
+        lines.push(style.phosphorDim(`  Provider: ${resolved.provider}`));
+    lines.push(style.phosphorDim("  Persistent default unchanged; use `omk model use` to persist.\n"));
+    if (resolved.provider && resolved.provider !== ctx.state.provider) {
+        const providerResult = await applyProviderOverride(ctx, resolved.provider, resolved.model);
+        if (providerResult.statePatch?.provider !== resolved.provider)
+            return providerResult;
+        const providerPatch = providerResult.statePatch ?? {};
+        const bootstrap = {
+            ...(providerPatch.bootstrap ?? ctx.state.bootstrap),
+            selectedModel: resolved.model,
+        };
+        ctx.env.OMK_PROVIDER_MODEL = resolved.model;
+        return okSlashResult({
+            statePatch: {
+                ...providerPatch,
+                bootstrap,
+                model: resolved.model,
+                updatedAt,
+            },
+            text: [providerResult.text?.trimEnd(), ...lines]
+                .filter(Boolean)
+                .join("\n"),
+        });
+    }
+    const statePatch = {
+        bootstrap: {
+            ...ctx.state.bootstrap,
+            selectedModel: resolved.model,
+        },
+        model: resolved.model,
+        updatedAt,
+    };
+    ctx.env.OMK_PROVIDER_MODEL = resolved.model;
+    return okSlashResult({ statePatch, text: lines.join("\n") });
+}
+function renderAuthReport(report, verbose) {
+    const lines = [
+        style.phosphorBold("OMK Auth Center"),
+        style.phosphorDim(`Default provider: ${report.defaultProvider}`),
+        style.phosphorDim(`Authority: ${report.authorityProvider}`),
+    ];
+    if (report.model)
+        lines.push(style.phosphorDim(`Model: ${report.model}`));
+    lines.push("");
+    for (const provider of report.providers) {
+        const mark = provider.available
+            ? style.phosphorBold("✓")
+            : provider.enabled
+                ? style.phosphorDim("○")
+                : style.phosphorDim("×");
+        const state = provider.available
+            ? "runtime ready"
+            : provider.enabled
+                ? "needs setup"
+                : "disabled";
+        const auth = provider.apiKeyEnv
+            ? `${provider.authMethod} ${provider.apiKeyEnv}`
+            : provider.authMethod;
+        lines.push(`  ${mark} ${style.phosphor(provider.provider.padEnd(12))} ${style.phosphorDim(state.padEnd(14))} ${style.phosphorDim(auth)}`);
+        if (verbose && provider.nextActions.length > 0) {
+            for (const action of provider.nextActions.slice(0, 3))
+                lines.push(style.phosphorDim(`      - ${action}`));
+        }
+    }
+    lines.push("");
+    lines.push(style.phosphorDim("Secret policy: tokenFilesRead=false, secretValuesPrinted=false"));
+    lines.push(style.phosphorDim("Use `omk auth <provider> --setup` for setup actions."));
+    return lines.join("\n");
+}

package/dist/commands/chat/slash/commands/session.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommandSpec } from "../types.js";
+export declare function buildSessionSlashCommands(): SlashCommandSpec[];

package/dist/commands/chat/slash/commands/session.js

@@ -0,0 +1,86 @@
+import { style } from "../../../../util/theme.js";
+import { readTodos } from "../../../../util/todo-sync.js";
+import { commandLine, formatScopedNames, section } from "../format.js";
+import { okSlashResult } from "../result.js";
+export function buildSessionSlashCommands() {
+    return [
+        {
+            name: "/exit",
+            aliases: ["/quit", ":q"],
+            group: "session",
+            summary: "Exit chat session",
+            usage: "/exit",
+            examples: ["/quit"],
+            handler: () => okSlashResult({ exit: true }),
+        },
+        {
+            name: "/help",
+            aliases: ["/h", "/?"],
+            group: "session",
+            summary: "Show slash command help",
+            usage: "/help",
+            examples: ["/help"],
+            handler: () => okSlashResult({ text: renderSlashHelp() }),
+        },
+        {
+            name: "/status",
+            aliases: ["/s"],
+            group: "session",
+            summary: "Show session status",
+            usage: "/status",
+            examples: ["/status"],
+            handler: async (ctx) => {
+                const { input, state } = ctx;
+                const uptime = process.uptime();
+                const mem = process.memoryUsage();
+                const lines = [
+                    style.phosphorBold(`\n  Session: ${input.runId}`),
+                    `  Provider: ${style.phosphor(state.provider)} | Model: ${style.phosphorDim(state.model ?? "auto")}`,
+                    `  Uptime: ${style.phosphorDim(`${Math.floor(uptime / 60)}m ${Math.floor(uptime % 60)}s`)}`,
+                    `  Heap: ${style.phosphorDim(`${(mem.heapUsed / 1024 / 1024).toFixed(1)}M`)} / ${style.phosphorDim(`${(mem.heapTotal / 1024 / 1024).toFixed(1)}M`)}`,
+                    `  Layout: ${style.phosphorDim(input.layout)} | Root: ${style.phosphorDim(input.root)}`,
+                    `  CWD: ${style.phosphorDim(input.activeCwd ?? process.cwd())} | Source: ${style.phosphorDim(input.rootSource ?? "unknown")}`,
+                    `  MCP: ${style.phosphorDim(formatScopedNames(input.mcpAllowlist, "none"))}`,
+                    `  Skills: ${style.phosphorDim(formatScopedNames(input.skillNames, "none"))}`,
+                    `  Hooks: ${style.phosphorDim(formatScopedNames(input.hookNames, "none"))}`,
+                    `  Theme: ${style.phosphorDim(state.theme ?? "system24")} | View: ${style.phosphorDim(state.view ?? "summary")} | Animation: ${style.phosphorDim(state.animation ?? ctx.env.OMK_ANIMATION ?? "auto")}`,
+                ];
+                const todos = await readTodos(input.runId).catch(() => null);
+                if (todos && todos.length > 0) {
+                    const counts = { pending: 0, in_progress: 0, done: 0, failed: 0, blocked: 0, skipped: 0 };
+                    for (const todo of todos)
+                        counts[todo.status] = (counts[todo.status] ?? 0) + 1;
+                    lines.push(`  TODOs: ${style.mint(String(counts.in_progress))} active · ${style.phosphorDim(String(counts.pending))} pending · ${style.phosphorDim(String(counts.done))} done`);
+                    for (const todo of todos.filter((item) => item.status === "in_progress").slice(0, 3)) {
+                        lines.push(style.phosphorDim(`    ▶ ${todo.title.slice(0, 60)}`));
+                    }
+                }
+                lines.push("");
+                return okSlashResult({ text: lines.join("\n") });
+            },
+        },
+    ];
+}
+function renderSlashHelp() {
+    return section("OMK Slash Commands:", [
+        commandLine("/exit", "/quit :q", "Exit chat session"),
+        commandLine("/help", "/h /?", "Show this help"),
+        commandLine("/auth", "", "Show provider auth status"),
+        commandLine("/providers", "", "List available providers"),
+        commandLine("/provider", "<name>", "Switch provider"),
+        commandLine("/model", "<name>", "Set session model"),
+        commandLine("/use", "<ref>", "Provider/model alias"),
+        commandLine("/route", "<prompt>", "Preview route policy/evidence/agent lanes"),
+        commandLine("/mcp", "[--all]", "MCP Tool Plane status"),
+        commandLine("/tools", "", "Scoped MCP/skills/hooks"),
+        commandLine("/theme", "<system24|green-rain|neon-grid|rust-forge|plain|high-contrast>", "Set session theme"),
+        commandLine("/view", "<summary|graph|evidence|tool-plane|events>", "Set control-plane view"),
+        commandLine("/animation", "<off|low|auto|full>", "Set animation policy"),
+        commandLine("/status", "", "Session status"),
+        commandLine("/clear", "/cls", "Clear screen"),
+        commandLine("/runs", "", "Recent run history"),
+        commandLine("/doctor", "", "Run omk doctor"),
+        commandLine("/parallel", "<prompt>", "Parallel orchestrator"),
+        style.phosphorDim("\n  Any other input is routed to the AI agent."),
+    ]);
+}

package/dist/commands/chat/slash/commands/tool-plane.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommandSpec } from "../types.js";
+export declare function buildToolPlaneSlashCommands(): SlashCommandSpec[];

package/dist/commands/chat/slash/commands/tool-plane.js

@@ -0,0 +1,64 @@
+import { runMcpAutoConnect, renderMcpAutoConnectBanner } from "../../../../mcp/autoconnect.js";
+import { style } from "../../../../util/theme.js";
+import { formatScopedNames } from "../format.js";
+import { okSlashResult } from "../result.js";
+export function buildToolPlaneSlashCommands() {
+    return [
+        {
+            name: "/mcp",
+            aliases: [":mcp"],
+            group: "tool-plane",
+            summary: "Show MCP Tool Plane status",
+            usage: "/mcp [--all] [--fix]",
+            examples: ["/mcp", "/mcp --all"],
+            handler: async (ctx, args) => {
+                const wantsFullPreflight = Boolean(args.flags.all);
+                const wantsFix = Boolean(args.flags.fix) || args.positional.includes("fix") || args.positional.includes("repair");
+                const report = await runMcpAutoConnect({
+                    preflight: wantsFullPreflight ? "full" : "fast",
+                    env: {
+                        ...ctx.env,
+                        OMK_MCP_PREFLIGHT: wantsFullPreflight ? ctx.env.OMK_MCP_PREFLIGHT : "off",
+                    },
+                });
+                if (args.flags.json)
+                    return okSlashResult({ json: report });
+                const lines = ["", renderMcpAutoConnectBanner(report), ""];
+                if (wantsFix)
+                    lines.push(style.phosphorDim("  Repairs are explicit CLI actions: omk mcp connect --fix\n"));
+                return okSlashResult({ text: lines.join("\n") });
+            },
+        },
+        {
+            name: "/tools",
+            aliases: [":tools"],
+            group: "tool-plane",
+            summary: "Show scoped MCP/skills/hooks",
+            usage: "/tools [--json]",
+            examples: ["/tools", "/tools --json"],
+            handler: (ctx, args) => {
+                const payload = {
+                    mcp: ctx.input.mcpAllowlist ?? [],
+                    skills: ctx.input.skillNames ?? [],
+                    hooks: ctx.input.hookNames ?? [],
+                    runtime: ctx.state.bootstrap.selectedRuntimeId ?? "none",
+                    provider: ctx.state.provider,
+                    execution: ctx.input.executionPrompt ?? "auto",
+                };
+                if (args.flags.json)
+                    return okSlashResult({ json: payload });
+                return okSlashResult({
+                    text: [
+                        style.phosphorBold("\n  Scoped Tool Plane:"),
+                        `  MCP:    ${style.phosphorDim(formatScopedNames(ctx.input.mcpAllowlist))}`,
+                        `  Skills: ${style.phosphorDim(formatScopedNames(ctx.input.skillNames))}`,
+                        `  Hooks:  ${style.phosphorDim(formatScopedNames(ctx.input.hookNames))}`,
+                        `  Runtime: ${style.phosphorDim(`${payload.runtime} (${payload.provider})`)}`,
+                        `  Safety: ${style.phosphorDim(`execution=${payload.execution}; provider metadata is scoped per turn`)}`,
+                        style.phosphorDim("  Use /mcp for MCP status or `omk mcp connect --json` for the full contract.\n"),
+                    ].join("\n"),
+                });
+            },
+        },
+    ];
+}

package/dist/commands/chat/slash/commands/ui.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommandSpec } from "../types.js";
+export declare function buildUiSlashCommands(): SlashCommandSpec[];