chainlesschain 0.162.36 → 0.162.38

package/src/repl/agent-repl.js

@@ -74,6 +74,7 @@ import { expandFileRefs } from "../runtime/file-ref-expander.js";
 import { composeSystemPrompt } from "../runtime/system-prompt.js";
 import { makeFallbackChatFn } from "../runtime/fallback-model.js";
 import { resolveSlashMacro } from "./slash-macro.js";
+import { expandMcpPrompt, renderMcpSurface } from "./mcp-prompt.js";
 
 /**
  * Reference to the runtime DB for hook execution (set during startAgentRepl)
@@ -129,7 +130,8 @@ async function _persistAlwaysAllow(tool, args) {
       scope: "local",
     });
     if (!_permissionRules) _permissionRules = { allow: [], ask: [], deny: [] };
-    if (!_permissionRules.allow.includes(rule)) _permissionRules.allow.push(rule);
+    if (!_permissionRules.allow.includes(rule))
+      _permissionRules.allow.push(rule);
     return { rule, file };
   } catch (err) {
     process.stderr.write(`  always-allow persist failed: ${err.message}\n`);
@@ -504,9 +506,8 @@ export async function startAgentRepl(options = {}) {
   // settings.json SessionStart hooks → inject session context (observe-only).
   if (_settingsHooks) {
     try {
-      const { runSessionStartHooks } = await import(
-        "../lib/settings-hook-events.cjs"
-      );
+      const { runSessionStartHooks } =
+        await import("../lib/settings-hook-events.cjs");
       const ctx = runSessionStartHooks(_settingsHooks, {
         source: "startup",
         cwd: process.cwd(),
@@ -630,6 +631,11 @@ export async function startAgentRepl(options = {}) {
           mcpConfigPath: options.mcpConfig || null,
           db: db?.getDatabase?.() || null,
           includeRegistered: options.useRegisteredMcp !== false,
+          // IDE bridge: auto-connect a running editor's MCP server when inside
+          // an IDE integrated terminal. --ide forces it, --no-ide disables it
+          // (parity with headless; auto-detect already works via process.env).
+          ide: options.ide,
+          cwd: process.cwd(),
         },
         { writeErr: (s) => process.stderr.write(s) },
       );
@@ -800,7 +806,8 @@ export async function startAgentRepl(options = {}) {
     if (_statusLineEnabled && _renderStatus) {
       const line = _renderStatus();
       // Built-in line is dimmed; a custom command may carry its own ANSI.
-      if (line) process.stdout.write((_customStatus ? line : chalk.dim(line)) + "\n");
+      if (line)
+        process.stdout.write((_customStatus ? line : chalk.dim(line)) + "\n");
     }
     rl.setPrompt(getPrompt());
     rl.prompt();
@@ -1019,15 +1026,16 @@ export async function startAgentRepl(options = {}) {
         logger.info("Status line: on");
       } else {
         // bare / "show" → report state + a one-off render
-        const line = _statusLineEnabled && _renderStatus ? _renderStatus() : null;
+        const line =
+          _statusLineEnabled && _renderStatus ? _renderStatus() : null;
         if (line) {
-          logger.info(
-            `Status line: ${_customStatus ? line : chalk.dim(line)}`,
-          );
+          logger.info(`Status line: ${_customStatus ? line : chalk.dim(line)}`);
         } else {
           logger.info(
             `Status line: ${_statusLineEnabled ? "on (no content yet)" : "off"}` +
-              (_statusLineEnabled ? "" : ` — enable with ${chalk.cyan("/statusline on")}`),
+              (_statusLineEnabled
+                ? ""
+                : ` — enable with ${chalk.cyan("/statusline on")}`),
           );
         }
         if (_customStatus) {
@@ -1041,9 +1049,8 @@ export async function startAgentRepl(options = {}) {
     if (trimmed === "/output-style" || trimmed.startsWith("/output-style ")) {
       const arg = trimmed.slice("/output-style".length).trim();
       try {
-        const { discoverOutputStyles, getOutputStyle } = await import(
-          "../lib/output-styles.js"
-        );
+        const { discoverOutputStyles, getOutputStyle } =
+          await import("../lib/output-styles.js");
         if (!arg) {
           logger.log(chalk.bold("Output styles:"));
           for (const s of discoverOutputStyles(process.cwd())) {
@@ -1796,15 +1803,47 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `/mcp` — overview of connected MCP servers' resources + prompts.
+    if (trimmed === "/mcp" || trimmed === "/mcp ") {
+      const mcpClient = _adhocMcp?.mcpClient || _bundleMcpClient;
+      logger.log(renderMcpSurface(mcpClient));
+      prompt();
+      return;
+    }
+
     // User-defined slash-command macros (.claude/commands/*.md), Claude-Code
     // parity. resolveSlashMacro maps a leading /name to a command macro and
     // expands its template; a non-match returns the line unchanged so a literal
     // prompt like "/etc/hosts" still reaches the LLM. Wire is unit-tested.
     let promptText = trimmed;
+
+    // MCP server-provided prompts (Claude-Code parity): `/mcp__<server>__<name>
+    // [json-args]` fetches a rendered prompt template from the connected MCP
+    // server and uses its text as this turn's input. Falls through unchanged
+    // when the line isn't an MCP prompt command.
+    if (promptText.startsWith("/mcp__")) {
+      try {
+        const expanded = await expandMcpPrompt(
+          promptText,
+          _adhocMcp?.mcpClient || _bundleMcpClient,
+        );
+        if (expanded != null) {
+          promptText = expanded;
+          logger.log(chalk.gray(`[mcp] prompt expanded`));
+        }
+      } catch (err) {
+        logger.info(
+          chalk.yellow(`[mcp] prompt expansion failed: ${err.message}`),
+        );
+        prompt();
+        return;
+      }
+    }
     try {
       const macro = await resolveSlashMacro(trimmed, { cwd: process.cwd() });
       if (macro.matched) {
-        for (const w of macro.warnings) logger.info(chalk.yellow(`[@ref] ${w}`));
+        for (const w of macro.warnings)
+          logger.info(chalk.yellow(`[@ref] ${w}`));
         promptText = macro.promptText;
         logger.log(
           chalk.gray(`[/${macro.name}] macro expanded (${macro.scope})`),
@@ -1859,9 +1898,8 @@ export async function startAgentRepl(options = {}) {
     // is observe-only). block → abort the turn; context → inject before the turn.
     if (_settingsHooks) {
       try {
-        const { runUserPromptSubmitHooks } = await import(
-          "../lib/settings-hook-events.cjs"
-        );
+        const { runUserPromptSubmitHooks } =
+          await import("../lib/settings-hook-events.cjs");
         const ups = runUserPromptSubmitHooks(_settingsHooks, {
           prompt: userContent,
           cwd: process.cwd(),
@@ -2131,9 +2169,8 @@ export async function startAgentRepl(options = {}) {
     // settings.json SessionEnd hooks (observe-only) when the REPL exits.
     if (_settingsHooks) {
       try {
-        const { runObserveHooks } = await import(
-          "../lib/settings-hook-events.cjs"
-        );
+        const { runObserveHooks } =
+          await import("../lib/settings-hook-events.cjs");
         runObserveHooks(
           _settingsHooks,
           "SessionEnd",

package/src/repl/mcp-prompt.js

@@ -0,0 +1,122 @@
+/**
+ * MCP prompt + resource surfacing for the agent REPL (Claude-Code parity).
+ *
+ * MCP servers can expose "prompts" — server-defined, parameterized prompt
+ * templates — which Claude Code surfaces as slash commands of the form
+ * `/mcp__<server>__<prompt>`. This module is the pure, unit-testable core:
+ * it parses such a command, fetches the rendered prompt from the connected
+ * MCP client, and flattens it into plain text to use as the user's turn.
+ *
+ * It also renders a `/mcp` overview of every connected server's resources and
+ * prompts. The REPL (agent-repl.js) wires these in; all the logic lives here so
+ * it can be tested without spinning up a readline session.
+ */
+
+/**
+ * Parse a `/mcp__<server>__<prompt> [args]` line. Returns `{ server, name,
+ * args }` or `null` when the line is not an MCP prompt invocation.
+ *
+ * `args` is parsed from a trailing JSON object when present; a non-JSON tail is
+ * passed as `{ input: "<tail>" }` so simple one-arg prompts stay ergonomic.
+ */
+export function parseMcpPromptCommand(line) {
+  const trimmed = (line || "").trim();
+  if (!trimmed.startsWith("/mcp__")) return null;
+
+  const sp = trimmed.search(/\s/);
+  const token = sp === -1 ? trimmed : trimmed.slice(0, sp);
+  const rest = sp === -1 ? "" : trimmed.slice(sp + 1).trim();
+
+  const full = token.slice(1); // drop leading "/"
+  const parts = full.split("__"); // ["mcp", "<server>", "<prompt...>"]
+  if (parts.length < 3 || parts[0] !== "mcp") return null;
+  const server = parts[1];
+  const name = parts.slice(2).join("__");
+  if (!server || !name) return null;
+
+  let args = {};
+  if (rest) {
+    try {
+      const parsed = JSON.parse(rest);
+      args =
+        parsed && typeof parsed === "object" && !Array.isArray(parsed)
+          ? parsed
+          : { input: rest };
+    } catch {
+      args = { input: rest };
+    }
+  }
+  return { server, name, args };
+}
+
+/**
+ * Flatten an MCP `prompts/get` result (`{ messages: [...] }`) into plain text.
+ * Handles text blocks and embedded text resources; ignores binary blocks.
+ */
+export function renderPromptMessages(result) {
+  const messages = Array.isArray(result?.messages) ? result.messages : [];
+  const out = [];
+  for (const msg of messages) {
+    const blocks = Array.isArray(msg?.content) ? msg.content : [msg?.content];
+    for (const b of blocks) {
+      if (!b) continue;
+      if (b.type === "text" && typeof b.text === "string") {
+        out.push(b.text);
+      } else if (
+        b.type === "resource" &&
+        b.resource &&
+        typeof b.resource.text === "string"
+      ) {
+        out.push(b.resource.text);
+      }
+    }
+  }
+  return out.join("\n\n");
+}
+
+/**
+ * Expand a `/mcp__server__prompt` line into prompt text by calling the MCP
+ * client. Returns the rendered text, or `null` when the line is not an MCP
+ * prompt command. Throws if the underlying `getPrompt` fails (caller decides
+ * whether to surface or swallow).
+ */
+export async function expandMcpPrompt(line, mcpClient) {
+  const cmd = parseMcpPromptCommand(line);
+  if (!cmd) return null;
+  if (!mcpClient || typeof mcpClient.getPrompt !== "function") {
+    throw new Error("No MCP servers are connected this session.");
+  }
+  const result = await mcpClient.getPrompt(cmd.server, cmd.name, cmd.args);
+  return renderPromptMessages(result);
+}
+
+/**
+ * Render a human overview of all connected MCP resources + prompts for `/mcp`.
+ */
+export function renderMcpSurface(mcpClient) {
+  if (!mcpClient) return "No MCP servers are connected this session.";
+  const resources =
+    typeof mcpClient.listResources === "function"
+      ? mcpClient.listResources()
+      : [];
+  const prompts =
+    typeof mcpClient.listPrompts === "function" ? mcpClient.listPrompts() : [];
+
+  const lines = [];
+  lines.push(`MCP resources (${resources.length}):`);
+  for (const r of resources) {
+    lines.push(`  ${r.uri} [${r.server}]${r.name ? " — " + r.name : ""}`);
+  }
+  lines.push("");
+  lines.push(`MCP prompts (${prompts.length}):`);
+  for (const p of prompts) {
+    lines.push(
+      `  /mcp__${p.server}__${p.name}${p.description ? " — " + p.description : ""}`,
+    );
+  }
+  if (resources.length === 0 && prompts.length === 0) {
+    lines.push("");
+    lines.push("(connected servers expose no resources or prompts)");
+  }
+  return lines.join("\n");
+}

package/src/runtime/agent-core.js

@@ -222,7 +222,10 @@ async function runSettingsPreToolUseHooks(name, args, context, cwd) {
     cwd,
     session_id: context.sessionId || null,
   };
-  const outcome = runCommandHooks(matched, payload, { cwd, event: "PreToolUse" });
+  const outcome = runCommandHooks(matched, payload, {
+    cwd,
+    event: "PreToolUse",
+  });
   if (outcome.decision === "block") {
     return { blocked: true, reason: outcome.reason, hook: outcome.hook };
   }
@@ -234,8 +237,7 @@ async function runSettingsPreToolUseHooks(name, args, context, cwd) {
             tool: name,
             args,
             rule: `hook:${outcome.hook}`,
-            reason:
-              outcome.reason || "a PreToolUse hook requests confirmation",
+            reason: outcome.reason || "a PreToolUse hook requests confirmation",
           })
         : false;
     return ok
@@ -730,7 +732,11 @@ export async function executeTool(name, args, context = {}) {
     if (!ok) {
       return {
         error: `[Permission] Tool "${name}" requires confirmation (settings rule: ${settingsVerdict.rule}) — denied.`,
-        policy: { decision: "ask", rule: settingsVerdict.rule, via: "settings" },
+        policy: {
+          decision: "ask",
+          rule: settingsVerdict.rule,
+          via: "settings",
+        },
       };
     }
     ruleAllowed = true; // confirmed → treat like allow downstream
@@ -889,6 +895,41 @@ export async function executeTool(name, args, context = {}) {
     }
   }
 
+  // settings.json SubagentStop hooks: fire when a `spawn_sub_agent` tool call
+  // finishes (Claude-Code SubagentStop parity). The subagent has already
+  // returned its summary, so this is observe + feedback rather than force-
+  // continue: a `block` reason is surfaced to the PARENT agent as hookFeedback
+  // so it can react (e.g. re-spawn or adjust), mirroring PostToolUse.
+  if (
+    name === "spawn_sub_agent" &&
+    context.settingsHooks &&
+    toolResult &&
+    typeof toolResult === "object"
+  ) {
+    try {
+      const outcome = runObserveHooks(
+        context.settingsHooks,
+        "SubagentStop",
+        {
+          stop_hook_active: false,
+          session_id: context.sessionId || null,
+          subagent_response:
+            typeof toolResult === "object"
+              ? JSON.stringify(toolResult).substring(0, 2000)
+              : String(toolResult).substring(0, 2000),
+        },
+        { cwd },
+      );
+      if (outcome.decision === "block" && outcome.reason) {
+        toolResult.hookFeedback = toolResult.hookFeedback
+          ? `${toolResult.hookFeedback}\n${outcome.reason}`
+          : outcome.reason;
+      }
+    } catch (_err) {
+      // SubagentStop hooks are best-effort
+    }
+  }
+
   return toolResult;
 }
 
@@ -1240,12 +1281,8 @@ async function executeToolInner(
         ...(task.error ? { error: task.error } : {}),
         stdout: out.text.substring(0, 30000),
         stderr: err.text.substring(0, 30000),
-        ...(out.droppedGap
-          ? { stdout_dropped_bytes: out.droppedGap }
-          : {}),
-        ...(err.droppedGap
-          ? { stderr_dropped_bytes: err.droppedGap }
-          : {}),
+        ...(out.droppedGap ? { stdout_dropped_bytes: out.droppedGap } : {}),
+        ...(err.droppedGap ? { stderr_dropped_bytes: err.droppedGap } : {}),
         ...(killed ? { killed: true } : {}),
         startedAt: task.startedAt,
         endedAt: task.endedAt,
@@ -1635,6 +1672,50 @@ async function executeToolInner(
     }
 
     default:
+      if (localToolExecutor?.kind === "mcp-resource") {
+        if (!mcpClient) {
+          return attachDescriptor({
+            error: `MCP client is unavailable for tool: ${name}`,
+          });
+        }
+        try {
+          if (localToolExecutor.op === "list") {
+            const resources =
+              typeof mcpClient.listResources === "function"
+                ? mcpClient.listResources(args?.server || undefined)
+                : [];
+            return attachDescriptor({ count: resources.length, resources });
+          }
+          // op === "read"
+          const uri = args?.uri;
+          if (!uri || typeof uri !== "string") {
+            return attachDescriptor({
+              error: "read_mcp_resource requires a string 'uri' argument.",
+            });
+          }
+          let server = args?.server;
+          if (!server && typeof mcpClient.listResources === "function") {
+            const match = mcpClient
+              .listResources()
+              .find((r) => r && r.uri === uri);
+            server = match?.server;
+          }
+          if (!server) {
+            return attachDescriptor({
+              error: `Could not resolve which MCP server owns resource "${uri}". Pass 'server' explicitly.`,
+            });
+          }
+          const result = await mcpClient.readResource(server, uri);
+          return attachDescriptor(
+            result && typeof result === "object" ? result : { result },
+          );
+        } catch (err) {
+          return attachDescriptor({
+            error: `MCP resource access failed: ${err.message}`,
+          });
+        }
+      }
+
       if (localToolExecutor?.kind === "mcp") {
         if (!mcpClient || typeof mcpClient.callTool !== "function") {
           return attachDescriptor({
@@ -2601,7 +2682,13 @@ export function _accumulateAnthropicStream(lines, onToken) {
   return _anthropicFinalize(state);
 }
 
-async function _chatAnthropicStreaming(apiUrl, body, extraHeaders, onToken, signal) {
+async function _chatAnthropicStreaming(
+  apiUrl,
+  body,
+  extraHeaders,
+  onToken,
+  signal,
+) {
   const response = await fetch(apiUrl, {
     method: "POST",
     headers: { "Content-Type": "application/json", ...extraHeaders },
@@ -2663,10 +2750,12 @@ function _openaiReduceLine(state, raw, onToken) {
   if (Array.isArray(delta?.tool_calls)) {
     for (const tc of delta.tool_calls) {
       const idx = tc.index ?? 0;
-      if (!state.tools[idx]) state.tools[idx] = { id: undefined, name: "", args: "" };
+      if (!state.tools[idx])
+        state.tools[idx] = { id: undefined, name: "", args: "" };
       if (tc.id) state.tools[idx].id = tc.id;
       if (tc.function?.name) state.tools[idx].name = tc.function.name;
-      if (tc.function?.arguments) state.tools[idx].args += tc.function.arguments;
+      if (tc.function?.arguments)
+        state.tools[idx].args += tc.function.arguments;
     }
   }
   if (obj.usage) {
@@ -2702,7 +2791,14 @@ export function _accumulateOpenAIStream(lines, onToken) {
   return _openaiFinalize(state);
 }
 
-async function _chatOpenAIStreaming(apiUrl, body, apiKey, onToken, signal, provider) {
+async function _chatOpenAIStreaming(
+  apiUrl,
+  body,
+  apiKey,
+  onToken,
+  signal,
+  provider,
+) {
   const response = await fetch(apiUrl, {
     method: "POST",
     headers: {
@@ -2843,7 +2939,11 @@ function _intensityToEffort(want) {
  * RUNTIME-UNVERIFIED — no Anthropic key to validate the wire shape live.
  * Exported for tests.
  */
-export function _anthropicThinkingParams(model, options = {}, maxTokens = 8192) {
+export function _anthropicThinkingParams(
+  model,
+  options = {},
+  maxTokens = 8192,
+) {
   const want = options?.thinking;
   if (!want) return null; // off by default → request unchanged
   const m = String(model || "").toLowerCase();
@@ -3181,7 +3281,11 @@ export async function* agentLoop(messages, options) {
             }
           }
           if (preCompactBlocked) {
-            yield { type: "compaction-skipped", runId, reason: preCompactReason };
+            yield {
+              type: "compaction-skipped",
+              runId,
+              reason: preCompactReason,
+            };
           }
           const { messages: compacted, stats } = preCompactBlocked
             ? { messages, stats: { saved: 0 } }
@@ -3400,7 +3504,9 @@ export function formatToolArgs(name, args) {
     case "edit_file_hashed":
       return `${args.path} @${args.anchor_hash}`;
     case "run_shell":
-      return args.run_in_background ? `${args.command} (background)` : args.command;
+      return args.run_in_background
+        ? `${args.command} (background)`
+        : args.command;
     case "check_shell":
       return args.task_id
         ? `${args.task_id}${args.kill ? " (kill)" : ""}`

package/src/runtime/headless-runner.js

@@ -176,6 +176,34 @@ export function resolveHeadlessSession(options = {}, store = {}, fallbackId) {
   return { sessionId: id, resumeId, persist, wantLatest };
 }
 
+/**
+ * Apply `--fork-session`: when a session has been resolved (resume/continue) and
+ * a fork is requested, branch its JSONL transcript into a NEW id so the original
+ * stays untouched (Claude-Code `--fork-session` parity). The copy carries the
+ * full prior history, so a later `--resume <newId>` replays the whole branch.
+ *
+ * Returns the id to use downstream + the source (`forkedFrom`), or the original
+ * id unchanged with `missing:true` when there is no transcript to fork. Pure
+ * apart from the injected store's side effect; both `sessionExists`/`forkSession`
+ * are injection seams so this is unit-testable without disk.
+ *
+ * @param {{forkSession?:boolean, sessionId?:string|null}} opts
+ * @param {{sessionExists?:Function, forkSession?:Function}} store
+ * @returns {{ sessionId:string|null, forkedFrom:string|null, missing:boolean }}
+ */
+export function applyForkSession(opts = {}, store = {}) {
+  const want = opts.forkSession === true;
+  const id = opts.sessionId || null;
+  if (!want || !id) return { sessionId: id, forkedFrom: null, missing: false };
+  if (typeof store.sessionExists === "function" && !store.sessionExists(id)) {
+    return { sessionId: id, forkedFrom: null, missing: true };
+  }
+  const newId =
+    typeof store.forkSession === "function" ? store.forkSession(id) : null;
+  if (!newId) return { sessionId: id, forkedFrom: null, missing: false };
+  return { sessionId: newId, forkedFrom: id, missing: false };
+}
+
 /**
  * Run a single headless agentic turn.
  *
@@ -404,9 +432,8 @@ export async function runAgentHeadless(options = {}, deps = {}) {
   // settings.json UserPromptSubmit hooks. block → abort the run; context → inject.
   if (settingsHooks) {
     try {
-      const { runUserPromptSubmitHooks } = await import(
-        "../lib/settings-hook-events.cjs"
-      );
+      const { runUserPromptSubmitHooks } =
+        await import("../lib/settings-hook-events.cjs");
       const ups = runUserPromptSubmitHooks(settingsHooks, {
         prompt: userContent,
         cwd,
@@ -434,9 +461,8 @@ export async function runAgentHeadless(options = {}, deps = {}) {
   let sessionStartContext = null;
   if (settingsHooks) {
     try {
-      const { runSessionStartHooks } = await import(
-        "../lib/settings-hook-events.cjs"
-      );
+      const { runSessionStartHooks } =
+        await import("../lib/settings-hook-events.cjs");
       sessionStartContext = runSessionStartHooks(settingsHooks, {
         source: resumeId ? "resume" : "startup",
         cwd,
@@ -766,9 +792,8 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     // settings.json SessionEnd hooks (observe-only) when the run finishes.
     if (settingsHooks) {
       try {
-        const { runObserveHooks } = await import(
-          "../lib/settings-hook-events.cjs"
-        );
+        const { runObserveHooks } =
+          await import("../lib/settings-hook-events.cjs");
         runObserveHooks(
           settingsHooks,
           "SessionEnd",