chainlesschain 0.165.6 → 0.165.9

package/src/runtime/headless-stream.js

@@ -27,6 +27,7 @@ import {
   sameInteractionBinding,
 } from "../lib/interaction-binding.js";
 import {
+  addHooksV2EventObserver,
   emitHooksV2Event,
   executeHooksV2Event,
   resolvePromptExpansion,
@@ -42,6 +43,7 @@ import { composeSystemPrompt } from "./system-prompt.js";
 import { collapseConsecutiveMessagesInPlace } from "./message-roles.js";
 import { sanitizeToolPairs } from "../harness/prompt-compressor.js";
 import { compactConversationWithProvider } from "../harness/provider-backed-compaction.js";
+import { HostResourceBudget } from "../lib/host-resource-budget.js";
 import { projectCanonicalResumeMessages } from "../lib/session-message-provenance.js";
 import { isAbortError } from "../lib/abort-utils.js";
 import { expandFileRefsAsync } from "./file-ref-expander.js";
@@ -65,6 +67,7 @@ import {
   resolveAgentMcp,
   resolvePermissionPromptTool,
   makePermissionPromptConfirmer,
+  readHeadlessMcpConfigErrors,
 } from "./mcp-config.js";
 import { maybeApplyToolSearch } from "./mcp-tool-search.js";
 import {
@@ -398,6 +401,9 @@ export function planSnapshot(pm) {
 const MAX_PLAN_REVIEW_SNAPSHOT_CHARS = 24000;
 const MAX_PLAN_REVIEW_COMMENTS = 64;
 const MAX_PLAN_REVIEW_COMMENT_CHARS = 2000;
+const HOST_EVENT_BACKLOG_CODE = "CC_HOST_EVENT_BACKLOG_EXHAUSTED";
+const HOST_EVENT_BACKLOG_ERROR =
+  "CC_HOST_EVENT_BACKLOG_EXHAUSTED: event backlog limit reached";
 
 function boundedReviewString(value, limit) {
   return String(value == null ? "" : value).slice(0, limit);
@@ -1463,6 +1469,11 @@ async function runAgentHeadlessStreamInWorkspace(
     deps[STREAM_SESSION_ID] ||
     options.sessionId ||
     `headless-stream-${Date.now()}-${process.pid}`;
+  // The input stream may drive many turns. Allocate once at the stream-run
+  // boundary so every turn (and its nested agents) shares cache/backlog limits.
+  // SessionResourceBudget remains separately leased by executeTool.
+  const hostResourceBudget =
+    options.hostResourceBudget || new HostResourceBudget();
   const persist =
     (Boolean(options.sessionId) || options.observabilityScope != null) &&
     options.ephemeral !== true;
@@ -1483,6 +1494,10 @@ async function runAgentHeadlessStreamInWorkspace(
       fieldGate,
     });
   const emit = streamCoalescer.emit;
+  const removeHookObserver =
+    options.includeHookEvents === true
+      ? addHooksV2EventObserver(sessionId, (event) => emit(event))
+      : null;
   streamCleanup.setOutputCleanup(() => streamCoalescer.flush?.());
 
   const hasInjectedSessionStore =
@@ -2484,6 +2499,20 @@ async function runAgentHeadlessStreamInWorkspace(
   let sanitizeRolesNextTurn =
     resumedMessages > 0 && messages[messages.length - 1]?.role === "user";
 
+  // `system:init` intentionally precedes MCP connection so stream consumers
+  // receive their manifest promptly. Validation itself is local and side-effect
+  // free, so preflight just its bounded, redacted projection here; the normal
+  // resolver below remains authoritative for parsing and connection.
+  let initialMcpServerErrors = [];
+  if (options.mcpConfig) {
+    try {
+      initialMcpServerErrors = readHeadlessMcpConfigErrors(options.mcpConfig);
+    } catch {
+      // The normal resolver reports unreadable/malformed files as its existing
+      // config error result. Never place filesystem/parser details in init.
+    }
+  }
+
   emit({
     type: "system",
     subtype: "init",
@@ -2512,6 +2541,9 @@ async function runAgentHeadlessStreamInWorkspace(
       mcp: Boolean(options.mcpConfig) || options.useRegisteredMcp !== false,
       enabledToolNames,
     }),
+    ...(initialMcpServerErrors.length > 0
+      ? { mcp_server_errors: initialMcpServerErrors }
+      : {}),
     slash_commands: [...SESSION_SLASH_COMMANDS],
     input_format: "stream-json",
     additional_directories: additionalDirectories,
@@ -2591,6 +2623,7 @@ async function runAgentHeadlessStreamInWorkspace(
         },
         {
           writeErr,
+          mcpConfigWarnings: false,
           loadMcpConfig: deps.loadMcpConfig,
           loadRegisteredMcp: deps.loadRegisteredMcp,
           loadIdeMcp: deps.loadIdeMcp,
@@ -2836,6 +2869,78 @@ async function runAgentHeadlessStreamInWorkspace(
     }
   }
 
+  const streamInteraction = {};
+  if (interactiveQuestions) streamInteraction.askUser = interactionAskUser;
+  if (options.includeHookEvents === true) {
+    streamInteraction.emit = (kind, payload = {}) => {
+      const subAgentId =
+        typeof payload.subAgentId === "string" && payload.subAgentId.trim()
+          ? payload.subAgentId.slice(0, 160)
+          : null;
+      if (!subAgentId) return;
+      const base = {
+        schema_version: 1,
+        subagent_id: subAgentId,
+        parent_id:
+          typeof payload.parentSessionId === "string" &&
+          payload.parentSessionId.trim()
+            ? payload.parentSessionId.slice(0, 160)
+            : sessionId,
+        ...(typeof payload.role === "string" && payload.role.trim()
+          ? { role: payload.role.trim().slice(0, 96) }
+          : {}),
+      };
+      if (kind === "sub-agent.started") {
+        emit({
+          type: "subagent_started",
+          ...base,
+          background: payload.background === true,
+        });
+      } else if (
+        kind === "sub-agent.completed" ||
+        kind === "sub-agent.failed"
+      ) {
+        emit({
+          type: "subagent_completed",
+          ...base,
+          status: kind === "sub-agent.failed" ? "failed" : "completed",
+          background: payload.background === true,
+          ...(Number.isFinite(payload.iterationCount)
+            ? {
+                iteration_count: Math.max(
+                  0,
+                  Math.floor(payload.iterationCount),
+                ),
+              }
+            : {}),
+        });
+      } else if (kind === "sub-agent.progress") {
+        emit({
+          type: "subagent_progress",
+          ...base,
+          event_type:
+            typeof payload.event_type === "string"
+              ? payload.event_type.slice(0, 96)
+              : "unknown",
+          ...(typeof payload.tool === "string" && payload.tool
+            ? { tool: payload.tool.slice(0, 128) }
+            : {}),
+          ...(Number.isFinite(payload.iteration_count)
+            ? {
+                iteration_count: Math.max(
+                  0,
+                  Math.floor(payload.iteration_count),
+                ),
+              }
+            : {}),
+          ...(Number.isFinite(payload.token_count)
+            ? { token_count: Math.max(0, Math.floor(payload.token_count)) }
+            : {}),
+        });
+      }
+    };
+  }
+
   const loopOptionsBase = {
     model,
     provider,
@@ -2849,6 +2954,7 @@ async function runAgentHeadlessStreamInWorkspace(
     additionalDirectories,
     sessionId,
     sessionBudget: options.sessionBudget || null,
+    hostResourceBudget,
     sessionHostSnapshot: canonicalResume?.snapshot || null,
     // Auto-checkpoint (Claude-Code parity): snapshot the work tree before each
     // mutating tool so a stream consumer (e.g. the IDE chat panel) can rewind.
@@ -2877,9 +2983,8 @@ async function runAgentHeadlessStreamInWorkspace(
     // ask_user_question round-trip (opt-in via CC_INTERACTIVE_QUESTIONS): give
     // the tool handler an askUser that emits question_request + blocks on stdin.
     // Absent → agent-core returns user_not_reachable (graceful proceed).
-    interaction: interactiveQuestions
-      ? { askUser: interactionAskUser }
-      : undefined,
+    interaction:
+      Object.keys(streamInteraction).length > 0 ? streamInteraction : undefined,
     prepareCall: goalPrepareCallFn,
     // --mcp-config wiring (tool defs + dispatch map + live client).
     mcpClient: mcp?.mcpClient || null,
@@ -3081,13 +3186,43 @@ async function runAgentHeadlessStreamInWorkspace(
   // Stop / Claude-Code Esc parity) instead of waiting in line behind it.
   // Normal events queue for the serial turn loop below; interrupts act on the
   // live per-turn AbortController and are never queued.
+  // A normal input can contain arbitrary user data, so retain it only while it
+  // is waiting for the serial turn loop. Interrupts/approvals/answers remain
+  // out-of-band controls and never consume a queue slot.
   const queue = [];
   let wakeQueue = null;
   let inputDone = false;
   let currentAbort = null;
+  let inputBacklogFailure = false;
   let slashRequestSeq = 0;
   const inputLines = readJsonLines(input);
-  streamCleanup.setInputCancel(() => inputLines.return?.());
+  const releaseQueuedInputEvents = () => {
+    while (queue.length > 0) {
+      const queued = queue.shift();
+      try {
+        queued?.lease?.release?.();
+      } catch {
+        // Drain every opaque slot even when an injected test authority has a
+        // faulty disposer. Its payload is deliberately never inspected here.
+      }
+    }
+  };
+  const failInputEventBacklog = () => {
+    if (inputBacklogFailure) return;
+    inputBacklogFailure = true;
+    releaseQueuedInputEvents();
+    // A flood can happen while a model turn is running. Abort that turn before
+    // surfacing the stable host diagnostic; otherwise it could continue to do
+    // paid/tool work after the host has refused its input backlog.
+    currentAbort?.abort();
+    streamCleanup.setReason("host_event_backlog_exhausted");
+    streamCleanup.requestStop();
+    wakeQueue?.();
+  };
+  streamCleanup.setInputCancel(() => {
+    releaseQueuedInputEvents();
+    return inputLines.return?.();
+  });
   (async () => {
     try {
       for await (const line of inputLines) {
@@ -3157,7 +3292,26 @@ async function runAgentHeadlessStreamInWorkspace(
             );
           continue;
         }
-        queue.push(parsed);
+        try {
+          if (typeof hostResourceBudget?.admitEvent !== "function") {
+            throw new TypeError(
+              "host resource budget does not provide admitEvent()",
+            );
+          }
+          const lease = hostResourceBudget.admitEvent();
+          if (!lease || typeof lease.release !== "function") {
+            throw new TypeError(
+              "host resource budget event admission is invalid",
+            );
+          }
+          queue.push({ parsed, lease });
+        } catch {
+          // Refuse the whole input stream rather than dropping one unbounded
+          // event and then accepting more. The externally-visible error below
+          // is fixed and contains none of the rejected line's content.
+          failInputEventBacklog();
+          break;
+        }
         if (wakeQueue) wakeQueue();
       }
     } catch {
@@ -3177,7 +3331,15 @@ async function runAgentHeadlessStreamInWorkspace(
   })();
   const nextEvent = async () => {
     for (;;) {
-      if (queue.length > 0) return queue.shift();
+      if (queue.length > 0) {
+        const queued = queue.shift();
+        try {
+          return queued.parsed;
+        } finally {
+          // The serial loop now owns the event; it is no longer backlog.
+          queued.lease.release();
+        }
+      }
       if (inputDone || options.signal?.aborted) return null;
       await new Promise((r) => {
         let settled = false;
@@ -3198,6 +3360,18 @@ async function runAgentHeadlessStreamInWorkspace(
   for (;;) {
     await deps.outputFlow?.wait?.();
     const parsed = await nextEvent();
+    if (inputBacklogFailure) {
+      emit({
+        type: "result",
+        subtype: "error_host_resource_budget",
+        is_error: true,
+        code: HOST_EVENT_BACKLOG_CODE,
+        error: HOST_EVENT_BACKLOG_ERROR,
+        session_id: sessionId,
+      });
+      sawError = true;
+      break;
+    }
     if (parsed == null) break; // stdin closed
     sessionHostLease?.assert?.();
     if (turnBindingPersistenceError) {
@@ -4309,6 +4483,7 @@ async function runAgentHeadlessStreamInWorkspace(
           : "completed",
   );
   await streamCleanup.cleanup();
+  removeHookObserver?.();
 
   if (!pipeState.closed) {
     emit({ type: "system", subtype: "end", session_id: sessionId, turns });

package/src/runtime/mcp-config.js

@@ -51,7 +51,15 @@ import {
   normalizeMcpSandboxPolicy,
   readMcpStdioCwd,
 } from "../lib/mcp-sandbox-policy.js";
-import { normalizeMcpTlsConfig } from "../lib/mcp-tls.js";
+import {
+  MCP_TLS_MANAGED_SOURCE_REQUIRED_CODE,
+  MCP_TLS_MANAGED_SOURCE_REQUIRED_MESSAGE,
+  provisionManagedMcpTlsConfig,
+} from "../lib/mcp-tls.js";
+import {
+  McpLifecycleAuthority,
+  defaultMcpLifecycleAuthorityPath,
+} from "../lib/mcp-lifecycle-authority.js";
 
 function invalidSandboxPolicy(message) {
   const error = new TypeError(message);
@@ -135,12 +143,203 @@ function headersHelperField(value) {
     : {};
 }
 
+const MCP_CONFIG_ERROR_TYPES = new Set([
+  "invalid_config",
+  "invalid_name",
+  "unknown_type",
+  "url_missing_type",
+  "reserved_name",
+]);
+
+const MCP_CONFIG_TRANSPORT_TYPES = new Set([
+  "stdio",
+  "http",
+  "https",
+  "sse",
+  "ws",
+  "wss",
+]);
+
+function mcpConfigError(name, type, message) {
+  return {
+    // The entry name is intentionally retained: callers need to associate a
+    // skipped config with the declaration that supplied it. Keep its size
+    // bounded, while all other fields are fixed host-owned strings.
+    name: String(name || "<unnamed>").slice(0, 256),
+    type: MCP_CONFIG_ERROR_TYPES.has(type) ? type : "invalid_config",
+    message,
+  };
+}
+
+function mcpConfigEntries(raw) {
+  const block =
+    raw && typeof raw === "object" && !Array.isArray(raw)
+      ? raw.mcpServers || raw.servers || raw
+      : null;
+  return block && typeof block === "object" && !Array.isArray(block)
+    ? Object.entries(block)
+    : [];
+}
+
+function mcpConfigEntryError(name, config) {
+  if (!name || typeof name !== "string" || name.trim().length === 0) {
+    return mcpConfigError(
+      name,
+      "invalid_name",
+      "MCP server name must be a non-empty string.",
+    );
+  }
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    return mcpConfigError(
+      name,
+      "invalid_config",
+      "MCP server configuration must be an object.",
+    );
+  }
+
+  const configuredType =
+    typeof config.type === "string" && config.type.trim()
+      ? config.type.trim().toLowerCase()
+      : typeof config.transport === "string" && config.transport.trim()
+        ? config.transport.trim().toLowerCase()
+        : null;
+  if (configuredType && !MCP_CONFIG_TRANSPORT_TYPES.has(configuredType)) {
+    return mcpConfigError(
+      name,
+      "unknown_type",
+      "MCP server transport type is not supported.",
+    );
+  }
+
+  const hasCommand =
+    typeof config.command === "string" && config.command.trim().length > 0;
+  const hasUrl = typeof config.url === "string" && config.url.trim().length > 0;
+  if (hasCommand && hasUrl) {
+    return mcpConfigError(
+      name,
+      "invalid_config",
+      "MCP server configuration must specify one transport endpoint.",
+    );
+  }
+  if (
+    configuredType === "stdio" &&
+    !hasCommand &&
+    config.disabled !== true &&
+    config.enabled !== false
+  ) {
+    return mcpConfigError(
+      name,
+      "invalid_config",
+      "Stdio MCP server configuration requires a command.",
+    );
+  }
+  if (
+    configuredType &&
+    configuredType !== "stdio" &&
+    !hasUrl &&
+    config.disabled !== true &&
+    config.enabled !== false
+  ) {
+    return mcpConfigError(
+      name,
+      "invalid_config",
+      "Remote MCP server configuration requires a URL.",
+    );
+  }
+  if (
+    !hasCommand &&
+    !hasUrl &&
+    config.disabled !== true &&
+    config.enabled !== false
+  ) {
+    return mcpConfigError(
+      name,
+      "invalid_config",
+      "MCP server configuration requires a command or URL.",
+    );
+  }
+  return null;
+}
+
+/**
+ * Validate one explicit `--mcp-config` document without connecting to any
+ * server. Invalid entries are independently skipped; the fixed diagnostic
+ * shape is safe to expose in headless `system:init` output.
+ *
+ * This intentionally retains ChainlessChain's legacy URL inference when no
+ * `type`/`transport` is given. Explicit, unknown transport types are rejected
+ * before any DNS, process spawn, or transport construction.
+ */
+export function parseHeadlessMcpConfig(raw) {
+  const servers = {};
+  const errors = [];
+  for (const [name, config] of mcpConfigEntries(raw)) {
+    const entryError = mcpConfigEntryError(name, config);
+    if (entryError) {
+      errors.push(entryError);
+      continue;
+    }
+    try {
+      // Claude-style config calls the field `type`; the established cc shape
+      // calls it `transport`. Preserve an explicit transport when both exist.
+      const normalizedConfig =
+        config.transport == null && typeof config.type === "string"
+          ? { ...config, transport: config.type }
+          : config;
+      const parsed = parseMcpServers({
+        mcpServers: { [name]: normalizedConfig },
+      });
+      if (!parsed[name]) {
+        errors.push(
+          mcpConfigError(
+            name,
+            "invalid_config",
+            "MCP server configuration is invalid.",
+          ),
+        );
+        continue;
+      }
+      servers[name] = parsed[name];
+    } catch (error) {
+      if (error?.code === MCP_SANDBOX_POLICY_INVALID_CODE) {
+        throw error;
+      }
+      // Non-authority config parsers can still reject malformed nested values.
+      // Do not reflect their raw message into NDJSON because it may contain a
+      // filesystem path or user-supplied secret.
+      errors.push(
+        mcpConfigError(
+          name,
+          "invalid_config",
+          "MCP server configuration is invalid.",
+        ),
+      );
+    }
+  }
+  return { servers, errors };
+}
+
+/** Read just the safe validation projection for a `--mcp-config` file. */
+export function readHeadlessMcpConfigErrors(filePath, deps = {}) {
+  const readFile = deps.readFile || ((p) => fs.readFileSync(p, "utf-8"));
+  const raw = JSON.parse(readFile(filePath));
+  return parseHeadlessMcpConfig(raw).errors;
+}
+
 /**
  * Normalize a parsed config object into a `{ name: serverConfig }` map.
  * Accepts the Claude-Code shape `{ "mcpServers": { ... } }`, the bundle shape
  * `{ "servers": { ... } }`, or a bare `{ name: cfg }` map.
  */
-export function parseMcpServers(raw) {
+function unmanagedMcpTlsConfigError() {
+  // Configuration parsing errors are surfaced in headless diagnostics. Keep
+  // this entirely host-owned: do not disclose source paths or any TLS field.
+  const error = new Error(MCP_TLS_MANAGED_SOURCE_REQUIRED_MESSAGE);
+  error.code = MCP_TLS_MANAGED_SOURCE_REQUIRED_CODE;
+  return error;
+}
+
+function parseMcpServersForSource(raw, { provisionManagedTls = false } = {}) {
   const block =
     (raw && typeof raw === "object" && (raw.mcpServers || raw.servers)) ||
     raw ||
@@ -208,22 +407,50 @@ export function parseMcpServers(raw) {
       ...(Number.isFinite(cfg.maxToolResultNodes)
         ? { maxToolResultNodes: cfg.maxToolResultNodes }
         : {}),
+      ...(Number.isFinite(cfg.toolIdleTimeoutMs)
+        ? { toolIdleTimeoutMs: cfg.toolIdleTimeoutMs }
+        : {}),
+      ...(cfg.discoveryCache === true ||
+      (cfg.discoveryCache && typeof cfg.discoveryCache === "object")
+        ? { discoveryCache: cfg.discoveryCache }
+        : {}),
       ...headersHelperField(cfg.headersHelper),
       ...(cfg.configScope ? { configScope: cfg.configScope } : {}),
       ...(cfg.configSource ? { configSource: cfg.configSource } : {}),
-      ...(cfg.tls != null ? { tls: normalizeMcpTlsConfig(cfg.tls) } : {}),
+      ...(cfg.tls != null
+        ? provisionManagedTls
+          ? { tls: provisionManagedMcpTlsConfig(cfg.tls) }
+          : (() => {
+              throw unmanagedMcpTlsConfigError();
+            })()
+        : {}),
+      ...(cfg.disabled === true || cfg.enabled === false
+        ? { disabled: true }
+        : {}),
     };
   }
   return out;
 }
 
+/**
+ * Parse an unprivileged MCP configuration source. TLS material is deliberately
+ * rejected here; only `loadManagedMcp` invokes the source-specific parser that
+ * can mint the opaque managed TLS provenance.
+ */
+export function parseMcpServers(raw) {
+  return parseMcpServersForSource(raw);
+}
+
 /** Load organization-provisioned MCP servers as the highest-precedence layer. */
 export async function loadManagedMcp(settings, deps = {}) {
   const block = settings?.managedMcpServers || settings?.mcpServers;
   if (!block || typeof block !== "object" || Array.isArray(block)) {
     return deps.into || null;
   }
-  const servers = parseMcpServers({ mcpServers: block });
+  const servers = parseMcpServersForSource(
+    { mcpServers: block },
+    { provisionManagedTls: true },
+  );
   const nameReservations = mcpServerNameReservations(deps);
   for (const config of Object.values(servers)) {
     config.configScope = "managed";
@@ -339,11 +566,30 @@ export function mcpAuthHint(url, errMessage) {
  */
 export async function setupMcpFromConfig(servers, deps = {}) {
   const writeErr = deps.writeErr || (() => {});
+  const mcpLifecycleAuthority =
+    deps.mcpLifecycleAuthority || new McpLifecycleAuthority();
   const createClient =
     deps.createClient ||
     (() =>
-      new MCPClient({ eventRuntimeStore: deps.eventRuntimeStore || null }));
+      new MCPClient({
+        eventRuntimeStore: deps.eventRuntimeStore || null,
+        lifecycleAuthority: mcpLifecycleAuthority,
+        sessionId: deps.sessionId,
+      }));
   servers = filterMcpServersByPolicy(servers, deps.mcpPolicy, writeErr);
+  const enabledServers = {};
+  for (const [name, config] of Object.entries(servers)) {
+    if (config?.disabled === true || config?.enabled === false) {
+      mcpLifecycleAuthority.markDisabled({
+        name,
+        sessionId: deps.sessionId || "default",
+        config,
+      });
+    } else {
+      enabledServers[name] = config;
+    }
+  }
+  servers = enabledServers;
   const nameReservations = mcpServerNameReservations(deps);
   const previouslyReservedNames = new Set(nameReservations);
 
@@ -373,6 +619,29 @@ export async function setupMcpFromConfig(servers, deps = {}) {
     result.resourceTemplates = [];
   }
   if (!Array.isArray(result.prompts)) result.prompts = [];
+  if (!Array.isArray(result.mcpServerErrors)) {
+    result.mcpServerErrors = [];
+  }
+  if (Array.isArray(deps.mcpServerErrors)) {
+    for (const error of deps.mcpServerErrors) {
+      if (!error || typeof error !== "object") continue;
+      const normalized = mcpConfigError(
+        error.name,
+        error.type,
+        error.message || "MCP server configuration is invalid.",
+      );
+      if (
+        !result.mcpServerErrors.some(
+          (current) =>
+            current.name === normalized.name &&
+            current.type === normalized.type &&
+            current.message === normalized.message,
+        )
+      ) {
+        result.mcpServerErrors.push(normalized);
+      }
+    }
+  }
   // Per-server usage instructions from the MCP initialize response (surfaced
   // by tool search; absent for servers that send none).
   if (
@@ -779,20 +1048,31 @@ export async function loadMcpConfig(filePath, deps = {}) {
       `--mcp-config: cannot read/parse "${filePath}": ${err.message}`,
     );
   }
-  const servers = parseMcpServers(raw);
-  if (Object.keys(servers).length === 0) {
+  const { servers, errors } = parseHeadlessMcpConfig(raw);
+  if (Object.keys(servers).length === 0 && errors.length === 0) {
     throw new Error(
       `--mcp-config: no servers found in "${filePath}" ` +
         `(expected {"mcpServers": {"name": {"command": "..."}}}).`,
     );
   }
+  if (errors.length > 0 && deps.mcpConfigWarnings !== false) {
+    const count = errors.length;
+    const noun = count === 1 ? "server" : "servers";
+    deps.writeErr?.(
+      `Warning: ${count} MCP ${noun} skipped due to invalid config:\n` +
+        errors.map((error) => `  ${error.name}: ${error.message}\n`).join(""),
+    );
+  }
   authorizeStdioServers(
     servers,
     "explicit-config",
     () => path.resolve(filePath),
     { failFast: true },
   );
-  return setupMcpFromConfig(servers, deps);
+  return setupMcpFromConfig(servers, {
+    ...deps,
+    mcpServerErrors: errors,
+  });
 }
 
 /**
@@ -1317,6 +1597,15 @@ export async function resolveAgentMcp(args = {}, deps = {}) {
     (runtimeEnv.CC_EVENT_RUNTIME_DURABLE === "1"
       ? new EventRuntimeStore()
       : null);
+  const mcpLifecycleAuthority =
+    deps.mcpLifecycleAuthority ||
+    args.mcpLifecycleAuthority ||
+    new McpLifecycleAuthority({
+      statePath:
+        deps.mcpLifecycleStatePath ||
+        args.mcpLifecycleStatePath ||
+        defaultMcpLifecycleAuthorityPath(),
+    });
   const serverNameReservations =
     deps.mcpServerNameReservations instanceof Set
       ? deps.mcpServerNameReservations
@@ -1341,6 +1630,7 @@ export async function resolveAgentMcp(args = {}, deps = {}) {
     cwd: args.cwd || deps.cwd || process.cwd(),
     ...(args.sessionId != null ? { sessionId: args.sessionId } : {}),
     ...(eventRuntimeStore ? { eventRuntimeStore } : {}),
+    mcpLifecycleAuthority,
     mcpPolicy,
     mcpServerNameReservations: serverNameReservations,
   };