@chengchenccc/oh-my-agent 0.1.1-rc.1

package/dist/modes/tui/tui-commands-session.js

@@ -0,0 +1,191 @@
+import { deleteSession, forkSession, listAllSessions, listSessions, renameSession, sessionDirFor, } from "../../core/session/session-file.js";
+import { resolveSession } from "../../core/session/session-loop.js";
+import { hydrateTranscript } from "./view-state.js";
+export function buildSessionCommands(ctx) {
+    return [
+        {
+            name: "session",
+            description: "show the current session id and title",
+            group: "session",
+            live: true,
+            run: () => {
+                ctx.pushStatus(`session: ${ctx.session.sessionId}${ctx.sessionTitle ? ` — ${ctx.sessionTitle}` : ""}`);
+            },
+        },
+        {
+            name: "resume",
+            description: "list/resume sessions (all = every workspace)",
+            argumentHint: "<session>",
+            group: "session",
+            run: async (args) => {
+                // "all" = cross-workspace listing (pi's session selector "all"
+                // scope); any other arg is an id/prefix within this workspace.
+                const all = args === "all";
+                const sessions = all ? listAllSessions() : listSessions();
+                if (sessions.length === 0) {
+                    ctx.pushStatus(all ? "no sessions in any workspace" : "no saved sessions");
+                    return;
+                }
+                if (!args || all) {
+                    // Interactive overlay when the ctx.io supports it; text list otherwise.
+                    if (ctx.io.pickSession) {
+                        const picked = await ctx.io.pickSession(sessions.slice(0, 20));
+                        if (!picked) {
+                            ctx.pushStatus("resume cancelled");
+                            return;
+                        }
+                        const summary = sessions.find((s) => s.id === picked);
+                        const dir = all && summary?.workspace ? sessionDirFor(summary.workspace) : undefined;
+                        ctx.session = resolveSession(picked, dir);
+                        ctx.sessionTitle = summary?.title;
+                        hydrateTranscript(ctx.state, ctx.session.messages);
+                        ctx.io.setHeader?.({
+                            model: ctx.modelId,
+                            sessionId: ctx.session.sessionId,
+                            title: ctx.sessionTitle,
+                        });
+                        ctx.pushStatus(`resumed session: ${ctx.session.sessionId} (${ctx.session.messages.length} messages)`);
+                        return;
+                    }
+                    ctx.pushStatus(sessions.slice(0, 20).map((s) => {
+                        const when = new Date(s.modifiedAt).toISOString().slice(0, 16).replace("T", " ");
+                        const workspace = s.workspace ? ` [${s.workspace}]` : "";
+                        const fork = s.forkOf ? ` \u2442 ${s.forkOf.slice(0, 8)}` : "";
+                        return `${when}  ${s.id}${fork}${workspace}  ${s.title ?? s.preview}`;
+                    }));
+                    return;
+                }
+                const matches = sessions.filter((s) => s.id.startsWith(args));
+                if (matches.length === 0) {
+                    ctx.pushStatus(`no session matches: ${args} (see /resume for the list)`);
+                    return;
+                }
+                if (matches.length > 1) {
+                    ctx.pushStatus(matches.map((s) => `${s.id}  ${s.title ?? s.preview}`));
+                    return;
+                }
+                ctx.session = resolveSession(matches[0].id, undefined);
+                ctx.sessionTitle = matches[0].title;
+                hydrateTranscript(ctx.state, ctx.session.messages);
+                ctx.io.setHeader?.({
+                    model: ctx.modelId,
+                    sessionId: ctx.session.sessionId,
+                    title: ctx.sessionTitle,
+                });
+                ctx.pushStatus(`resumed session: ${ctx.session.sessionId} (${ctx.session.messages.length} messages)`);
+            },
+        },
+        {
+            name: "new",
+            description: "start a fresh session (clears the transcript)",
+            group: "session",
+            run: () => {
+                ctx.session = resolveSession();
+                ctx.sessionTitle = undefined;
+                hydrateTranscript(ctx.state, ctx.session.messages);
+                ctx.io.setHeader?.({
+                    model: ctx.modelId,
+                    sessionId: ctx.session.sessionId,
+                    title: ctx.sessionTitle,
+                });
+                ctx.pushStatus(`new session: ${ctx.session.sessionId}`);
+            },
+        },
+        {
+            name: "clear",
+            description: "clear the transcript view (keeps the session)",
+            group: "view",
+            run: () => {
+                ctx.state.runs.length = 0;
+            },
+        },
+        {
+            name: "fork",
+            description: "fork the session from an earlier user message",
+            argumentHint: "<n>",
+            group: "session",
+            run: async (args) => {
+                // Anchors: user-role messages in the live transcript. Compaction
+                // summaries carry role user too; they are legitimate fork points.
+                const anchors = ctx.session.messages
+                    .filter((m) => m.role === "user")
+                    .map((m) => String(m.text ?? ""));
+                if (anchors.length === 0) {
+                    ctx.pushStatus("no user messages to fork from yet");
+                    return;
+                }
+                let ordinal;
+                const parsed = Number(args);
+                if (args && Number.isInteger(parsed) && parsed >= 1) {
+                    ordinal = parsed;
+                }
+                else if (ctx.io.pickForkPoint) {
+                    const picked = await ctx.io.pickForkPoint(anchors.map((text, i) => ({
+                        ordinal: i + 1,
+                        text: text.replace(/\s+/g, " ").slice(0, 60),
+                    })));
+                    if (picked === null) {
+                        ctx.pushStatus("fork cancelled");
+                        return;
+                    }
+                    ordinal = picked;
+                }
+                else {
+                    ctx.pushStatus("usage: /fork <n> (n = user message number)");
+                    return;
+                }
+                const parentId = ctx.session.sessionId;
+                const newId = forkSession(parentId, ordinal, ctx.session.dir);
+                if (newId === null) {
+                    ctx.pushStatus(`cannot fork: no user message #${ordinal}`);
+                    return;
+                }
+                ctx.session = resolveSession(newId, ctx.session.dir);
+                ctx.sessionTitle = undefined;
+                hydrateTranscript(ctx.state, ctx.session.messages);
+                ctx.io.setHeader?.({ model: ctx.modelId, sessionId: ctx.session.sessionId });
+                ctx.pushStatus(`forked ${parentId.slice(0, 8)} @ msg ${ordinal} -> ${newId.slice(0, 8)} ` +
+                    `(${ctx.session.messages.length} messages)`);
+            },
+        },
+        {
+            name: "rename",
+            description: "rename a ctx.session's title",
+            argumentHint: "<ctx.session> <title>",
+            group: "session",
+            run: (args) => {
+                const space = args.indexOf(" ");
+                if (space <= 0) {
+                    ctx.pushStatus("usage: /rename <ctx.session-id> <title>");
+                    return;
+                }
+                const id = args.slice(0, space).trim();
+                const title = args.slice(space + 1).trim();
+                if (!title) {
+                    ctx.pushStatus("usage: /rename <ctx.session-id> <title>");
+                    return;
+                }
+                if (!renameSession(id, title))
+                    ctx.pushStatus(`no ctx.session: ${id}`);
+                else
+                    ctx.pushStatus(`renamed ${id} → ${title}`);
+            },
+        },
+        {
+            name: "delete",
+            description: "delete a ctx.session file",
+            argumentHint: "<session>",
+            group: "session",
+            run: (args) => {
+                if (!args) {
+                    ctx.pushStatus("usage: /delete <ctx.session-id>");
+                    return;
+                }
+                if (!deleteSession(args))
+                    ctx.pushStatus(`no ctx.session: ${args}`);
+                else
+                    ctx.pushStatus(`deleted ctx.session: ${args}`);
+            },
+        },
+    ];
+}

package/dist/modes/tui/tui-commands.d.ts

@@ -0,0 +1,52 @@
+import type { OmaRuntime } from "../../core/runtime/create-runtime.js";
+import type { TuiIo, TuiModeOptions } from "./tui-mode.js";
+import type { TuiViewState } from "./view-state.js";
+export interface CommandDef {
+    name: string;
+    description: string;
+    argumentHint?: string;
+    group: string;
+    aliases?: readonly string[];
+    live?: boolean;
+    run: (args: string) => void | Promise<void>;
+}
+export interface TuiSessionContext {
+    state: TuiViewState;
+    io: TuiIo;
+    opts: TuiModeOptions;
+    session: {
+        sessionId: string;
+        messages: Record<string, unknown>[];
+        dir: string;
+    };
+    sessionTitle?: string;
+    modelId?: string;
+    quitting: boolean;
+    exitArmed: boolean;
+    pendingPrompt?: string;
+    pendingWorkflowScript?: string;
+    liveRuntime: OmaRuntime | null;
+    pushStatus: (lines: string | readonly string[], replacePrefix?: string) => void;
+    commandsWithSkills?: readonly CommandDef[];
+    listModels: () => Promise<string[]>;
+    listModelRows: () => Promise<Array<{
+        id: string;
+        meta: string;
+        contextWindow: number;
+    }>>;
+    listSessions: () => Array<{
+        id: string;
+        title?: string;
+        preview?: string;
+        workspace?: string;
+        modifiedAt: number;
+        forkOf?: string;
+    }>;
+    lastContextTokens?: number;
+    pendingFocusRecap?: string;
+    runCommandText?: (text: string) => Promise<void>;
+    pickModelInteractive: () => Promise<void>;
+    forkTreeInteractive: () => Promise<void>;
+}
+export declare function buildCommands(ctx: TuiSessionContext): CommandDef[];
+//# sourceMappingURL=tui-commands.d.ts.map

package/dist/modes/tui/tui-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-commands.d.ts","sourceRoot":"","sources":["../../../src/modes/tui/tui-commands.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AAUvE,OAAO,KAAK,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,YAAY,CAAC;IACpB,EAAE,EAAE,KAAK,CAAC;IACV,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IACjF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,WAAW,EAAE,UAAU,GAAG,IAAI,CAAC;IAC/B,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EAAE,aAAa,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAChF,kBAAkB,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IAC3C,UAAU,EAAE,MAAM,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACpC,aAAa,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;IACzF,YAAY,EAAE,MAAM,KAAK,CAAC;QACxB,EAAE,EAAE,MAAM,CAAC;QACX,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,oBAAoB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,mBAAmB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,iBAAiB,GAAG,UAAU,EAAE,CA4XlE"}

package/dist/modes/tui/tui-commands.js

@@ -0,0 +1,373 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { resolveStandaloneSkillRoots } from "../../cli/initial-input.js";
+import { addMarketplace, installPlugin, listInstalledPlugins, listMarketplaces, removeMarketplace, setPluginEnabled, uninstallPlugin, } from "../../core/plugins/plugin-marketplace.js";
+import { trustFile, trustPlugin } from "../../core/plugins/plugin-trust.js";
+import { loadProjectSettings, saveProjectModel, saveProjectSettings, } from "../../core/settings/project-settings.js";
+import { buildSkillIndex } from "../../core/tools/index.js";
+import { listMcpServers, testMcpServer } from "../../core/tools/mcp-mount.js";
+import { buildSessionCommands } from "./tui-commands-session.js";
+import { formatTokens } from "./tui-format.js";
+export function buildCommands(ctx) {
+    const commands = [
+        {
+            name: "help",
+            description: "list slash commands",
+            group: "general",
+            live: true,
+            run: () => {
+                const groups = [];
+                for (const c of ctx.commandsWithSkills ?? []) {
+                    const aliases = c.aliases?.length ? `|${c.aliases.join("|")}` : "";
+                    const entry = `/${c.name}${aliases}${c.argumentHint ? ` ${c.argumentHint}` : ""} — ${c.description}`;
+                    const found = groups.find(([name]) => name === c.group);
+                    if (found)
+                        found[1].push(entry);
+                    else
+                        groups.push([c.group, [entry]]);
+                }
+                ctx.pushStatus(groups.flatMap(([group, entries]) => [`[${group}]`, ...entries.map((e) => `  ${e}`)]));
+            },
+        },
+        {
+            name: "exit",
+            description: "quit the session (twice to confirm)",
+            group: "general",
+            live: true,
+            run: () => {
+                if (ctx.exitArmed) {
+                    ctx.quitting = true;
+                    return;
+                }
+                ctx.exitArmed = true;
+                ctx.pushStatus("type /exit again to quit");
+            },
+        },
+        {
+            name: "quit",
+            description: "alias of /exit",
+            group: "general",
+            live: true,
+            run: () => {
+                if (ctx.exitArmed) {
+                    ctx.quitting = true;
+                    return;
+                }
+                ctx.exitArmed = true;
+                ctx.pushStatus("type /quit again to quit");
+            },
+        },
+        ...buildSessionCommands(ctx),
+        {
+            name: "settings",
+            description: "edit project settings (.oma/settings.json)",
+            group: "settings",
+            run: async () => {
+                if (!ctx.io.editSettings) {
+                    ctx.pushStatus("settings editor not supported");
+                    return;
+                }
+                const updated = await ctx.io.editSettings(loadProjectSettings(ctx.opts.workspaceRoot));
+                if (!updated) {
+                    ctx.pushStatus("settings edit cancelled");
+                    return;
+                }
+                saveProjectSettings(ctx.opts.workspaceRoot, updated);
+                ctx.pushStatus("settings saved");
+                ctx.io.render(ctx.state);
+            },
+        },
+        {
+            name: "plugin",
+            aliases: ["plugins"],
+            description: "list/install/uninstall/enable/disable plugins",
+            argumentHint: "[list|install <mkt>/<plugin>|uninstall <name>|enable <name>|disable <name>|trust <name>]",
+            group: "settings",
+            run: async (args) => {
+                const [sub, ...rest] = args.trim().split(/\s+/);
+                if (!sub || sub === "list") {
+                    const plugins = listInstalledPlugins(ctx.opts.workspaceRoot);
+                    if (plugins.length === 0) {
+                        ctx.pushStatus("no plugins installed");
+                        return;
+                    }
+                    ctx.pushStatus([
+                        `plugins (${plugins.length}):`,
+                        ...plugins.map((p) => `  ${p.enabled ? "+" : "-"} ${p.name}${p.description ? ` \u2014 ${p.description}` : ""} (${p.scope})`),
+                    ]);
+                    return;
+                }
+                if (sub === "install") {
+                    const ref = rest[0];
+                    if (!ref) {
+                        ctx.pushStatus("usage: /plugin install <marketplace>/<plugin>");
+                        return;
+                    }
+                    const res = installPlugin(ctx.opts.workspaceRoot, ref);
+                    if (!res.ok) {
+                        ctx.pushStatus(`plugin install failed: ${res.error}`);
+                        return;
+                    }
+                    ctx.pushStatus(`installed plugin: ${ref}`);
+                    ctx.io.render(ctx.state);
+                    return;
+                }
+                if (sub === "uninstall") {
+                    const name = rest[0];
+                    if (!name) {
+                        ctx.pushStatus("usage: /plugin uninstall <name>");
+                        return;
+                    }
+                    ctx.pushStatus(uninstallPlugin(ctx.opts.workspaceRoot, name)
+                        ? `uninstalled plugin: ${name}`
+                        : `no plugin: ${name}`);
+                    return;
+                }
+                if (sub === "enable" || sub === "disable") {
+                    const name = rest[0];
+                    if (!name) {
+                        ctx.pushStatus(`usage: /plugin ${sub} <name>`);
+                        return;
+                    }
+                    const enabled = sub === "enable";
+                    ctx.pushStatus(setPluginEnabled(ctx.opts.workspaceRoot, name, enabled)
+                        ? `plugin ${sub}d: ${name}`
+                        : `no plugin: ${name}`);
+                    return;
+                }
+                if (sub === "trust") {
+                    const name = rest[0];
+                    if (!name) {
+                        ctx.pushStatus("usage: /plugin trust <name>");
+                        return;
+                    }
+                    const plugins = listInstalledPlugins(ctx.opts.workspaceRoot);
+                    const target = plugins.find((p) => p.name === name && p.scope === "project");
+                    if (!target) {
+                        ctx.pushStatus(`no project-scope plugin named "${name}"`);
+                        return;
+                    }
+                    trustPlugin(target.root);
+                    ctx.pushStatus(`trusted ${name} (hash recorded; code components will load)`);
+                    return;
+                }
+                ctx.pushStatus("usage: /plugin list|install <mkt>/<plugin>|uninstall <name>|enable <name>|disable <name>|trust <name>");
+            },
+        },
+        {
+            name: "marketplace",
+            aliases: ["marketplaces"],
+            description: "list/add/remove marketplaces",
+            argumentHint: "[list|add <path|url>|remove <name>]",
+            group: "settings",
+            run: (args) => {
+                const [sub, ...rest] = args.trim().split(/\s+/);
+                if (!sub || sub === "list") {
+                    const markets = listMarketplaces(ctx.opts.workspaceRoot);
+                    if (markets.length === 0) {
+                        ctx.pushStatus("no marketplaces added");
+                        return;
+                    }
+                    ctx.pushStatus([
+                        `marketplaces (${markets.length}):`,
+                        ...markets.map((m) => `  ${m.name} \u2014 ${m.source}`),
+                    ]);
+                    return;
+                }
+                if (sub === "add") {
+                    const source = rest[0];
+                    if (!source) {
+                        ctx.pushStatus("usage: /marketplace add <path|url>");
+                        return;
+                    }
+                    const res = addMarketplace(ctx.opts.workspaceRoot, source);
+                    if (!res.ok) {
+                        ctx.pushStatus(`marketplace add failed: ${res.error}`);
+                        return;
+                    }
+                    ctx.pushStatus(`added marketplace: ${res.name ?? source}`);
+                    return;
+                }
+                if (sub === "remove") {
+                    const name = rest[0];
+                    if (!name) {
+                        ctx.pushStatus("usage: /marketplace remove <name>");
+                        return;
+                    }
+                    ctx.pushStatus(removeMarketplace(ctx.opts.workspaceRoot, name)
+                        ? `removed marketplace: ${name}`
+                        : `no marketplace: ${name}`);
+                    return;
+                }
+                ctx.pushStatus("usage: /marketplace list|add <path|url>|remove <name>");
+            },
+        },
+        {
+            name: "model",
+            aliases: ["models"],
+            description: "show or switch the model",
+            argumentHint: "<provider/model>",
+            group: "model",
+            live: true,
+            run: async (args) => {
+                if (!args) {
+                    // TUI: the interactive picker IS the listing (pi's /model opens the
+                    // selector); the text list is the headless fallback.
+                    if (ctx.io.pickModel) {
+                        await ctx.pickModelInteractive();
+                        return;
+                    }
+                    const rows = await ctx.listModelRows();
+                    const current = ctx.modelId ?? rows[0]?.id ?? "(none)";
+                    ctx.pushStatus([
+                        `current model: ${current}`,
+                        ...rows.map((r) => `  ${r.id === current ? "*" : " "} ${r.id} — ${r.meta}`),
+                    ]);
+                    return;
+                }
+                const rows = await ctx.listModelRows();
+                const row = rows.find((r) => r.id === args);
+                if (!row) {
+                    ctx.pushStatus(`unknown model: ${args} (see /model for the list)`);
+                    return;
+                }
+                ctx.modelId = args;
+                saveProjectModel(ctx.opts.workspaceRoot, ctx.modelId);
+                ctx.io.setHeader?.({
+                    model: ctx.modelId,
+                    sessionId: ctx.session.sessionId,
+                    title: ctx.sessionTitle,
+                });
+                ctx.pushStatus(`model: ${ctx.modelId} · ctx ${formatTokens(row.contextWindow)}`);
+            },
+        },
+        {
+            name: "thinking",
+            description: "toggle thinking blocks (ctrl+t)",
+            group: "view",
+            live: true,
+            run: () => {
+                ctx.state.showThinking = !ctx.state.showThinking;
+                ctx.pushStatus(`thinking ${ctx.state.showThinking ? "expanded" : "collapsed"}`);
+            },
+        },
+        {
+            name: "tools",
+            description: "toggle tool detail (ctrl+o)",
+            group: "view",
+            live: true,
+            run: () => {
+                ctx.state.showToolDetail = !ctx.state.showToolDetail;
+                ctx.pushStatus(`tool detail ${ctx.state.showToolDetail ? "expanded" : "collapsed"}`);
+            },
+        },
+        {
+            name: "abort",
+            description: "abort the live run (esc)",
+            group: "view",
+            live: true,
+            run: () => {
+                if (ctx.liveRuntime)
+                    void ctx.liveRuntime.stop().catch(() => { });
+                else
+                    ctx.pushStatus("no live run");
+            },
+        },
+        {
+            name: "mcp",
+            description: "list .mcp.json servers, or test one",
+            argumentHint: "[list|test <name>|trust]",
+            group: "mcp",
+            live: true,
+            run: async (args) => {
+                const space = args.indexOf(" ");
+                const sub = (space === -1 ? args : args.slice(0, space)).trim();
+                const name = space === -1 ? "" : args.slice(space + 1).trim();
+                if (sub === "test") {
+                    if (!name) {
+                        ctx.pushStatus("usage: /mcp test <name>");
+                        return;
+                    }
+                    ctx.pushStatus(`testing ${name}…`);
+                    ctx.io.render(ctx.state);
+                    const result = await testMcpServer(ctx.opts.workspaceRoot, name);
+                    if (result.ok) {
+                        const tools = result.tools.slice(0, 8).join(", ");
+                        const more = result.tools.length > 8 ? `, +${result.tools.length - 8} more` : "";
+                        ctx.pushStatus(`${name}: ok · ${result.tools.length} tools (${tools}${more})`);
+                    }
+                    else {
+                        ctx.pushStatus(`${name}: FAILED — ${result.error}`);
+                    }
+                    return;
+                }
+                if (sub === "trust") {
+                    const path = join(ctx.opts.workspaceRoot, ".mcp.json");
+                    if (!existsSync(path)) {
+                        ctx.pushStatus(`no .mcp.json in ${ctx.opts.workspaceRoot}`);
+                        return;
+                    }
+                    trustFile(path);
+                    ctx.pushStatus("workspace .mcp.json trusted (hash recorded; servers will mount)");
+                    return;
+                }
+                if (sub) {
+                    ctx.pushStatus(`unknown subcommand "${sub}" — /mcp lists, /mcp test <name> tests, /mcp trust approves the workspace file`);
+                    return;
+                }
+                const servers = listMcpServers(ctx.opts.workspaceRoot);
+                if (servers.length === 0) {
+                    ctx.pushStatus(`no .mcp.json servers in ${ctx.opts.workspaceRoot}`);
+                    return;
+                }
+                ctx.pushStatus([
+                    `mcp servers (${servers.length}) — mounted at run start:`,
+                    ...servers.map((s) => `  ${s.name} [${s.kind}] ${s.detail}`),
+                ]);
+            },
+        },
+        {
+            name: "skill",
+            description: "list installed skills",
+            group: "skill",
+            live: true,
+            run: () => {
+                const skills = buildSkillIndex(resolveStandaloneSkillRoots(ctx.opts.workspaceRoot));
+                if (skills.length === 0) {
+                    ctx.pushStatus(`no skills found (looked in ${join(ctx.opts.workspaceRoot, "skills")})`);
+                    return;
+                }
+                ctx.pushStatus([
+                    `skills (${skills.length}):`,
+                    ...skills.map((sk) => `  /skill:${sk.name} — ${sk.description || "(no description)"}`),
+                ]);
+            },
+        },
+        {
+            name: "workflow",
+            description: "run a workflow script (file path or inline JS)",
+            argumentHint: "<path|script>",
+            group: "workflow",
+            run: (args) => {
+                if (!args) {
+                    ctx.pushStatus("usage: /workflow <path-or-inline-script>");
+                    return;
+                }
+                const firstToken = args.split(/\s+/)[0] ?? "";
+                let script;
+                let label;
+                if (existsSync(firstToken) && statSync(firstToken).isFile()) {
+                    script = readFileSync(firstToken, "utf8");
+                    label = firstToken;
+                }
+                else {
+                    script = args;
+                    label = "inline";
+                }
+                ctx.pendingPrompt = `workflow ${label}`;
+                ctx.pendingWorkflowScript = script;
+            },
+        },
+    ];
+    return commands;
+}