chainlesschain 0.162.33 → 0.162.34

package/src/commands/command.js

@@ -0,0 +1,187 @@
+/**
+ * cc command — user-defined slash-command macros (Claude-Code parity).
+ *
+ *   cc command list [--json]                     list discovered commands
+ *   cc command show <name>                       show metadata + template body
+ *   cc command run <name> [args...] [opts]       expand the template and run it
+ *                                                headlessly (or --print-prompt)
+ *   cc command new <name> [--description <d>]    scaffold a command file
+ *
+ * Commands live in `.claude/commands/` (project, recursive) or
+ * `~/.claude/commands/` (personal). A file `git/commit.md` → command
+ * `git:commit`. Template body
+ * supports $ARGUMENTS / $1..$9, !`bash` bang execution, and @path file refs.
+ * Distinct from skills (AI-invoked); these are macros you run explicitly.
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+
+export function registerCommandCommand(program) {
+  const cmd = program
+    .command("command")
+    .alias("cmd")
+    .description("User-defined slash-command macros (.claude/commands/*.md)");
+
+  // ── list ──────────────────────────────────────────────────────────────
+  cmd
+    .command("list")
+    .alias("ls")
+    .description("List discovered command macros (project + personal)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { discoverCommands } = await import("../lib/slash-commands.js");
+        const all = discoverCommands(process.cwd());
+        if (options.json) {
+          console.log(JSON.stringify(all, null, 2));
+          return;
+        }
+        if (all.length === 0) {
+          logger.log(
+            chalk.gray(
+              "No command macros. Create one: cc command new <name>  " +
+                "(or add .claude/commands/<name>.md)",
+            ),
+          );
+          return;
+        }
+        for (const c of all) {
+          const tag =
+            c.scope === "project" ? chalk.cyan("[proj]") : chalk.gray("[pers]");
+          logger.log(
+            `${chalk.bold("/" + c.name.padEnd(22))} ${tag} ${chalk.gray(c.description || "")}` +
+              (c.argumentHint ? chalk.dim(`  ${c.argumentHint}`) : ""),
+          );
+        }
+      } catch (err) {
+        logger.error(chalk.red(`command list failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── show ──────────────────────────────────────────────────────────────
+  cmd
+    .command("show <name>")
+    .description("Show a command's metadata and template body")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      try {
+        const { getCommand } = await import("../lib/slash-commands.js");
+        const c = getCommand(name, process.cwd());
+        if (!c) {
+          logger.error(chalk.red(`no such command: ${name}`));
+          process.exitCode = 1;
+          return;
+        }
+        if (options.json) {
+          console.log(JSON.stringify(c, null, 2));
+          return;
+        }
+        logger.log(
+          chalk.bold(`/${c.name}`) + `  ${chalk.gray(`[${c.scope}]`)}`,
+        );
+        if (c.description) logger.log(chalk.gray(`  ${c.description}`));
+        if (c.argumentHint) logger.log(chalk.gray(`  args: ${c.argumentHint}`));
+        if (c.model) logger.log(chalk.gray(`  model: ${c.model}`));
+        if (c.allowedTools)
+          logger.log(chalk.gray(`  allowed-tools: ${c.allowedTools}`));
+        logger.log(chalk.gray(`  file: ${c.file}`));
+        logger.log(chalk.dim("  ───"));
+        logger.log(c.body);
+      } catch (err) {
+        logger.error(chalk.red(`command show failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── run ───────────────────────────────────────────────────────────────
+  cmd
+    .command("run <name> [args...]")
+    .description("Expand a command template and run it headlessly")
+    .option("--print-prompt", "Print the expanded prompt without running it")
+    .option("--no-bang", "Do not execute !`cmd` bang segments")
+    .option("--output-format <fmt>", "text | json | stream-json", "text")
+    .option("--model <model>", "Override the model")
+    .option("--permission-mode <mode>", "ApprovalGate tier (see cc agent)")
+    .action(async (name, args, options) => {
+      try {
+        const { getCommand, expandCommand } =
+          await import("../lib/slash-commands.js");
+        const c = getCommand(name, process.cwd());
+        if (!c) {
+          logger.error(chalk.red(`no such command: ${name}`));
+          process.exitCode = 1;
+          return;
+        }
+        const { prompt, warnings } = expandCommand(c, args, {
+          cwd: process.cwd(),
+          allowBang: options.bang !== false, // commander maps --no-bang → bang:false
+        });
+        for (const w of warnings) process.stderr.write(`  @ref: ${w}\n`);
+
+        if (options.printPrompt) {
+          console.log(prompt);
+          return;
+        }
+
+        const { runAgentHeadless, parseToolList } =
+          await import("../runtime/headless-runner.js");
+        const outcome = await runAgentHeadless({
+          prompt,
+          outputFormat: options.outputFormat,
+          model: options.model || c.model || undefined,
+          permissionMode: options.permissionMode,
+          // A command's frontmatter allowed-tools scopes the run.
+          allowedTools: parseToolList(c.allowedTools),
+        });
+        process.exit(outcome.exitCode);
+      } catch (err) {
+        logger.error(chalk.red(`command run failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── new (scaffold) ────────────────────────────────────────────────────
+  cmd
+    .command("new <name>")
+    .description("Scaffold a new command file under .claude/commands/")
+    .option("--description <d>", "Frontmatter description")
+    .option("--personal", "Create under ~/.claude/commands instead of project")
+    .action(async (name, options) => {
+      try {
+        const fs = await import("node:fs");
+        const path = await import("node:path");
+        const { homedir } = await import("node:os");
+        const safe = String(name).replace(/^\//, "").replace(/:/g, "/");
+        const root = options.personal
+          ? path.join(homedir(), ".claude", "commands")
+          : path.join(process.cwd(), ".claude", "commands");
+        const file = path.join(root, `${safe}.md`);
+        if (fs.existsSync(file)) {
+          logger.error(chalk.red(`already exists: ${file}`));
+          process.exitCode = 1;
+          return;
+        }
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        const tpl = `---
+description: ${options.description || name}
+argument-hint: "[args]"
+---
+
+Describe the task here. Use $ARGUMENTS for all args, $1/$2 for positional,
+@path to inline file contents, and !\`git status\` to splice in command output.
+`;
+        fs.writeFileSync(file, tpl, "utf-8");
+        logger.log(chalk.green(`✓ created ${file}`));
+        logger.log(
+          chalk.gray(
+            `  run it with: cc command run ${safe.replace(/\//g, ":")} <args>`,
+          ),
+        );
+      } catch (err) {
+        logger.error(chalk.red(`command new failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+}

package/src/commands/context.js

@@ -0,0 +1,189 @@
+/**
+ * cc context [sessionId] — context-window token breakdown for a session.
+ *
+ * Shows how a session's stored conversation fills the model context window,
+ * grouped by role (system / user / assistant / tool), with the share each takes
+ * and the headroom remaining. Reuses the SAME token estimator + window table as
+ * the headless auto-compactor (prompt-compressor.js) and the JSONL session store
+ * (rebuildMessages) — no new data is collected, this is purely a reporting view.
+ *
+ * Complements `cc cost` ($ spend) and `cc session usage` (raw token counts):
+ * this is the "how full is the window right now" view (Claude-Code `/context`).
+ *
+ *   cc context                       # most-recent headless session
+ *   cc context <sessionId>
+ *   cc context --model claude-sonnet-4-6   # size against a specific window
+ *   cc context --json
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+
+/**
+ * Bucket message tokens by role. tool_calls carried on assistant messages are
+ * counted separately so the breakdown reflects what actually fills the window.
+ */
+export function categorizeContext(messages, estimateTokens) {
+  const buckets = { system: 0, user: 0, assistant: 0, tool: 0, toolCalls: 0 };
+  const counts = { system: 0, user: 0, assistant: 0, tool: 0 };
+  for (const m of messages) {
+    if (!m) continue;
+    const role =
+      m.role === "system" || m.role === "user" || m.role === "tool"
+        ? m.role
+        : "assistant";
+    const content =
+      typeof m.content === "string"
+        ? m.content
+        : JSON.stringify(m.content || "");
+    buckets[role] += estimateTokens(content);
+    counts[role] += 1;
+    if (Array.isArray(m.tool_calls) && m.tool_calls.length) {
+      buckets.toolCalls += estimateTokens(JSON.stringify(m.tool_calls));
+    }
+  }
+  const total =
+    buckets.system +
+    buckets.user +
+    buckets.assistant +
+    buckets.tool +
+    buckets.toolCalls;
+  return { buckets, counts, total };
+}
+
+function bar(frac, width = 24) {
+  const f = Math.max(0, Math.min(1, frac || 0));
+  const filled = Math.round(f * width);
+  return "█".repeat(filled) + "░".repeat(width - filled);
+}
+
+export function registerContextCommand(program) {
+  program
+    .command("context")
+    .description(
+      "Context-window token breakdown for a session (Claude-Code /context parity)",
+    )
+    .argument("[id]", "Session ID (omit for the most-recent headless session)")
+    .option("--model <model>", "Size against this model's context window")
+    .option("--provider <provider>", "Provider (for the window default)")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+      const {
+        rebuildMessages,
+        getLastSessionId,
+        sessionExists,
+        readEvents,
+      } = await import("../harness/jsonl-session-store.js");
+      const { estimateTokens, getContextWindow } = await import(
+        "../harness/prompt-compressor.js"
+      );
+
+      const sessionId = id || getLastSessionId();
+      if (!sessionId) {
+        logger.error(
+          'No session found. Run a headless agent with `--session <id>` first, or pass a session id.',
+        );
+        process.exitCode = 1;
+        return;
+      }
+      if (!sessionExists(sessionId)) {
+        logger.error(
+          `No headless transcript for session "${sessionId}" (headless sessions are JSONL-only).`,
+        );
+        process.exitCode = 1;
+        return;
+      }
+
+      const messages = rebuildMessages(sessionId) || [];
+
+      // Auto-detect the session's model/provider from its session_start header,
+      // overridable by flags so you can size the same transcript against a
+      // different window.
+      let recordedModel = "";
+      let recordedProvider = "";
+      try {
+        const start = (readEvents(sessionId) || []).find(
+          (e) => e.type === "session_start",
+        );
+        recordedModel = start?.data?.model || "";
+        recordedProvider = start?.data?.provider || "";
+      } catch {
+        // header optional — fall through to flags/defaults
+      }
+      const model = options.model || recordedModel || null;
+      const provider = options.provider || recordedProvider || "ollama";
+      const window = getContextWindow(model, provider);
+
+      const { buckets, counts, total } = categorizeContext(
+        messages,
+        estimateTokens,
+      );
+      const used = window > 0 ? total / window : 0;
+      const remaining = Math.max(0, window - total);
+
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              sessionId,
+              model: model || null,
+              provider,
+              contextWindow: window,
+              totalTokens: total,
+              usedFraction: Number(used.toFixed(4)),
+              remainingTokens: remaining,
+              messageCount: messages.length,
+              breakdown: buckets,
+              counts,
+              overflows: total > window,
+            },
+            null,
+            2,
+          ),
+        );
+        return;
+      }
+
+      logger.log(chalk.bold(`Context — session ${chalk.gray(sessionId.slice(0, 28))}`));
+      logger.log(
+        chalk.gray(
+          `  model ${model || "(default)"} · provider ${provider} · ` +
+            `window ${window.toLocaleString()} tokens · ${messages.length} messages`,
+        ),
+      );
+      logger.log("");
+
+      const rows = [
+        ["system", buckets.system, counts.system],
+        ["user", buckets.user, counts.user],
+        ["assistant", buckets.assistant, counts.assistant],
+        ["tool results", buckets.tool, counts.tool],
+        ["tool calls", buckets.toolCalls, null],
+      ];
+      for (const [label, tok, cnt] of rows) {
+        if (!tok) continue;
+        const frac = total ? tok / total : 0;
+        logger.log(
+          `  ${label.padEnd(13)} ${String(tok).padStart(7)}  ` +
+            `${chalk.cyan(bar(frac))} ${String(Math.round(frac * 100)).padStart(3)}%` +
+            `${cnt != null ? chalk.gray(`  (${cnt})`) : ""}`,
+        );
+      }
+
+      logger.log("");
+      const pct = (used * 100).toFixed(1);
+      const color = used > 0.9 ? chalk.red : used > 0.7 ? chalk.yellow : chalk.green;
+      logger.log(
+        `  ${chalk.bold("total".padEnd(11))} ${String(total).padStart(7)}  ` +
+          `${color(bar(used))} ${color(`${pct}% of window`)}`,
+      );
+      logger.log(
+        chalk.gray(`  headroom      ${String(remaining).padStart(7)} tokens remaining`),
+      );
+      if (total > window) {
+        logger.log(
+          chalk.red("  ⚠ exceeds the model context window — compaction required"),
+        );
+      }
+    });
+}

package/src/index.js

@@ -57,8 +57,10 @@ import { registerPermMemCommand } from "./commands/permmem.js";
 import { registerRCacheCommand } from "./commands/rcache.js";
 import { registerSessionCommand } from "./commands/session.js";
 import { registerCostCommand } from "./commands/cost.js";
+import { registerContextCommand } from "./commands/context.js";
 import { registerCheckpointCommand } from "./commands/checkpoint.js";
 import { registerGoalCommand } from "./commands/goal.js";
+import { registerCommandCommand } from "./commands/command.js";
 import { registerCompactCommand } from "./commands/compact.js";
 import { registerConsolCommand } from "./commands/consol.js";
 import { registerImportCommand } from "./commands/import.js";
@@ -453,8 +455,10 @@ export function createProgram(opts = {}) {
   registerRCacheCommand(program);
   registerSessionCommand(program);
   registerCostCommand(program);
+  registerContextCommand(program);
   registerCheckpointCommand(program);
   registerGoalCommand(program);
+  registerCommandCommand(program);
   registerCompactCommand(program);
   registerConsolCommand(program);
 

package/src/lib/slash-commands.js

@@ -0,0 +1,197 @@
+/**
+ * slash-commands — user-defined command templates (Claude-Code parity).
+ *
+ * Markdown files under `.claude/commands/` (project) or `~/.claude/commands/`
+ * (personal) become reusable command macros. Distinct from skills (skills are
+ * AI-invoked capability bundles; these are user-authored prompt macros you run
+ * explicitly). A file `git/commit.md` is the command `git:commit`.
+ *
+ * Frontmatter (all optional): `description`, `argument-hint`, `allowed-tools`,
+ * `model`. Body is the prompt template, with substitutions applied at run time:
+ *   $ARGUMENTS   → all args joined by space
+ *   $1 $2 … $9   → positional args (missing → empty string)
+ *   !`<cmd>`     → run <cmd> in a shell, splice in its stdout (bang exec)
+ *   @path        → splice in file/dir contents (via file-ref-expander)
+ *
+ * Project scope shadows personal scope on a name clash. Discovery + parse +
+ * expand are pure (inject fs/exec/cwd) so the whole thing is unit-testable.
+ */
+
+import fsDefault from "node:fs";
+import pathDefault from "node:path";
+import { homedir } from "node:os";
+import { execSync as execSyncDefault } from "node:child_process";
+import yaml from "js-yaml";
+import { expandFileRefs } from "../runtime/file-ref-expander.js";
+
+const _deps = { fs: fsDefault, path: pathDefault, execSync: execSyncDefault };
+
+/**
+ * Split `--- ... ---` YAML frontmatter from the body and camelCase the keys
+ * (so `argument-hint` → `argumentHint`). Self-contained (no skill-loader, whose
+ * import chain drags in heavy native deps). Returns `{ data, body }`.
+ */
+function parseFrontmatter(content) {
+  const text = String(content || "");
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!m) return { data: {}, body: text.trim() };
+  let raw = {};
+  try {
+    raw = yaml.load(m[1]) || {};
+  } catch {
+    raw = {};
+  }
+  const data = {};
+  for (const [k, v] of Object.entries(raw)) {
+    const camel = k.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    data[camel] = v;
+  }
+  return { data, body: (m[2] || "").trim() };
+}
+
+/** Default shell timeout for `!`cmd`` bang execution. */
+export const BANG_TIMEOUT_MS = 10_000;
+
+/**
+ * The directories scanned for command files, project first (it shadows personal
+ * on a name clash). `opts.home` overrides the personal root for tests.
+ */
+export function commandDirs(cwd = process.cwd(), opts = {}) {
+  const path = opts.deps?.path || _deps.path;
+  const home = opts.home || homedir();
+  return [
+    { dir: path.join(cwd, ".claude", "commands"), scope: "project" },
+    { dir: path.join(home, ".claude", "commands"), scope: "personal" },
+  ];
+}
+
+/** Recursively collect `*.md` files under `dir` as `{file, rel}` (rel uses /). */
+function walkMd(dir, { fs, path }, base = dir, acc = []) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return acc;
+  }
+  for (const e of entries) {
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) {
+      walkMd(full, { fs, path }, base, acc);
+    } else if (e.isFile() && e.name.endsWith(".md")) {
+      const rel = path.relative(base, full).replace(/\\/g, "/");
+      acc.push({ file: full, rel });
+    }
+  }
+  return acc;
+}
+
+/** Command name from a relative path: `git/commit.md` → `git:commit`. */
+function nameFromRel(rel) {
+  return rel.replace(/\.md$/, "").replace(/\//g, ":");
+}
+
+/** Parse one command file into its metadata + body (no expansion yet). */
+export function parseCommandFile(file, scope, opts = {}) {
+  const fs = opts.deps?.fs || _deps.fs;
+  let content;
+  try {
+    content = fs.readFileSync(file, "utf-8");
+  } catch {
+    return null;
+  }
+  const { data, body } = parseFrontmatter(content);
+  return {
+    file,
+    scope,
+    description: data.description || "",
+    argumentHint: data.argumentHint || "",
+    allowedTools: data.allowedTools || null,
+    model: data.model || null,
+    body: body || "",
+  };
+}
+
+/**
+ * Discover all commands across both scopes. Project shadows personal by name.
+ * @returns {Array<{name, scope, file, description, argumentHint, allowedTools, model}>}
+ */
+export function discoverCommands(cwd = process.cwd(), opts = {}) {
+  const fs = opts.deps?.fs || _deps.fs;
+  const path = opts.deps?.path || _deps.path;
+  const byName = new Map();
+  // Personal first, then project — so project overwrites on clash.
+  const dirs = commandDirs(cwd, opts).reverse();
+  for (const { dir, scope } of dirs) {
+    for (const { file, rel } of walkMd(dir, { fs, path })) {
+      const meta = parseCommandFile(file, scope, opts);
+      if (!meta) continue;
+      const name = nameFromRel(rel);
+      byName.set(name, { name, ...meta });
+    }
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/** Look up one command by name (accepts `git:commit` or `git/commit`). */
+export function getCommand(name, cwd = process.cwd(), opts = {}) {
+  const wanted = String(name || "")
+    .replace(/^\//, "")
+    .replace(/\//g, ":");
+  return discoverCommands(cwd, opts).find((c) => c.name === wanted) || null;
+}
+
+/** Substitute $ARGUMENTS and $1..$9 in `text`. */
+export function substituteArgs(text, args = []) {
+  const list = Array.isArray(args) ? args : [];
+  let out = text.replace(/\$ARGUMENTS/g, list.join(" "));
+  out = out.replace(/\$([1-9])/g, (_, d) => list[Number(d) - 1] ?? "");
+  return out;
+}
+
+/** Run every `!`cmd`` and replace it with the command's stdout (best-effort). */
+function runBangs(text, { cwd, execSync }) {
+  return text.replace(/!`([^`]+)`/g, (_, cmd) => {
+    try {
+      const out = execSync(cmd, {
+        cwd,
+        encoding: "utf-8",
+        timeout: BANG_TIMEOUT_MS,
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+      return String(out).trim();
+    } catch (err) {
+      return `[command failed: ${cmd} — ${err.message?.split("\n")[0] || err}]`;
+    }
+  });
+}
+
+/**
+ * Expand a command into a final prompt string.
+ *   1. $ARGUMENTS / $1..$9 substitution
+ *   2. !`cmd` bang execution (skipped when opts.allowBang === false)
+ *   3. @path file references (via file-ref-expander)
+ *
+ * @param {object} command  output of getCommand/parseCommandFile (needs .body)
+ * @param {string[]} args
+ * @param {object} [opts] { cwd, allowBang, deps:{ execSync } }
+ * @returns {{ prompt:string, warnings:string[] }}
+ */
+export function expandCommand(command, args = [], opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const execSync = opts.deps?.execSync || _deps.execSync;
+  const warnings = [];
+
+  let text = substituteArgs(command.body || "", args);
+
+  if (opts.allowBang !== false) {
+    text = runBangs(text, { cwd, execSync });
+  }
+
+  // @file expansion appends a <referenced-files> block when anything resolves.
+  const expanded = expandFileRefs(text, { cwd });
+  for (const w of expanded.warnings) warnings.push(w);
+
+  return { prompt: expanded.prompt, warnings };
+}
+
+export { _deps };

package/src/repl/agent-repl.js

@@ -58,6 +58,7 @@ import {
 } from "../lib/session-hooks.js";
 import { HookEvents } from "../lib/hook-manager.js";
 import { IterationBudget } from "../lib/iteration-budget.js";
+import { loadMcpConfig } from "../runtime/mcp-config.js";
 import {
   AGENT_TOOLS,
   buildSystemPrompt,
@@ -354,6 +355,10 @@ export async function startAgentRepl(options = {}) {
   // and applies bundle manifest metadata (model/provider override, agentId).
   let _bundleResolved = null;
   let _bundleMcpClient = null;
+  // --mcp-config (interactive parity with headless): ad-hoc MCP servers loaded
+  // for this session via the shared mcp-config engine. Holds {mcpClient,
+  // extraToolDefinitions, externalToolExecutors, externalToolDescriptors}.
+  let _adhocMcp = null;
   if (options.bundlePath) {
     try {
       const { loadBundle } =
@@ -446,6 +451,28 @@ export async function startAgentRepl(options = {}) {
     }
   }
 
+  // --mcp-config: connect ad-hoc MCP servers for this interactive session and
+  // expose their tools to the LLM (Claude-Code parity with headless). Reuses the
+  // shared engine, so tools surface as mcp__<server>__<tool>. Best-effort: a bad
+  // config is reported but never aborts the REPL.
+  if (options.mcpConfig) {
+    try {
+      _adhocMcp = await loadMcpConfig(options.mcpConfig, {
+        writeErr: (s) => process.stderr.write(s),
+      });
+      const toolCount = _adhocMcp.extraToolDefinitions.length;
+      logger.log(
+        chalk.gray(
+          `MCP: ${_adhocMcp.connected.length} server(s), ${toolCount} tool(s) ` +
+            `(mcp__<server>__<tool>)`,
+        ),
+      );
+    } catch (mcpErr) {
+      logger.log(chalk.yellow(`MCP: --mcp-config failed — ${mcpErr.message}`));
+      _adhocMcp = null;
+    }
+  }
+
   // Apply bundle approval policy to this session (after both gate and sessionId are ready)
   if (_bundleResolved?.approvalPolicy?.default && _approvalGate && sessionId) {
     try {
@@ -1567,7 +1594,12 @@ export async function startAgentRepl(options = {}) {
         checkpointSession: sessionId,
         prepareCall,
         approvalGate: _approvalGate,
-        mcpClient: _bundleMcpClient || undefined,
+        // MCP: --mcp-config (ad-hoc) wins; bundle MCP is the fallback. The 3
+        // tool channels expose --mcp-config servers' tools to the LLM directly.
+        mcpClient: _adhocMcp?.mcpClient || _bundleMcpClient || undefined,
+        extraToolDefinitions: _adhocMcp?.extraToolDefinitions,
+        externalToolExecutors: _adhocMcp?.externalToolExecutors,
+        externalToolDescriptors: _adhocMcp?.externalToolDescriptors,
         chatFn: _fallbackChatFn,
       });
 
@@ -1778,6 +1810,15 @@ export async function startAgentRepl(options = {}) {
       }
     }
 
+    // Disconnect ad-hoc (--mcp-config) MCP servers
+    if (_adhocMcp?.mcpClient) {
+      try {
+        await _adhocMcp.mcpClient.disconnectAll();
+      } catch (_e) {
+        // Non-critical
+      }
+    }
+
     // Shutdown runtime
     try {
       await shutdown();