s-app-scoder-agent 0.8.21 → 0.9.3

package/dist/tui/command-registry.js

@@ -1,6 +1,11 @@
 import { listSessions, resolveSessionId } from "../session.js";
-import { discoverSkills } from "../skills.js";
-import { formatSlashHelp, parseMcpExec } from "./commands.js";
+import { discoverSkills, skillWarnings } from "../skills.js";
+import { selectableAgents } from "../agents.js";
+import { agentsMdTemplate } from "../agents-guide.js";
+import { existsSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { formatSlashHelp, parseMcpExec, BUILTIN_COMMANDS, resolveCommandDef, discoverCustomCommands, runCustomCommand } from "./commands.js";
+import { exportTranscript, findInTranscript } from "./transcript.js";
 /** Format usage/cost block (dùng chung — REPL console.log, TUI notice). */
 export function formatUsage(u) {
     return u.calls > 0
@@ -30,8 +35,30 @@ export function formatMcpStatus(status) {
     if (status.length === 0)
         return "no MCP servers configured — add mcpServers to .scoderrc.json";
     return status
-        .map((srv) => `${srv.connected ? "✓" : "·"} ${srv.name} — ${srv.command}` +
-        (srv.connected ? ` (${srv.tools.length} tools)\n` + srv.tools.map((t) => `    mcp__${srv.name}__${t.name}  ${t.description ?? ""}`).join("\n") : " (not connected)"))
+        .map((srv) => {
+        const capParts = [];
+        if (srv.serverInfo?.name)
+            capParts.push(srv.serverInfo.name + (srv.serverInfo.version ? " v" + srv.serverInfo.version : ""));
+        if (srv.capabilities?.ping === true)
+            capParts.push("ping");
+        if (srv.capabilities?.tools)
+            capParts.push("tools");
+        if (srv.capabilities?.resources)
+            capParts.push("resources");
+        if (srv.capabilities?.prompts)
+            capParts.push("prompts");
+        const capTag = capParts.length > 0 ? ` [${capParts.join(", ")}]` : "";
+        const counts = [
+            `${srv.tools.length} tools`,
+            ...(srv.resourceCount ? [`${srv.resourceCount} resources`] : []),
+            ...(srv.promptCount ? [`${srv.promptCount} prompts`] : []),
+        ].join(", ");
+        return (`${srv.connected ? "✓" : "·"} ${srv.name} — ${srv.command}${capTag}` +
+            (srv.connected
+                ? ` (${counts})\n` +
+                    srv.tools.map((t) => `    mcp__${srv.name}__${t.name}  ${t.description ?? ""}`).join("\n")
+                : " (not connected)"));
+    })
         .join("\n");
 }
 /**
@@ -70,9 +97,58 @@ export function coreCommands() {
         },
         {
             name: "/skills",
-            description: "list discovered skills (SKILL.md)",
-            run(_slash, host, notice) {
-                notice(formatSkills(host.agent()?.getSkills() ?? discoverSkills(host.config.workdir)));
+            description: "list/info/lint/reload skills — /skills [info <name>|lint|reload]",
+            run(slash, host, notice) {
+                const arg = slash.arg.trim();
+                const skills = host.agent()?.getSkills() ?? discoverSkills(host.config.workdir);
+                if (!arg) {
+                    notice(formatSkills(skills));
+                    return;
+                }
+                const parts = arg.split(/\s+/);
+                const sub = parts[0].toLowerCase();
+                if (sub === "info") {
+                    const name = parts.slice(1).join(" ").trim();
+                    if (!name)
+                        return notice("usage: /skills info <name>", "warn");
+                    const skill = skills.find((s) => s.name.toLowerCase() === name.toLowerCase());
+                    if (!skill)
+                        return notice(`skill "${name}" not found`, "error");
+                    const lines = [
+                        `# ${skill.name}${skill.version ? ` v${skill.version}` : ""}`,
+                        `description: ${skill.description}`,
+                        `scope: ${skill.scope}`,
+                        skill.tags?.length ? `tags: ${skill.tags.join(", ")}` : null,
+                        skill.allowedTools?.length ? `allowed-tools: ${skill.allowedTools.join(", ")}` : null,
+                        skill.references?.length ? `references: ${skill.references.join(", ")}` : null,
+                        skill.whenToUse ? `when-to-use: ${skill.whenToUse}` : null,
+                        "",
+                        skill.body,
+                    ].filter(Boolean);
+                    notice(lines.join("\n"));
+                    return;
+                }
+                if (sub === "lint") {
+                    const warnings = skillWarnings.filter((w) => !host.config.workdir || w.path.startsWith(host.config.workdir));
+                    if (warnings.length === 0)
+                        return notice("skills lint: ok (no warnings)", "info");
+                    notice(warnings.map((w) => `${w.path}: ${w.message}`).join("\n"), "warn");
+                    return;
+                }
+                if (sub === "reload") {
+                    const ag = host.agent();
+                    if (ag)
+                        ag.reloadSkills?.();
+                    notice(formatSkills(host.agent()?.getSkills() ?? discoverSkills(host.config.workdir)));
+                    return;
+                }
+                // default: treat arg as skill name → show info
+                const skill = skills.find((s) => s.name.toLowerCase() === arg.toLowerCase());
+                if (skill) {
+                    notice(`# ${skill.name}\n${skill.description}\n${skill.body.slice(0, 500)}`, "info");
+                    return;
+                }
+                notice(`unknown /skills subcommand: ${arg}`, "error");
             },
         },
         {
@@ -135,10 +211,86 @@ export function coreCommands() {
                     return;
                 }
                 host.agent()?.setPermissionMode(mode);
+                host.updateConfig?.({ permissionMode: mode });
                 host.config = withPermissionMode(host.config, mode);
                 notice(`permission mode → ${mode}`);
             },
         },
+        {
+            name: "/plan",
+            description: "show the current plan — /plan done|start <id|n|text> to mark steps",
+            run(slash, host, notice) {
+                const agent = host.agent();
+                const plan = agent?.getPlan() ?? [];
+                if (!slash.arg) {
+                    if (plan.length === 0)
+                        return notice("no plan yet — multi-step tasks get one via write_todos");
+                    const icon = (s) => (s === "completed" ? "✓" : s === "in_progress" ? "▸" : "○");
+                    notice("Plan:\n" +
+                        plan
+                            .map((t, i) => {
+                            let line = `  ${icon(t.status)} ${String(i + 1).padStart(2)}. ${t.content}`;
+                            if (t.verify)
+                                line += `\n       verify: ${t.verify}`;
+                            if (t.acceptance)
+                                line += `\n       acceptance: ${t.acceptance}`;
+                            if (t.files?.length)
+                                line += `\n       files: ${t.files.join(", ")}`;
+                            return line;
+                        })
+                            .join("\n") +
+                        "\nmark: /plan done <id|n> · /plan start <id|n>");
+                    return;
+                }
+                const m = /^(done|start)\s+(.+)$/.exec(slash.arg.trim());
+                if (!agent)
+                    return notice("agent not ready", "warn");
+                if (!m)
+                    return notice("usage: /plan [done|start <id|n|text>]", "warn");
+                const r = agent.markPlanStep(m[1] === "done" ? "completed" : "in_progress", m[2]);
+                notice(r.message, r.ok ? "info" : "warn");
+            },
+        },
+        {
+            name: "/agent",
+            description: "list selectable agents — /agent <name> to switch (idle only)",
+            run(slash, host, notice) {
+                const agents = selectableAgents(host.config.workdir);
+                const current = host.config.agent ?? "build";
+                if (!slash.arg) {
+                    notice("Agents:\n" +
+                        agents.map((a) => `  ${a.name === current ? "*" : " "} ${a.name.padEnd(10)} ${a.description}`).join("\n") +
+                        "\nswitch with /agent <name> (idle only; resets the conversation)");
+                    return;
+                }
+                const name = slash.arg.trim();
+                const def = agents.find((a) => a.name === name);
+                if (!def) {
+                    return notice(`agent "${name}" not selectable — available: ${agents.map((a) => a.name).join(", ")}`, "error");
+                }
+                if (current === name)
+                    return notice(`already on agent "${name}"`);
+                if (host.isRunning?.())
+                    return notice("agent is running — wait or Esc first", "warn");
+                host.updateConfig?.({ agent: name });
+                host.config = { ...host.config, agent: name };
+                host.replaceAgent(null); // fresh agent with the new def; old conversation ends here
+                notice(`agent → ${name} (${def.mode}) — conversation reset; /sessions can resume the previous one`);
+            },
+        },
+        {
+            name: "/init",
+            description: "create an AGENTS.md template in this project",
+            run(_slash, host, notice) {
+                const target = join(host.config.workdir, "AGENTS.md");
+                if (existsSync(target)) {
+                    notice(`AGENTS.md already exists: ${target}`, "warn");
+                    return;
+                }
+                writeFileSync(target, agentsMdTemplate(host.config.workdir), "utf8");
+                notice(`created ${target} — review and commit it`);
+            },
+        },
         {
             name: "/sessions",
             description: "list saved sessions — /sessions resume <id|last>",
@@ -160,8 +312,115 @@ export function coreCommands() {
                 notice(formatSessions(listSessions(host.config.workdir)));
             },
         },
+        {
+            name: "/commands",
+            description: "list all commands (builtin + custom) — /commands <name> to inspect",
+            run(slash, host, notice) {
+                const all = BUILTIN_COMMANDS.map((c) => ({
+                    name: c.name,
+                    desc: c.description,
+                    source: c.source,
+                }));
+                const custom = discoverCustomCommands(host.config.workdir).map((c) => ({
+                    name: "/commands " + c.name,
+                    desc: c.description,
+                    source: c.source,
+                }));
+                const combined = [...all, ...custom];
+                if (!slash.arg) {
+                    // List mode — grouped by source.
+                    const bySource = {};
+                    for (const c of combined)
+                        bySource[c.source] = (bySource[c.source] ?? []).concat(c);
+                    const sections = Object.entries(bySource)
+                        .sort(([a], [b]) => a.localeCompare(b))
+                        .map(([src, cmds]) => `  ${src}:\n${cmds.map((c) => `    ${c.name}  ${c.desc}`).join("\n")}`);
+                    notice(`commands:\n${sections.join("\n\n")}`);
+                    return;
+                }
+                // Inspect mode — /commands <name>
+                const name = slash.arg.trim().toLowerCase();
+                const customCmd = custom.find((c) => c.name === "/commands " + name || c.name === "/commands " + name.slice(1));
+                if (customCmd) {
+                    // Full info for custom command
+                    const cmd = discoverCustomCommands(host.config.workdir).find((c) => "/commands " + c.name === customCmd.name);
+                    if (!cmd)
+                        return;
+                    notice(`command: ${cmd.name}\n` +
+                        `description: ${cmd.description}\n` +
+                        `exec: ${cmd.exec ?? "prompt"}\n` +
+                        `source: ${cmd.source} — ${cmd.filePath}\n` +
+                        (cmd.args ? `args: ${cmd.args.join(", ")}\n` : "") +
+                        `\n${cmd.body.slice(0, 400)}\n` +
+                        (cmd.body.length > 400 ? "\n… (truncated)" : ""));
+                    return;
+                }
+                const builtin = BUILTIN_COMMANDS.find((c) => c.name === "/" + name || c.name === "/commands " + name);
+                if (builtin) {
+                    notice(`${builtin.name}: ${builtin.description}\nusage: ${builtin.usage}`);
+                    return;
+                }
+                notice(`command "/${name}" not found`, "warn");
+            },
+        },
+        {
+            name: "/export",
+            description: "export session transcript: /export [md|json] — writes to workdir/scoder-export.{md|json}",
+            run(slash, host, notice) {
+                const items = host.transcriptItems ? host.transcriptItems() : [];
+                if (items.length === 0) {
+                    notice("no transcript to export", "warn");
+                    return;
+                }
+                const fmt = slash.arg.trim().toLowerCase() || "md";
+                if (fmt !== "md" && fmt !== "json") {
+                    notice("usage: /export [md|json]", "warn");
+                    return;
+                }
+                const content = exportTranscript(items, fmt);
+                const fileName = `scoder-export.${fmt}`;
+                const filePath = join(host.config.workdir, fileName);
+                try {
+                    writeFileSync(filePath, "\ufeff" + content, "utf8");
+                    notice(`exported ${items.length} items → ${filePath}`);
+                }
+                catch (e) {
+                    notice(`export failed: ${e.message}`, "error");
+                }
+            },
+        },
+        {
+            name: "/search",
+            description: "search transcript: /search <query> — shows snippets; TUI jumps to result",
+            run(slash, host, notice) {
+                if (!slash.arg.trim()) {
+                    notice("usage: /search <query>", "warn");
+                    return;
+                }
+                const items = host.transcriptItems ? host.transcriptItems() : [];
+                if (items.length === 0) {
+                    notice("no transcript to search", "warn");
+                    return;
+                }
+                const matches = findInTranscript(items, slash.arg);
+                if (matches.length === 0) {
+                    notice(`no results for "${slash.arg.trim()}"`, "warn");
+                    return;
+                }
+                notice(`${matches.length} match${matches.length > 1 ? "es" : ""} in transcript:\n` +
+                    matches.slice(0, 20).map((m) => `  [${m.index}] ${m.kind}: ${m.snippet}`).join("\n"));
+                // TUI: jump to first result
+                if (host.selectTranscriptItem && matches.length > 0) {
+                    host.selectTranscriptItem(matches[0].index);
+                }
+            },
+        },
     ];
 }
+/** Merged catalog of builtin command metadata — /help & completion read this. */
+export function commandCatalog() {
+    return BUILTIN_COMMANDS.map((def) => ({ ...def }));
+}
 /** Clone config với permissionMode mới (host.config thay thế được). */
 function withPermissionMode(cfg, mode) {
     return { ...cfg, permissionMode: mode };
@@ -172,11 +431,14 @@ function withPermissionMode(cfg, mode) {
  * /diff; REPL: không có) TRƯỚC khi gọi hàm này.
  */
 export async function dispatchCommand(input, host, notice, extra = []) {
-    const m = /^\/([a-zA-Z][a-zA-Z0-9]*)(?:\s+(.*\S))?\s*$/.exec(input.trim());
+    const m = /^\/([a-zA-Z][a-zA-Z0-9-]*)(?:\s+([\s\S]*\S))?\s*$/.exec(input.trim());
     if (!m)
         return { handled: false, outcome: null };
-    const cmd = "/" + m[1].toLowerCase();
+    const raw = "/" + m[1].toLowerCase();
     const arg = m[2] ?? "";
+    // Resolve aliases → canonical command (e.g. /quit → /exit).
+    const resolved = resolveCommandDef(raw);
+    const cmd = resolved?.name ?? raw;
     const slash = { cmd, arg };
     if (cmd === "/exit" || cmd === "/quit")
         return { handled: true, outcome: { quit: true } };
@@ -185,6 +447,19 @@ export async function dispatchCommand(input, host, notice, extra = []) {
         host.replaceAgent(null);
         return { handled: true, outcome: { notice: "conversation cleared — context reset" } };
     }
+    const custom = discoverCustomCommands(host.config.workdir);
+    const customMatch = custom.find((c) => `/${c.name.toLowerCase()}` === cmd || c.aliases.some((a) => `/${a.toLowerCase().replace(/^\//, "")}` === cmd));
+    if (customMatch) {
+        if (customMatch.exec === "shell") {
+            notice(`custom command "${customMatch.name}" declares shell execution; run it explicitly through a reviewed agent task`, "warn");
+        }
+        else {
+            const prompt = runCustomCommand(customMatch, arg);
+            notice(`custom command "${customMatch.name}"`, "info");
+            return { handled: true, outcome: { task: prompt } };
+        }
+        return { handled: true, outcome: {} };
+    }
     const entry = [...extra, ...coreCommands()].find((c) => c.name === cmd);
     if (!entry) {
         notice(`unknown command ${cmd} — try /help`, "error");

package/dist/tui/commands.js

@@ -3,29 +3,45 @@
  * (src/tui/app.tsx). Pure parsing/formatting only — each frontend executes
  * the command against its own context, so both stay in sync on the surface.
  */
-export const SLASH_COMMANDS = [
-    { cmd: "/help", desc: "show this command list" },
-    { cmd: "/sessions", desc: "list saved sessions — /sessions resume <id|last>" },
-    { cmd: "/diff", desc: "show diffs: /diff turn | session | branch" },
-    { cmd: "/theme", desc: "switch palette: /theme <name> — /theme list (mission|paper|mono|light|high-contrast|solarized)" },
-    { cmd: "/clear", desc: "clear the conversation and reset agent context" },
-    { cmd: "/compact", desc: "summarize older history now (manual compaction)" },
-    { cmd: "/cost", desc: "token usage of the current session" },
-    { cmd: "/model", desc: "show the active model & provider" },
-    { cmd: "/skills", desc: "list discovered skills (SKILL.md)" },
-    { cmd: "/skill", desc: "load a skill into context: /skill <name>" },
-    { cmd: "/mcp", desc: "MCP servers & tools: /mcp [server] [tool] [json|text]" },
-    { cmd: "/review", desc: "prompt gate: rewrite + user approval — /review <prompt>" },
-    { cmd: "/permission", desc: "view or switch permission mode: /permission <auto|ask|readonly>" },
-    { cmd: "/undo", desc: "revert files: /undo [files|edit] — edit also trims the turn back for re-send" },
-    { cmd: "/exit", desc: "quit (aliases: /quit, exit, quit)" },
+/** Built-in commands — the single catalog both help and completion read. */
+export const BUILTIN_COMMANDS = [
+    { name: "/help", aliases: [], description: "show this command list", usage: "/help", visibility: "public", source: "builtin" },
+    { name: "/plan", aliases: [], description: "show the current plan — /plan done|start <id|n> to mark steps", usage: "/plan [done|start <id|n|text>]", visibility: "public", source: "builtin" },
+    { name: "/agent", aliases: [], description: "list selectable agents — /agent <name> to switch (idle only)", usage: "/agent [name]", visibility: "public", source: "builtin" },
+    { name: "/init", aliases: [], description: "create an AGENTS.md template in this project", usage: "/init", visibility: "public", source: "builtin" },
+    { name: "/sessions", aliases: [], description: "list saved sessions — /sessions resume <id|last>", usage: "/sessions [resume <id|last>]", visibility: "public", source: "builtin" },
+    { name: "/diff", aliases: [], description: "show diffs: /diff turn | session | branch", usage: "/diff [turn|session|branch]", visibility: "tui-only", source: "builtin" },
+    { name: "/theme", aliases: [], description: "switch palette: /theme <name> — /theme list (mission|paper|mono|light|high-contrast|solarized)", usage: "/theme [name|list]", visibility: "tui-only", source: "builtin" },
+    { name: "/clear", aliases: [], description: "clear the conversation and reset agent context", usage: "/clear", visibility: "public", source: "builtin" },
+    { name: "/compact", aliases: [], description: "summarize older history now (manual compaction)", usage: "/compact", visibility: "public", source: "builtin" },
+    { name: "/cost", aliases: [], description: "token usage of the current session", usage: "/cost", visibility: "public", source: "builtin" },
+    { name: "/model", aliases: [], description: "show the active model & provider", usage: "/model [provider/model]", visibility: "public", source: "builtin" },
+    { name: "/skills", aliases: [], description: "list discovered skills (SKILL.md)", usage: "/skills", visibility: "public", source: "builtin" },
+    { name: "/skill", aliases: [], description: "load a skill into context: /skill <name>", usage: "/skill <name>", visibility: "public", source: "builtin" },
+    { name: "/mcp", aliases: [], description: "MCP servers & tools: /mcp [server] [tool] [json|text]", usage: "/mcp [server [tool [json]]]", visibility: "public", source: "builtin" },
+    { name: "/review", aliases: [], description: "prompt gate: rewrite + user approval — /review <prompt>", usage: "/review <prompt>", visibility: "tui-only", source: "builtin" },
+    { name: "/permission", aliases: [], description: "view or switch permission mode: /permission <auto|ask|readonly>", usage: "/permission [auto|ask|readonly]", visibility: "public", source: "builtin" },
+    { name: "/undo", aliases: [], description: "revert files: /undo [files|edit] — edit also trims the turn back for re-send", usage: "/undo [files|edit]", visibility: "tui-only", source: "builtin" },
+    { name: "/commands", aliases: [], description: "list all commands (builtin + custom) — /commands <name> to inspect", usage: "/commands [name]", visibility: "public", source: "builtin" },
+    { name: "/export", aliases: [], description: "export session transcript: /export [md|json]", usage: "/export [md|json]", visibility: "public", source: "builtin" },
+    { name: "/search", aliases: [], description: "search transcript: /search <query>", usage: "/search <query>", visibility: "public", source: "builtin" },
+    { name: "/exit", aliases: ["/quit"], description: "quit (aliases: /quit, exit, quit)", usage: "/exit", visibility: "public", source: "builtin" },
 ];
+/** Back-compat view used by completion + /help — derived from BUILTIN_COMMANDS. */
+export const SLASH_COMMANDS = BUILTIN_COMMANDS
+    .filter((c) => c.visibility !== "hidden")
+    .map((c) => ({ cmd: c.name, desc: c.description }));
+/** Resolve a command name or alias → canonical CommandDef (case-insensitive). */
+export function resolveCommandDef(name) {
+    const n = name.toLowerCase();
+    return BUILTIN_COMMANDS.find((c) => c.name === n || c.aliases.includes(n));
+}
 /** Parse "/cmd arg…"; returns null when the input is not a slash command. */
 export function parseSlashCommand(input) {
-    const m = /^\/([a-zA-Z][a-zA-Z0-9]*)(?:\s+(.*\S))?\s*$/.exec(input.trim());
+    const m = /^\/([a-zA-Z][a-zA-Z0-9-]*)(?:\s+([\s\S]*\S))?\s*$/.exec(input.trim());
     if (!m)
         return null;
-    return { cmd: "/" + m[1].toLowerCase(), arg: m[2] ?? "" };
+    return { cmd: resolveCommandDef("/" + m[1].toLowerCase())?.name ?? "/" + m[1].toLowerCase(), arg: m[2] ?? "" };
 }
 /**
  * Tab completion for a partial input starting with "/".
@@ -53,44 +69,215 @@ export function completeSlashCommand(input) {
     }
     return { completed: prefix + (matches.length === 1 ? " " : ""), candidates: matches };
 }
+import { readdirSync, existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve, basename, extname } from "node:path";
 import { suggest } from "./at-complete.js";
+/** Substitute $ARGUMENTS, $1..$n, @file references in the body. */
+function substituteTemplate(body, argStr) {
+    const args = argStr.trim().split(/\s+/).filter(Boolean);
+    let out = body;
+    out = out.replace(/\$ARGUMENTS/g, argStr.trim());
+    for (let i = 0; i < args.length; i++) {
+        out = out.replace(new RegExp(`\\$${i + 1}`, "g"), args[i]);
+    }
+    out = out.replace(/\$ARGUMENTS/g, argStr.trim()); // repeat in case $ARGUMENTS contains $1
+    // @file references — leave as-is (agent interprets them).
+    return out;
+}
+/** Discover custom commands from ~/.scoder/commands/*.md + .scoder/commands/*.md. */
+export function discoverCustomCommands(workdir) {
+    const dirs = [resolve(workdir, ".scoder", "commands"), join(homedir(), ".scoder", "commands")].filter((d) => existsSync(d));
+    const results = [];
+    for (const dir of dirs) {
+        let files;
+        try {
+            files = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            if (extname(file) !== ".md")
+                continue;
+            const filePath = join(dir, file);
+            let stat;
+            try {
+                stat = statSync(filePath);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            const content = readFileSync(filePath, "utf8");
+            const parsed = parseCustomCommandFile(basename(file, ".md"), filePath, content, dir === resolve(workdir, ".scoder", "commands") ? "project" : "global");
+            if (parsed)
+                results.push(parsed);
+        }
+    }
+    return results;
+}
+/** Parse a custom command .md file. Returns null on error. */
+function parseCustomCommandFile(defaultName, filePath, content, source) {
+    const frontMatch = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(content.trim());
+    if (!frontMatch) {
+        // No frontmatter: body is the entire file, name is filename.
+        return {
+            name: defaultName,
+            description: content.trim().slice(0, 80),
+            visibility: "public",
+            aliases: [],
+            body: content.trim(),
+            source,
+            filePath,
+        };
+    }
+    const frontRaw = frontMatch[1];
+    const body = frontMatch[2].trim();
+    // Parse YAML frontmatter manually (no external dependency).
+    const front = {};
+    for (const line of frontRaw.split("\n")) {
+        const m = /^(\w+):\s*(.*)$/.exec(line.trim());
+        if (m) {
+            const [, key, rawVal] = m;
+            front[key] = rawVal.startsWith('"') && rawVal.endsWith('"')
+                ? rawVal.slice(1, -1)
+                : rawVal;
+        }
+    }
+    return {
+        name: String(front.name ?? defaultName),
+        description: String(front.description ?? body.split("\n")[0].slice(0, 80)),
+        visibility: front.visibility ?? "public",
+        aliases: parseFrontList(front.aliases),
+        exec: front.exec ?? "prompt",
+        agent: front.agent ? String(front.agent) : undefined,
+        model: front.model ? String(front.model) : undefined,
+        shell: front.shell ? String(front.shell) : undefined,
+        args: front.args
+            ? (Array.isArray(front.args)
+                ? front.args.map(String)
+                : String(front.args)
+                    // YAML flow array "[a, b]" → strip brackets, split on comma.
+                    .replace(/^\[|\]$/g, "")
+                    .split(",")
+                    .map((s) => s.trim())
+                    .filter(Boolean))
+            : undefined,
+        body,
+        source,
+        filePath,
+    };
+}
+/** Parse the small YAML list subset used by command aliases/args metadata. */
+function parseFrontList(value) {
+    if (Array.isArray(value))
+        return value.map(String).map((s) => s.trim()).filter(Boolean);
+    if (typeof value !== "string")
+        return [];
+    const raw = value.trim().replace(/^\[|\]$/g, "");
+    return raw.split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+}
+/** Substitute + execute a custom command; returns the prompt text to inject. */
+export function runCustomCommand(cmd, argStr) {
+    return substituteTemplate(cmd.body, argStr);
+}
 /** Build providers from runtime context (called once per keystroke burst). */
 export function completionProviders(sources) {
-    return [
+    const limit = sources.limit ?? 8;
+    const skills = sources.skills ?? [];
+    const agents = sources.agents ?? [];
+    const files = sources.files ?? [];
+    const commands = sources.commands ?? SLASH_COMMANDS;
+    const out = [
         {
             id: "commands",
             match: (t) => t.startsWith("/") && !t.slice(1).includes(" "),
-            candidates: (t) => SLASH_COMMANDS.filter((c) => c.cmd.startsWith(t.toLowerCase()))
-                .map((c) => ({ label: c.cmd, desc: c.desc, insert: c.cmd + " " })),
+            candidates: (t) => {
+                const q = t.toLowerCase();
+                return commands
+                    .filter((c) => c.cmd.toLowerCase().startsWith(q) || c.cmd.toLowerCase().includes(q.slice(1)))
+                    .slice(0, limit)
+                    .map((c) => ({ label: c.cmd, desc: c.desc, insert: c.cmd + " " }));
+            },
         },
-        {
+    ];
+    if (files.length > 0) {
+        out.push({
             id: "files",
             match: (t) => t.startsWith("@") && t.length > 1,
-            candidates: (t) => suggest(sources.files, t.slice(1)).map((f) => ({ label: f, insert: "@" + f + (f.endsWith("/") ? "" : " ") })),
-        },
-        {
+            candidates: (t) => suggest(files, t.slice(1), limit).map((f) => ({ label: f, insert: "@" + f + (f.endsWith("/") ? "" : " ") })),
+        });
+    }
+    if (skills.length > 0) {
+        out.push({
             id: "skills",
             match: (t) => t.startsWith("@") && t.length > 1,
             candidates: (t) => {
                 const q = t.slice(1).toLowerCase();
-                return sources.skills
-                    .filter((s) => s.toLowerCase().includes(q))
-                    .slice(0, 4)
-                    .map((s) => ({ label: `@${s}`, desc: "skill", insert: `@${s} ` }));
+                return skills.filter((s) => s.toLowerCase().includes(q)).slice(0, limit).map((s) => ({ label: `@${s}`, desc: "skill", insert: `@${s} ` }));
             },
-        },
-        {
+        });
+    }
+    if (agents.length > 0) {
+        out.push({
             id: "agents",
             match: (t) => t.startsWith("@") && t.length > 1,
             candidates: (t) => {
                 const q = t.slice(1).toLowerCase();
-                return sources.agents
-                    .filter((a) => a.toLowerCase().includes(q))
-                    .slice(0, 4)
-                    .map((a) => ({ label: `@${a}`, desc: "agent", insert: `@${a} ` }));
+                return agents.filter((a) => a.toLowerCase().includes(q)).slice(0, limit).map((a) => ({ label: `@${a}`, desc: "agent", insert: `@${a} ` }));
             },
-        },
-    ];
+        });
+    }
+    if (sources.mcpServers && sources.mcpServers.length > 0) {
+        out.push({
+            id: "mcp",
+            match: (t) => t.startsWith("@") && t.length > 1,
+            candidates: (t) => {
+                const q = t.slice(1).toLowerCase();
+                const res = [];
+                for (const s of sources.mcpServers ?? []) {
+                    if (s.name.toLowerCase().includes(q))
+                        res.push({ label: `@${s.name}`, desc: "mcp server", insert: `@${s.name} ` });
+                    for (const tool of s.tools ?? []) {
+                        if (tool.toLowerCase().includes(q))
+                            res.push({ label: `@${tool}`, desc: `mcp:${s.name}`, insert: `@${tool} ` });
+                    }
+                }
+                return res.slice(0, limit);
+            },
+        });
+    }
+    if (sources.sessions && sources.sessions.length > 0) {
+        out.push({
+            id: "sessions",
+            match: (t) => t.startsWith("@") && t.length > 1,
+            candidates: (t) => {
+                const q = t.slice(1).toLowerCase();
+                return (sources.sessions ?? []).filter((s) => s.toLowerCase().includes(q)).slice(0, limit).map((s) => ({ label: `@${s}`, desc: "session", insert: `@${s} ` }));
+            },
+        });
+    }
+    return out;
+}
+/** Fuzzy score helper (Completion v2 ranking). Higher = better. */
+export function fuzzyScore(query, target) {
+    const q = query.toLowerCase();
+    const t = target.toLowerCase();
+    if (!q)
+        return 0;
+    if (t.startsWith(q))
+        return 1000 - (t.length - q.length);
+    const idx = t.indexOf(q);
+    if (idx >= 0)
+        return 500 - idx;
+    // subsequence
+    let qi = 0;
+    for (let i = 0; i < t.length && qi < q.length; i++)
+        if (t[i] === q[qi])
+            qi++;
+    return qi === q.length ? 100 : 0;
 }
 /**
  * Ghost text: when the current input has exactly ONE candidate across all