s-app-scoder-agent 0.9.3 → 0.9.6

package/dist/cli/mcp-command.js

@@ -0,0 +1,185 @@
+export async function runMcpCommand(cfg, cmd, restArgs) {
+    const { McpManager } = await import("../mcp/manager.js");
+    const { readFileSync, writeFileSync, existsSync } = await import("node:fs");
+    const { join, dirname } = await import("node:path");
+    const { mkdirSync } = await import("node:fs");
+    const rcPath = join(cfg.workdir, ".scoderrc.json");
+    // Load existing mcpServers from workdir rc.
+    const existing = {};
+    if (existsSync(rcPath)) {
+        try {
+            Object.assign(existing, JSON.parse(readFileSync(rcPath, "utf8")).mcpServers ?? {});
+        }
+        catch { /* ignore */ }
+    }
+    if (cmd === "list") {
+        const servers = Object.entries(cfg.mcpServers ?? existing);
+        if (servers.length === 0) {
+            console.log("no MCP servers configured — add mcpServers to .scoderrc.json");
+            return;
+        }
+        for (const [name, cfg_srv] of servers) {
+            const trust = cfg_srv.trust ?? "auto";
+            const enabled = cfg_srv.enabled === false ? " (disabled)" : "";
+            const target = cfg_srv.url ?? cfg_srv.command ?? "?";
+            console.log(`${name}: ${target}${trust !== "auto" ? ` [${trust}]` : ""}${enabled}`);
+        }
+        return;
+    }
+    if (cmd === "add") {
+        // scoder mcp add <name> --command "..." [--url "..."] [--trust auto|ask|readonly|deny]
+        const name = restArgs[0];
+        if (!name) {
+            console.error("usage: scoder mcp add <name> --command '...' [--url '...'] [--trust readonly]");
+            return;
+        }
+        const opts = {};
+        for (let i = 1; i < restArgs.length; i++) {
+            if (restArgs[i] === "--command" || restArgs[i] === "-c")
+                opts.command = restArgs[++i];
+            else if (restArgs[i] === "--url" || restArgs[i] === "-u")
+                opts.url = restArgs[++i];
+            else if (restArgs[i] === "--trust" || restArgs[i] === "-t")
+                opts.trust = restArgs[++i];
+            else if (restArgs[i] === "--args" || restArgs[i] === "-a")
+                opts.args = restArgs[++i];
+        }
+        if (!opts.command && !opts.url) {
+            console.error("error: --command or --url required");
+            return;
+        }
+        const newEntry = { ...(opts.command ? { command: opts.command } : {}), ...(opts.url ? { url: opts.url } : {}), ...(opts.args ? { args: opts.args.split(" ") } : {}), ...(opts.trust ? { trust: opts.trust } : {}) };
+        const allServers = { ...existing, [name]: newEntry };
+        const rc = existsSync(rcPath) ? JSON.parse(readFileSync(rcPath, "utf8")) : {};
+        mkdirSync(dirname(rcPath) || ".", { recursive: true });
+        writeFileSync(rcPath, JSON.stringify({ ...rc, mcpServers: allServers }, null, 2) + "\n", "utf8");
+        console.log(`MCP server "${name}" added to ${rcPath}`);
+        return;
+    }
+    if (cmd === "remove") {
+        const name = restArgs[0];
+        if (!name) {
+            console.error("usage: scoder mcp remove <name>");
+            return;
+        }
+        if (!existing[name] && !(cfg.mcpServers ?? {})[name]) {
+            console.error(`MCP server "${name}" not found in config`);
+            return;
+        }
+        const allServers = { ...existing };
+        delete allServers[name];
+        const rc = existsSync(rcPath) ? JSON.parse(readFileSync(rcPath, "utf8")) : {};
+        mkdirSync(dirname(rcPath) || ".", { recursive: true });
+        writeFileSync(rcPath, JSON.stringify({ ...rc, mcpServers: allServers }, null, 2) + "\n", "utf8");
+        console.log(`MCP server "${name}" removed from ${rcPath}`);
+        return;
+    }
+    if (cmd === "test") {
+        const name = restArgs[0];
+        if (!name) {
+            console.error("usage: scoder mcp test <name>");
+            return;
+        }
+        const srvCfg = (cfg.mcpServers ?? {})[name] ?? existing[name];
+        if (!srvCfg) {
+            console.error(`MCP server "${name}" not found`);
+            return;
+        }
+        if (srvCfg.enabled === false) {
+            console.log(`✘ "${name}" is disabled (enabled:false)`);
+            return;
+        }
+        if (srvCfg.trust === "readonly") {
+            console.log(`✘ "${name}" is trust:readonly — not spawning`);
+            return;
+        }
+        console.log(`connecting to "${name}"...`);
+        const m = new McpManager({ [name]: srvCfg });
+        try {
+            await m.connectAll();
+            const states = m.serverStates();
+            const s = states[0];
+            if (s?.state === "ready") {
+                console.log(`✓ "${name}" connected — ${s.toolCount} tools`);
+                console.log(`  serverInfo: ${s.serverInfo.name ?? "?"} v${s.serverInfo.version ?? "?"}`);
+                console.log(`  capabilities: ${Object.keys(s.capabilities).join(", ") || "(none)"}`);
+            }
+            else {
+                console.log(`✘ "${name}" failed to connect (state: ${s?.state})`);
+            }
+        }
+        finally {
+            m.killAll();
+        }
+        return;
+    }
+    if (cmd === "import") {
+        // scoder mcp import [path] [--dry-run] [--force]
+        const { loadConfigFile, discoverConfigs, mergeConfigs } = await import("../mcp/mcp-import.js");
+        const dryRun = restArgs.includes("--dry-run");
+        const force = restArgs.includes("--force");
+        const paths = restArgs.filter((a) => !a.startsWith("--"));
+        let discovered = [];
+        try {
+            discovered = discoverConfigs();
+        }
+        catch { /* ignore */ }
+        if (paths.length === 0 && discovered.length === 0) {
+            console.log("No config files found. Provide a path or ensure one of these exists:");
+            console.log("  ~/.claude/config.json  — Claude Desktop MCP servers");
+            console.log("  opencode.json         — OpenCode MCP config");
+            console.log("  .mcp.json             — standard MCP server list");
+            console.log("\nUsage: scoder mcp import [path] [--dry-run] [--force]");
+            return;
+        }
+        // Auto-discover when no path given
+        const toCheck = paths.length > 0 ? paths : discovered.map((d) => d.source);
+        if (paths.length === 0 && discovered.length > 0) {
+            console.log("Auto-discovered MCP config files:");
+            for (const d of discovered) {
+                console.log(`  ${d.format}: ${d.source} (${d.serverCount} server${d.serverCount === 1 ? "" : "s"})`);
+            }
+            console.log();
+        }
+        const { readFileSync, writeFileSync, existsSync } = await import("node:fs");
+        const { mkdirSync } = await import("node:fs");
+        let totalAdded = 0;
+        let totalSkipped = 0;
+        for (const srcPath of toCheck) {
+            const servers = loadConfigFile(srcPath);
+            if (!servers) {
+                console.log(`  skip: ${srcPath} not found`);
+                continue;
+            }
+            const { added, skipped } = mergeConfigs(existing, servers, { force, dryRun });
+            totalAdded += added.length;
+            totalSkipped += skipped.length;
+            console.log(`${srcPath}:`);
+            for (const s of added) {
+                const target = s.config.url ?? s.config.command ?? "?";
+                console.log(`  + ${s.name}: ${target} (from ${s.originalKey})`);
+            }
+            for (const s of skipped) {
+                console.log(`  ~ ${s.name}: skipped (already exists; use --force to overwrite)`);
+            }
+            if (added.length === 0 && skipped.length === 0) {
+                console.log(`    (no servers found)`);
+            }
+        }
+        if (dryRun) {
+            console.log(`\n[DRY RUN] Would import ${totalAdded} server${totalAdded === 1 ? "" : "s"} (${totalSkipped} skipped).`);
+            return;
+        }
+        if (totalAdded > 0) {
+            const rc = existsSync(rcPath) ? JSON.parse(readFileSync(rcPath, "utf8")) : {};
+            mkdirSync(dirname(rcPath) || ".", { recursive: true });
+            writeFileSync(rcPath, JSON.stringify({ ...rc, mcpServers: existing }, null, 2) + "\n", "utf8");
+            console.log(`\nImported ${totalAdded} server${totalAdded === 1 ? "" : "s"} into ${rcPath} (${totalSkipped} skipped).`);
+        }
+        else {
+            console.log(`\nNothing to import.`);
+        }
+        return;
+    }
+    console.error(`unknown mcp command: ${cmd}`);
+}

package/dist/cli/repl.js

@@ -0,0 +1,77 @@
+/** Classic interactive REPL (`scoder` with no task). */
+import process from "node:process";
+import { createInterface } from "node:readline";
+import { Agent } from "../agent.js";
+import { dispatchCommand } from "../commands/registry.js";
+import * as ui from "../io/terminal.js";
+export async function repl(cfg) {
+    ui.header(`scoder interactive — model: ${cfg.model}`);
+    ui.info('Type a task and press Enter. "exit" or Ctrl+D to quit.');
+    const rl = createInterface({ input: process.stdin, output: process.stdout, prompt: "you> " });
+    // One shared session for the whole REPL conversation (plan P0.5 §4):
+    // every input is a follow-up turn, context carries over, saved continuously.
+    // /clear swaps in a fresh Agent (the /clear branch reassigns this).
+    let agent = new Agent(cfg);
+    process.on("SIGINT", () => {
+        ui.warn("\nSIGINT — aborting current task...");
+        agent.abort();
+    });
+    let first = true;
+    for (;;) {
+        const line = await new Promise((res) => rl.question("you> ", res));
+        const input = line.trim();
+        if (!input)
+            continue;
+        if (input === "exit" || input === "quit")
+            break;
+        // Slash commands — registry dùng chung với TUI (T1). Command riêng của
+        // TUI (/theme) do TUI tự xử lý trước.
+        const host = {
+            agent: () => agent,
+            config: cfg,
+            updateConfig: (patch) => {
+                Object.assign(cfg, patch); // mutate the shared cfg so new Agents see it
+            },
+            replaceAgent: (next) => {
+                agent.abort();
+                agent.dispose();
+                agent = next ?? new Agent(cfg);
+                first = true;
+            },
+        };
+        const { handled, outcome } = await dispatchCommand(input, host, (text, level) => {
+            if (level === "error")
+                ui.error(text);
+            else
+                console.log(text);
+        });
+        if (handled) {
+            if (outcome?.notice)
+                ui.info(outcome.notice);
+            if (!outcome?.task)
+                continue;
+            try {
+                const result = first ? await agent.run(outcome.task) : await agent.runTurn(outcome.task);
+                first = false;
+                if (!result.success)
+                    ui.warn("task did not complete — try refining it");
+            }
+            catch (err) {
+                ui.error(err.message);
+            }
+            continue;
+        }
+        try {
+            const result = first ? await agent.run(input) : await agent.runTurn(input);
+            first = false;
+            if (!result.success)
+                ui.warn("task did not complete — try refining it");
+        }
+        catch (err) {
+            ui.error(err.message);
+        }
+    }
+    agent.dispose();
+    ui.info("bye");
+    process.exit(0);
+}

package/dist/cli/run-once.js

@@ -0,0 +1,26 @@
+/** One-shot `scoder "<task>"` mode: run to completion, exit with the result code. */
+import process from "node:process";
+import { Agent } from "../agent.js";
+import { pruneSessions } from "../session/session.js";
+import * as ui from "../io/terminal.js";
+export async function runOnce(cfg, task) {
+    const agent = new Agent(cfg);
+    process.on("SIGINT", () => {
+        ui.warn("\nSIGINT received — finishing current tool, then stopping...");
+        agent.abort();
+    });
+    try {
+        const result = await agent.run(task);
+        const pruned = pruneSessions(cfg.workdir, 7);
+        if (pruned > 0)
+            ui.info(`pruned ${pruned} old session(s)`);
+        return result.success ? 0 : 1;
+    }
+    catch (err) {
+        ui.error(err.message);
+        return 2;
+    }
+    finally {
+        agent.dispose();
+    }
+}

package/dist/{tui/commands.js → commands/definitions.js}

@@ -5,27 +5,17 @@
  */
 /** 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: "/help", aliases: [], description: "show this command list (builtin + custom)", usage: "/help", 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: "/skill", aliases: [], description: "list skills, or load one 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
@@ -59,7 +49,7 @@ export function completeSlashCommand(input) {
     // Exact match — complete to it (e.g. typing "/help" + Tab still completes).
     if (matches.length === 1)
         return { completed: matches[0].cmd + " ", candidates: matches };
-    // Common prefix of all matches (e.g. "/sk" → "/skill" prefix of /skills+/skill).
+    // Common prefix of all matches (e.g. "/m" → "/m" prefix of /model+/mcp).
     let prefix = matches[0].cmd;
     for (const m of matches.slice(1)) {
         let i = 0;
@@ -72,7 +62,7 @@ export function completeSlashCommand(input) {
 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";
+import { suggest } from "../workspace/file-index.js";
 /** Substitute $ARGUMENTS, $1..$n, @file references in the body. */
 function substituteTemplate(body, argStr) {
     const args = argStr.trim().split(/\s+/).filter(Boolean);
@@ -309,8 +299,8 @@ export function ghostText(value, providers) {
     return { rest, insert };
 }
 /** Format the /help listing (shared so both frontends render identically). */
-export function formatSlashHelp(commandName) {
-    const rows = SLASH_COMMANDS.map((c) => `  ${c.cmd.padEnd(12)} ${c.desc}`).join("\n");
+export function formatSlashHelp(commandName, custom = []) {
+    const rows = [...SLASH_COMMANDS, ...custom].map((c) => `  ${c.cmd.padEnd(12)} ${c.desc}`).join("\n");
     return `Commands (${commandName}):\n${rows}\n  Anything else is sent to the agent as a task.\n  Tab completes commands; ↑/↓ recalls history.`;
 }
 /**

package/dist/commands/registry.js

@@ -0,0 +1,260 @@
+import { discoverSkills, matchSkillPrefix } from "../context/skills.js";
+import { selectableAgents } from "../context/agents.js";
+import { agentsMdTemplate } from "../context/agents-guide.js";
+import { existsSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { formatSlashHelp, parseMcpExec, BUILTIN_COMMANDS, resolveCommandDef, discoverCustomCommands, runCustomCommand } from "./definitions.js";
+/** Format usage/cost block (dùng chung — REPL console.log, TUI notice). */
+export function formatUsage(u) {
+    return u.calls > 0
+        ? `session usage: ${u.calls} LLM calls · tokens in ${u.inputTokens} / out ${u.outputTokens}` +
+            (u.cachedTokens > 0 ? ` (+${u.cachedTokens} cached)` : "")
+        : "no LLM calls yet in this session";
+}
+/** Format skills listing (dùng chung). */
+export function formatSkills(skills) {
+    if (skills.length === 0) {
+        return "no skills discovered — add .scoder/skills/<name>/SKILL.md (name + description frontmatter)";
+    }
+    return ("Skills:\n" +
+        skills
+            .map((s) => `  ${s.name.padEnd(20)} ${s.description || "(no description)"}  [${s.scope}]`)
+            .join("\n"));
+}
+/** Format MCP status listing (dùng chung). */
+export function formatMcpStatus(status) {
+    if (status.length === 0)
+        return "no MCP servers configured — add mcpServers to .scoderrc.json";
+    return status
+        .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");
+}
+/**
+ * Handlers dùng chung. Command đặc thù frontend (/theme — chỉ TUI) KHÔNG nằm
+ * đây — frontend xử lý trước khi dispatch, rồi mới gọi dispatchCommand() cho
+ * phần còn lại.
+ */
+export function coreCommands() {
+    return [
+        {
+            name: "/help",
+            description: "show this command list (builtin + custom)",
+            run(_slash, host, notice) {
+                const custom = discoverCustomCommands(host.config.workdir).map((c) => ({ cmd: "/" + c.name, desc: c.description }));
+                notice(formatSlashHelp("scoder tui", custom));
+            },
+        },
+        {
+            name: "/cost",
+            description: "token usage of the current session",
+            run(_slash, host, notice) {
+                notice(formatUsage(host.agent()?.getUsage() ?? { calls: 0, inputTokens: 0, outputTokens: 0, cachedTokens: 0 }));
+            },
+        },
+        {
+            name: "/compact",
+            description: "summarize older history now (manual compaction)",
+            async run(_slash, host, notice) {
+                const agent = host.agent();
+                if (!agent)
+                    return notice("agent not ready — start a task first", "warn");
+                if (host.isRunning?.())
+                    return notice("agent is running — wait or Esc first", "warn");
+                const r = await agent.compactHistory();
+                notice(r.message, r.ok ? "info" : "warn");
+            },
+        },
+        {
+            name: "/skill",
+            description: "list skills, or load one into context: /skill <name> [task]",
+            run(slash, host, notice) {
+                if (!slash.arg) {
+                    notice(formatSkills(host.agent()?.getSkills() ?? discoverSkills(host.config.workdir)));
+                    return;
+                }
+                const agent = host.agent();
+                if (!agent)
+                    return notice("agent not ready — start a task first", "warn");
+                // "/skill <name> <task…>": stage rồi CHẠY task luôn — skill áp dụng
+                // ngay cho prompt đó (trước đây task text bị nuốt vào tham số name).
+                const m = matchSkillPrefix(host.config.workdir, slash.arg);
+                const r = agent.stageSkill(m ? m.skill.name : slash.arg);
+                notice(r.message, r.ok ? "info" : "error");
+                if (r.ok && m?.rest)
+                    return { task: m.rest };
+            },
+        },
+        {
+            name: "/mcp",
+            description: "MCP servers & tools: /mcp [server] [tool] [json|text]",
+            async run(slash, host, notice) {
+                const agent = host.agent();
+                if (!agent)
+                    return notice("agent not ready", "warn");
+                const exec = parseMcpExec(slash.arg);
+                if (exec === null) {
+                    notice(formatMcpStatus(await agent.mcpStatus()));
+                    return;
+                }
+                if ("error" in exec)
+                    return notice(exec.error, "warn");
+                notice(`→ ${exec.fullName}`);
+                const r = await agent.callMcpTool(exec.fullName, exec.args);
+                if (r.ok)
+                    notice(r.output.length > 4000 ? r.output.slice(0, 4000) + "\n… (truncated)" : r.output);
+                else
+                    notice(r.output, "error");
+            },
+        },
+        {
+            name: "/model",
+            description: "show the active model & provider — /model <provider/model> to hot-swap",
+            run(slash, host, notice) {
+                if (slash.arg) {
+                    const agent = host.agent();
+                    if (!agent)
+                        return notice("agent not ready", "warn");
+                    const msg = agent.setModel(slash.arg.trim());
+                    notice(msg, msg.startsWith("ERROR") ? "error" : "info");
+                    return;
+                }
+                const cfg = host.config;
+                notice(`model: ${cfg.model} · provider: ${cfg.provider} · build: ${cfg.buildCmd ?? "auto-detect"}`);
+            },
+        },
+        {
+            name: "/permission",
+            description: "view or switch permission mode: /permission <auto|ask|readonly>",
+            run(slash, host, notice) {
+                const mode = slash.arg.toLowerCase();
+                if (!["auto", "ask", "readonly"].includes(mode)) {
+                    notice(`permission mode: ${host.config.permissionMode} — usage: /permission <auto|ask|readonly>`, "warn");
+                    return;
+                }
+                host.agent()?.setPermissionMode(mode);
+                host.updateConfig?.({ permissionMode: mode });
+                host.config = withPermissionMode(host.config, mode);
+                notice(`permission mode → ${mode}`);
+            },
+        },
+        {
+            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; \`scoder resume last\` resumes 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`);
+            },
+        },
+    ];
+}
+/** 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 };
+}
+/**
+ * Dispatch một input qua registry. Trả về {handled:false} khi không phải
+ * slash command. Frontend xử lý command riêng (TUI: /theme; 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]*\S))?\s*$/.exec(input.trim());
+    if (!m)
+        return { handled: false, outcome: null };
+    const raw = "/" + m[1].toLowerCase();
+    const arg = m[2] ?? "";
+    // Resolve aliases → canonical command.
+    const resolved = resolveCommandDef(raw);
+    const cmd = resolved?.name ?? raw;
+    const slash = { cmd, arg };
+    if (cmd === "/clear") {
+        host.agent()?.abort();
+        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");
+        return { handled: true, outcome: {} };
+    }
+    let outcome;
+    try {
+        outcome = await entry.run(slash, host, notice);
+    }
+    catch (err) {
+        notice(err.message, "error");
+        return { handled: true, outcome: {} };
+    }
+    return { handled: true, outcome: outcome ?? {} };
+}

package/dist/{config.js → config/config.js}

@@ -1,7 +1,7 @@
 import { readFileSync, existsSync, mkdirSync, writeFileSync, renameSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve, dirname } from "node:path";
-import { parseCustomProviders, resolveProvider, splitProviderModel } from "./provider-registry.js";
+import { parseCustomProviders, resolveProvider, splitProviderModel } from "../llm/provider-registry.js";
 const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 const DEFAULT_MODEL = "gpt-4o-mini";
 const ANTHROPIC_BASE_URL = "https://api.anthropic.com/v1";

package/dist/{prompt-builder.js → context/prompt-builder.js}

@@ -5,8 +5,17 @@
  */
 import { spawnSync } from "node:child_process";
 import { formatSkillIndex } from "./skills.js";
+// P2: memoize per (workdir, date, platform, node version) — the git probe is a
+// spawned process and the output cannot change for a given key within a run.
+// The date is part of the key, so nothing is cached across a day boundary.
+const envInfoCache = new Map();
 /** One-line environment snapshot for the system prompt (cache-stable per run). */
 export function buildEnvInfo(workdir) {
+    const today = new Date().toISOString().slice(0, 10);
+    const cacheKey = `${workdir}|${process.platform}|${process.version}|${today}`;
+    const hit = envInfoCache.get(cacheKey);
+    if (hit !== undefined)
+        return hit;
     let git = "";
     try {
         const branch = spawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: workdir, encoding: "utf8" });
@@ -16,7 +25,9 @@ export function buildEnvInfo(workdir) {
     catch {
         /* git unavailable */
     }
-    return `Environment: ${process.platform} · node ${process.version}${git} · today ${new Date().toISOString().slice(0, 10)}`;
+    const info = `Environment: ${process.platform} · node ${process.version}${git} · today ${today}`;
+    envInfoCache.set(cacheKey, info);
+    return info;
 }
 /** Skills advertised in system prompt (passive listing only — agent does NOT auto-load). */
 export function buildSkillsBlock(skills) {