chainlesschain 0.162.37 → 0.162.39

package/src/lib/ide-context.js

@@ -0,0 +1,271 @@
+/**
+ * IDE live prompt context (Claude-Code parity) — when an IDE bridge is
+ * connected (lib/ide-bridge.js → mcp-config.js `loadIdeMcp`, server `ide`),
+ * automatically share the editor's state at the moment a prompt is submitted:
+ * the active file, the open editor tabs, and the current selection. The agent
+ * no longer has to *choose* to call mcp__ide__getSelection — the context rides
+ * along with every user turn, exactly like Claude Code's at-submit selection
+ * sharing.
+ *
+ * The context is EPHEMERAL by design: entry points append it to the in-flight
+ * user content only, after session persistence, so a resumed session replays
+ * the user's words, not a stale editor snapshot.
+ *
+ * Everything here is best-effort and bounded: a missing/slow IDE server can
+ * never block or fail a turn (short timeout, all errors → null), and the
+ * injected block is capped. `CC_IDE_CONTEXT=0` disables the feature without
+ * disconnecting the IDE tools themselves.
+ */
+
+/** Hard cap on the selected text we inline into the prompt. */
+const SELECTION_TEXT_CAP = 2000;
+/** At most this many open-editor entries are listed. */
+const OPEN_EDITORS_CAP = 10;
+/** Per-tool-call budget; the IDE answers from memory, so this is generous. */
+const DEFAULT_TIMEOUT_MS = 1500;
+
+/** Env kill-switch: CC_IDE_CONTEXT=0|false|off disables injection. */
+export function ideContextEnabled(env = process.env) {
+  const v = String(env?.CC_IDE_CONTEXT ?? "").toLowerCase();
+  return !(v === "0" || v === "false" || v === "off");
+}
+
+/**
+ * Does this resolved MCP bundle expose the IDE bridge's selection tool?
+ * (`resolveAgentMcp` connects the bridge as server `ide`, so its tools land in
+ * `externalToolExecutors` as mcp__ide__*.)
+ */
+export function hasIdeContextTools(mcp) {
+  return !!(
+    mcp?.mcpClient?.callTool &&
+    mcp.externalToolExecutors?.mcp__ide__getSelection?.kind === "mcp"
+  );
+}
+
+/**
+ * Read an MCP tools/call result's first text block as JSON. The IDE bridge
+ * servers always wrap handler data as
+ * `{content:[{type:"text",text:JSON.stringify(data)}]}`. Returns null for
+ * isError results, non-text content, or unparsable text.
+ */
+export function parseToolResultJson(result) {
+  if (!result || result.isError) return null;
+  const block = Array.isArray(result.content)
+    ? result.content.find((b) => b && b.type === "text")
+    : null;
+  if (!block || typeof block.text !== "string") return null;
+  try {
+    return JSON.parse(block.text);
+  } catch {
+    return null;
+  }
+}
+
+/** Resolve to the promise's value, or null after `ms` / on rejection. */
+function withTimeout(promise, ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(null), ms);
+    promise.then(
+      (v) => {
+        clearTimeout(timer);
+        resolve(v);
+      },
+      () => {
+        clearTimeout(timer);
+        resolve(null);
+      },
+    );
+  });
+}
+
+/**
+ * Query the connected IDE for its live state. Returns
+ * `{ selection, openEditors }` (either field may be null) or null when the
+ * feature is disabled, no IDE tools are connected, or nothing useful came
+ * back. Never throws.
+ *
+ * @param {object} mcp   resolved bundle from resolveAgentMcp
+ * @param {object} opts  { env?, timeoutMs? }
+ */
+export async function collectIdeContext(mcp, opts = {}) {
+  if (!ideContextEnabled(opts.env || process.env)) return null;
+  if (!hasIdeContextTools(mcp)) return null;
+  const timeoutMs = opts.timeoutMs || DEFAULT_TIMEOUT_MS;
+  const executors = mcp.externalToolExecutors;
+  const call = (name) => {
+    const exec = executors[name];
+    if (!exec || exec.kind !== "mcp") return Promise.resolve(null);
+    let p;
+    try {
+      p = mcp.mcpClient.callTool(exec.serverName, exec.toolName, {});
+    } catch {
+      return Promise.resolve(null);
+    }
+    return withTimeout(p.then(parseToolResultJson), timeoutMs);
+  };
+  const [selection, editors] = await Promise.all([
+    call("mcp__ide__getSelection"),
+    call("mcp__ide__getOpenEditors"),
+  ]);
+  const openEditors = Array.isArray(editors?.editors) ? editors.editors : null;
+  if (!selection && !(openEditors && openEditors.length > 0)) return null;
+  return { selection: selection || null, openEditors };
+}
+
+/**
+ * Render collected IDE state as a compact tagged block for the user turn.
+ * Returns null when there is nothing worth saying.
+ */
+export function formatIdeContext(ctx) {
+  if (!ctx) return null;
+  const lines = [];
+  const editors = Array.isArray(ctx.openEditors) ? ctx.openEditors : [];
+  const active = editors.find((e) => e && e.active);
+  if (active?.file) lines.push(`Active file: ${active.file}`);
+  if (editors.length > 0) {
+    const names = editors
+      .filter((e) => e && e.file)
+      .slice(0, OPEN_EDITORS_CAP)
+      .map((e) => (e.active ? `${e.file} (active)` : e.file));
+    const more = editors.length - names.length;
+    lines.push(
+      `Open editors: ${names.join(", ")}${more > 0 ? ` (+${more} more)` : ""}`,
+    );
+  }
+  const sel = ctx.selection;
+  if (sel && typeof sel.text === "string" && sel.text.length > 0) {
+    const start = sel.selection?.start?.line;
+    const end = sel.selection?.end?.line;
+    const range =
+      Number.isInteger(start) && Number.isInteger(end)
+        ? `:${start + 1}-${end + 1}` // editor lines are 0-based
+        : "";
+    const text =
+      sel.text.length > SELECTION_TEXT_CAP
+        ? sel.text.slice(0, SELECTION_TEXT_CAP) + "\n...(selection truncated)"
+        : sel.text;
+    lines.push(`Selected text in ${sel.file || "the active editor"}${range}:`);
+    lines.push(text);
+  } else if (sel?.file && !active) {
+    lines.push(`Active file: ${sel.file}`);
+  }
+  if (lines.length === 0) return null;
+  return (
+    "<ide-context>\n" +
+    "Live editor state, shared automatically at prompt time (an IDE is " +
+    "connected). This reflects what the user is looking at NOW:\n" +
+    lines.join("\n") +
+    "\n</ide-context>"
+  );
+}
+
+/**
+ * Append extra text to user-turn content, preserving multimodal arrays
+ * (OpenAI-style content parts from --image runs).
+ */
+export function appendTextToContent(content, extra) {
+  if (!extra) return content;
+  if (typeof content === "string") {
+    return content.length > 0 ? `${content}\n\n${extra}` : extra;
+  }
+  if (Array.isArray(content)) {
+    return [...content, { type: "text", text: extra }];
+  }
+  return content;
+}
+
+/**
+ * One-call convenience for entry points: collect + format. Returns the tagged
+ * block string or null. Never throws.
+ */
+export async function buildIdePromptContext(mcp, opts = {}) {
+  try {
+    const ctx = await collectIdeContext(mcp, opts);
+    return ctx ? formatIdeContext(ctx) : null;
+  } catch {
+    return null;
+  }
+}
+
+// ─── Post-edit diagnostics feedback (Claude-Code parity) ────────────────────
+//
+// After the agent mutates a file, the connected IDE's language servers see the
+// change and update their diagnostics. Pulling them right back into the tool
+// result lets the model fix what it just broke in the SAME loop instead of
+// discovering it turns later. The IDE needs a beat to re-lint, hence the
+// settle delay (CC_IDE_DIAG_SETTLE_MS overrides; 0 skips the wait).
+
+/** Give language servers this long to notice the disk change before asking. */
+const DIAG_SETTLE_MS = 600;
+/** At most this many diagnostics are surfaced per edit. */
+const DIAG_CAP = 10;
+/** Only these severities are worth interrupting the model for. */
+const DIAG_SEVERITIES = new Set(["error", "warning"]);
+
+/** Does this MCP surface expose the IDE bridge's diagnostics tool? */
+export function hasIdeDiagnosticsTool(mcp) {
+  return !!(
+    mcp?.mcpClient?.callTool &&
+    mcp.externalToolExecutors?.mcp__ide__getDiagnostics?.kind === "mcp"
+  );
+}
+
+/**
+ * Pull the IDE's current error/warning diagnostics for one file. `mcp` accepts
+ * either a resolveAgentMcp bundle or agent-core's tool context (both carry
+ * `mcpClient` + `externalToolExecutors`). Returns a non-empty array or null.
+ * Never throws.
+ *
+ * @param {object} mcp       { mcpClient, externalToolExecutors }
+ * @param {string} filePath  absolute path of the just-edited file
+ * @param {object} opts      { env?, settleMs?, timeoutMs? }
+ */
+export async function collectIdeDiagnostics(mcp, filePath, opts = {}) {
+  const env = opts.env || process.env;
+  if (!ideContextEnabled(env)) return null;
+  if (!filePath || !hasIdeDiagnosticsTool(mcp)) return null;
+  const settle =
+    opts.settleMs ??
+    (Number.isFinite(Number(env.CC_IDE_DIAG_SETTLE_MS))
+      ? Number(env.CC_IDE_DIAG_SETTLE_MS)
+      : DIAG_SETTLE_MS);
+  if (settle > 0) await new Promise((r) => setTimeout(r, settle));
+  const exec = mcp.externalToolExecutors.mcp__ide__getDiagnostics;
+  let p;
+  try {
+    p = mcp.mcpClient.callTool(exec.serverName, exec.toolName, {
+      path: filePath,
+    });
+  } catch {
+    return null;
+  }
+  const data = await withTimeout(
+    p.then(parseToolResultJson),
+    opts.timeoutMs || DEFAULT_TIMEOUT_MS,
+  );
+  const all = Array.isArray(data?.diagnostics) ? data.diagnostics : null;
+  if (!all) return null;
+  const relevant = all.filter(
+    (d) => d && DIAG_SEVERITIES.has(String(d.severity).toLowerCase()),
+  );
+  return relevant.length > 0 ? relevant : null;
+}
+
+/**
+ * Render pulled diagnostics as a compact feedback string for the tool result.
+ * Returns null when there is nothing to report.
+ */
+export function formatIdeDiagnostics(diags, { cap = DIAG_CAP } = {}) {
+  if (!Array.isArray(diags) || diags.length === 0) return null;
+  const shown = diags.slice(0, cap).map((d) => {
+    const loc = Number.isInteger(d.line) ? `:${d.line + 1}` : "";
+    const src = d.source ? ` (${d.source})` : "";
+    return `  [${d.severity}] ${d.file || ""}${loc} ${d.message || ""}${src}`.trimEnd();
+  });
+  const more = diags.length - shown.length;
+  return (
+    `IDE diagnostics after this edit (${diags.length} problem${diags.length === 1 ? "" : "s"}):\n` +
+    shown.join("\n") +
+    (more > 0 ? `\n  (+${more} more)` : "")
+  );
+}

package/src/lib/repl-completer.js

@@ -0,0 +1,139 @@
+/**
+ * REPL `@` file-reference tab-completion (Claude-Code @-mention parity).
+ *
+ * Typing `@src/fo<TAB>` in the agent REPL completes file/dir paths the same
+ * way the @-token will later be expanded by file-ref-expander. Two candidate
+ * sources, merged:
+ *   1. the filesystem under cwd (dirs get a trailing `/` so TAB can descend)
+ *   2. the connected IDE's OPEN EDITOR TABS (when the IDE bridge is up) —
+ *      the files you are working on rank first, before any fs listing.
+ *
+ * IDE tabs come from an injected async `getIdeOpenFiles()`; the completer
+ * caches the last list (TTL) and refreshes in the background, so completion
+ * stays synchronous-fast and a slow/dead IDE costs nothing (first TAB simply
+ * has no IDE entries yet).
+ */
+import fs from "fs";
+import path from "path";
+
+/** Refresh the IDE open-editors list at most this often. */
+const IDE_CACHE_TTL_MS = 5000;
+/** Hard cap on candidates shown per TAB. */
+const MAX_CANDIDATES = 30;
+
+/**
+ * Find a trailing `@token` being typed at the end of the line. Returns
+ * `{ prefix }` (token without `@`, may be "") or null when the cursor is not
+ * on an @-token. An @ must start the line or follow whitespace, mirroring
+ * file-ref-expander's token rules.
+ */
+export function extractAtPrefix(line) {
+  const m = /(^|\s)@([^\s@]*)$/.exec(line || "");
+  return m ? { prefix: m[2] } : null;
+}
+
+/** Normalize to forward slashes (what @refs use on every platform). */
+function fwd(p) {
+  return String(p).replace(/\\/g, "/");
+}
+
+/**
+ * Filesystem candidates for an @-prefix, relative to cwd. Directories get a
+ * trailing `/`. Missing dirs / unreadable entries → empty (best-effort).
+ */
+export function fileCandidates(prefix, { cwd = process.cwd(), deps } = {}) {
+  const readdir = deps?.readdir || ((d) => fs.readdirSync(d));
+  const isDir =
+    deps?.isDir ||
+    ((p) => {
+      try {
+        return fs.statSync(p).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  const norm = fwd(prefix);
+  const slash = norm.lastIndexOf("/");
+  const dirPart = slash >= 0 ? norm.slice(0, slash + 1) : "";
+  const basePart = slash >= 0 ? norm.slice(slash + 1) : norm;
+  const absDir = path.resolve(cwd, dirPart || ".");
+  let names;
+  try {
+    names = readdir(absDir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (basePart && !name.toLowerCase().startsWith(basePart.toLowerCase())) {
+      continue;
+    }
+    if (name === "node_modules" || name === ".git") continue;
+    const rel = dirPart + name;
+    out.push(isDir(path.join(absDir, name)) ? `${rel}/` : rel);
+    if (out.length >= MAX_CANDIDATES) break;
+  }
+  return out;
+}
+
+/**
+ * Build a readline completer. Returns `completer(line)` → `[hits, replaced]`
+ * per the readline contract; non-@ lines complete to nothing.
+ *
+ * @param {object} opts { cwd?, getIdeOpenFiles?: () => Promise<string[]>, deps? }
+ */
+export function makeAtCompleter(opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const getIde = opts.getIdeOpenFiles || null;
+  const now = opts.deps?.now || Date.now;
+  let ideFiles = [];
+  let ideFetchedAt = -Infinity; // "never" — the first @ must always fetch
+  let ideInFlight = false;
+
+  const refreshIde = () => {
+    if (!getIde || ideInFlight || now() - ideFetchedAt < IDE_CACHE_TTL_MS) {
+      return;
+    }
+    ideInFlight = true;
+    Promise.resolve()
+      .then(() => getIde())
+      .then((files) => {
+        ideFiles = Array.isArray(files)
+          ? files
+              .filter((f) => typeof f === "string" && f.length > 0)
+              .map((f) => {
+                const rel = path.relative(cwd, f);
+                // Keep workspace files relative (the natural @ref form);
+                // out-of-workspace files keep their absolute path.
+                return rel && !rel.startsWith("..") ? fwd(rel) : fwd(f);
+              })
+          : [];
+        ideFetchedAt = now();
+      })
+      .catch(() => {
+        ideFetchedAt = now(); // don't hammer a dead IDE
+      })
+      .finally(() => {
+        ideInFlight = false;
+      });
+  };
+
+  const completer = (line) => {
+    const at = extractAtPrefix(line);
+    if (!at) return [[], line];
+    refreshIde(); // async top-up for the NEXT tab; this one uses the cache
+    const norm = fwd(at.prefix).toLowerCase();
+    const fromIde = ideFiles.filter((f) => f.toLowerCase().startsWith(norm));
+    const fromFs = fileCandidates(at.prefix, { cwd, deps: opts.deps });
+    const merged = [...new Set([...fromIde, ...fromFs])].slice(
+      0,
+      MAX_CANDIDATES,
+    );
+    // readline replaces `replaced` with the chosen hit — keep the `@`.
+    return [merged.map((m) => `@${m}`), `@${at.prefix}`];
+  };
+  // test seam: expose the cache refresher state
+  completer._refreshIde = refreshIde;
+  completer._ideState = () => ({ ideFiles, ideFetchedAt });
+  return completer;
+}

package/src/lib/settings-hooks.cjs

@@ -37,6 +37,7 @@ const HOOK_EVENTS = Object.freeze([
   "PostToolUse",
   "UserPromptSubmit",
   "Stop",
+  "SubagentStop",
   "SessionStart",
   "SessionEnd",
   "PreCompact",

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(),
@@ -731,11 +732,35 @@ export async function startAgentRepl(options = {}) {
     return chalk.green("> ");
   };
 
+  // `@` tab-completion (Claude-Code @-mention parity): filesystem paths +
+  // (when the IDE bridge is connected) the editor's open tabs ranked first.
+  const { makeAtCompleter } = await import("../lib/repl-completer.js");
+  const atCompleter = makeAtCompleter({
+    cwd: process.cwd(),
+    getIdeOpenFiles: async () => {
+      const exec = _adhocMcp?.externalToolExecutors?.mcp__ide__getOpenEditors;
+      if (!exec || exec.kind !== "mcp" || !_adhocMcp?.mcpClient?.callTool) {
+        return [];
+      }
+      const { parseToolResultJson } = await import("../lib/ide-context.js");
+      const res = await _adhocMcp.mcpClient.callTool(
+        exec.serverName,
+        exec.toolName,
+        {},
+      );
+      const data = parseToolResultJson(res);
+      return Array.isArray(data?.editors)
+        ? data.editors.map((e) => e?.file).filter(Boolean)
+        : [];
+    },
+  });
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
     prompt: getPrompt(),
     terminal: true,
+    completer: atCompleter,
   });
 
   logger.log(chalk.bold("\nChainlessChain Agent"));
@@ -805,7 +830,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();
@@ -1024,15 +1050,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) {
@@ -1046,9 +1073,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())) {
@@ -1801,15 +1827,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})`),
@@ -1864,9 +1922,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(),
@@ -1889,6 +1946,18 @@ export async function startAgentRepl(options = {}) {
       }
     }
 
+    // IDE live context (Claude-Code parity): re-shared on every prompt while
+    // an IDE bridge is connected — the user's selection moves between turns.
+    // Ephemeral: persistence stores effectivePrompt, not this snapshot.
+    // Best-effort; CC_IDE_CONTEXT=0 disables.
+    try {
+      const { buildIdePromptContext } = await import("../lib/ide-context.js");
+      const ideCtx = await buildIdePromptContext(_adhocMcp);
+      if (ideCtx) userContent += `\n\n${ideCtx}`;
+    } catch (_err) {
+      // optional polish — never fail the turn over it
+    }
+
     // Add user message
     messages.push({ role: "user", content: userContent });
 
@@ -2136,9 +2205,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",