claude-threads 1.34.2 → 1.35.0

package/dist/index.js

@@ -2196,6 +2196,231 @@ var init_logger = __esm(() => {
   wsLogger = createLogger("ws", false);
 });
 
+// src/config/types.ts
+function isOverheadVisibility(value) {
+  return typeof value === "string" && OVERHEAD_VISIBILITY_VALUES.includes(value);
+}
+function resolveOverheadVisibility(value, fieldPath) {
+  if (value === undefined || value === null)
+    return DEFAULT_OVERHEAD_VISIBILITY;
+  if (isOverheadVisibility(value))
+    return value;
+  throw new Error(`Invalid ${fieldPath}: expected one of ${OVERHEAD_VISIBILITY_VALUES.join(", ")}, got ${JSON.stringify(value)}`);
+}
+function resolveMemoryConfig(value, fieldPath) {
+  if (value === undefined || value === null || value === true)
+    return DEFAULT_MEMORY_CONFIG;
+  if (value === false)
+    return MEMORY_DISABLED;
+  if (typeof value === "object" && !Array.isArray(value)) {
+    const obj = value;
+    const bool2 = (v, name, dflt) => resolveBooleanFeature(v, `${fieldPath ?? "memory"}.${name}`, { default: dflt, verb: `using default (${dflt})` });
+    const enabled = bool2(obj.enabled, "enabled", true);
+    if (!enabled)
+      return MEMORY_DISABLED;
+    return {
+      enabled: true,
+      repoLayer: bool2(obj.repoLayer, "repoLayer", true),
+      channelLayer: bool2(obj.channelLayer, "channelLayer", true),
+      distillation: bool2(obj.distillation, "distillation", true)
+    };
+  }
+  console.warn(`Invalid ${fieldPath ?? "memory"} config: expected boolean or {enabled, repoLayer, channelLayer, distillation}, got ${JSON.stringify(value)} — using defaults`);
+  return DEFAULT_MEMORY_CONFIG;
+}
+function resolveRoutinesEnabled(value, fieldPath) {
+  return resolveBooleanFeature(value, fieldPath ?? "routines", { default: true, verb: "routines stay enabled" });
+}
+function resolveTranscriptionEnabled(value, fieldPath) {
+  if (value === undefined || value === null)
+    return true;
+  if (typeof value === "boolean")
+    return value;
+  console.warn(`Invalid ${fieldPath ?? "transcription"}: ${JSON.stringify(value)} — expected true or false. ` + `Transcription is DISABLED for this platform: a value we cannot read is not consent to upload its audio.`);
+  return false;
+}
+function resolveBooleanFeature(value, fieldPath, opts) {
+  if (value === true || value === false)
+    return value;
+  if (value === undefined || value === null)
+    return opts.default;
+  console.warn(`Invalid ${fieldPath} config: expected boolean, got ${JSON.stringify(value)} — ${opts.verb}`);
+  return opts.default;
+}
+function resolveWatchesEnabled(value, fieldPath) {
+  return resolveBooleanFeature(value, fieldPath ?? "watches", { default: true, verb: "watches stay enabled" });
+}
+function resolveAuditLogEnabled(value, fieldPath) {
+  return resolveBooleanFeature(value, fieldPath ?? "auditLog", { default: false, verb: "audit log stays off" });
+}
+function isRemoteMcpServer(server) {
+  return server.type === "http" || server.type === "sse";
+}
+function resolveStrictMcpConfig(value, fieldPath) {
+  return resolveBooleanFeature(value, fieldPath ?? "strictMcpConfig", {
+    default: false,
+    verb: "the operator's MCP sources stay available"
+  });
+}
+function resolveClaudeAiConnectors(value, fieldPath) {
+  return resolveBooleanFeature(value, fieldPath ?? "claudeAiConnectors", {
+    default: false,
+    verb: "claude.ai connectors stay disabled"
+  });
+}
+function isStringRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((v) => typeof v === "string");
+}
+function validateMcpServers(value, fieldPath) {
+  if (value === undefined || value === null)
+    return {};
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Invalid ${fieldPath}: expected a map of server name → {command, args?, env?} or {type: http|sse, url, headers?}`);
+  }
+  const out = {};
+  for (const [name, raw] of Object.entries(value)) {
+    const path = `${fieldPath}.${name}`;
+    if (name === BOT_MCP_SERVER_NAME) {
+      throw new Error(`Invalid ${path}: "${BOT_MCP_SERVER_NAME}" is the bot's own server and cannot be redefined`);
+    }
+    if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(name)) {
+      throw new Error(`Invalid ${path}: server names may contain letters, digits, "_" and "-" only`);
+    }
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      throw new Error(`Invalid ${path}: expected an object`);
+    }
+    const s = Object.fromEntries(Object.entries(raw).filter(([, v]) => v !== null && v !== undefined));
+    if (typeof s.command === "string" && typeof s.url === "string") {
+      throw new Error(`Invalid ${path}: has both command (stdio) and url (http/sse); keep one`);
+    }
+    const type2 = s.type ?? (typeof s.url === "string" ? "http" : "stdio");
+    if (type2 === "http" || type2 === "sse") {
+      const unknown = Object.keys(s).filter((k) => !REMOTE_KEYS.has(k));
+      if (unknown.length > 0) {
+        throw new Error(`Invalid ${path}: unknown key(s) ${unknown.join(", ")}; a ${type2} server takes type, url, headers`);
+      }
+      if (typeof s.url !== "string" || s.url.length === 0) {
+        throw new Error(`Invalid ${path}: a ${type2} server needs a url`);
+      }
+      if (s.headers !== undefined && !isStringRecord(s.headers)) {
+        throw new Error(`Invalid ${path}.headers: expected a map of strings`);
+      }
+      out[name] = { type: type2, url: s.url, ...s.headers ? { headers: s.headers } : {} };
+    } else if (type2 === "stdio") {
+      const unknown = Object.keys(s).filter((k) => !STDIO_KEYS.has(k));
+      if (unknown.length > 0) {
+        throw new Error(`Invalid ${path}: unknown key(s) ${unknown.join(", ")}; a stdio server takes type, command, args, env`);
+      }
+      if (typeof s.command !== "string" || s.command.length === 0) {
+        throw new Error(`Invalid ${path}: a stdio server needs a command (or set type: http|sse with a url)`);
+      }
+      if (s.args !== undefined && !(Array.isArray(s.args) && s.args.every((a) => typeof a === "string"))) {
+        throw new Error(`Invalid ${path}.args: expected a list of strings`);
+      }
+      if (s.env !== undefined && !isStringRecord(s.env)) {
+        throw new Error(`Invalid ${path}.env: expected a map of strings`);
+      }
+      out[name] = { type: "stdio", command: s.command, args: s.args ?? [], env: s.env ?? {} };
+    } else {
+      throw new Error(`Invalid ${path}.type: expected stdio, http or sse, got ${JSON.stringify(s.type)}`);
+    }
+  }
+  return out;
+}
+function resolveMcpServers(global2, platform, fieldPath) {
+  return { ...validateMcpServers(global2, "mcpServers"), ...validateMcpServers(platform, fieldPath) };
+}
+function resolveLimits(limits) {
+  const envMaxSessions = process.env.MAX_SESSIONS ? parseInt(process.env.MAX_SESSIONS, 10) : undefined;
+  const envSessionTimeout = process.env.SESSION_TIMEOUT_MS ? Math.round(parseInt(process.env.SESSION_TIMEOUT_MS, 10) / 60000) : undefined;
+  return {
+    maxSessions: limits?.maxSessions ?? envMaxSessions ?? LIMITS_DEFAULTS.maxSessions,
+    sessionTimeoutMinutes: limits?.sessionTimeoutMinutes ?? envSessionTimeout ?? LIMITS_DEFAULTS.sessionTimeoutMinutes,
+    sessionWarningMinutes: limits?.sessionWarningMinutes ?? LIMITS_DEFAULTS.sessionWarningMinutes,
+    cleanupIntervalMinutes: limits?.cleanupIntervalMinutes ?? LIMITS_DEFAULTS.cleanupIntervalMinutes,
+    maxWorktreeAgeHours: limits?.maxWorktreeAgeHours ?? LIMITS_DEFAULTS.maxWorktreeAgeHours,
+    cleanupWorktrees: limits?.cleanupWorktrees ?? LIMITS_DEFAULTS.cleanupWorktrees,
+    permissionTimeoutSeconds: limits?.permissionTimeoutSeconds ?? LIMITS_DEFAULTS.permissionTimeoutSeconds,
+    flushDelayMs: limits?.flushDelayMs ?? LIMITS_DEFAULTS.flushDelayMs,
+    maxRoutines: limits?.maxRoutines ?? LIMITS_DEFAULTS.maxRoutines,
+    maxWatches: limits?.maxWatches ?? LIMITS_DEFAULTS.maxWatches,
+    watchCooldownMinutes: limits?.watchCooldownMinutes ?? LIMITS_DEFAULTS.watchCooldownMinutes,
+    watchDailyCap: limits?.watchDailyCap ?? LIMITS_DEFAULTS.watchDailyCap
+  };
+}
+function resolvePermissionMode(opts) {
+  if (opts.permissionMode)
+    return opts.permissionMode;
+  if (opts.skipPermissions === true)
+    return "bypass";
+  if (opts.skipPermissions === false)
+    return "default";
+  return "default";
+}
+function permissionModeDisplay(mode) {
+  const info = MODE_INFO[mode];
+  return { icon: info.icon, label: info.label, chip: `${info.icon} ${info.label}` };
+}
+function permissionModeDescription(mode) {
+  return MODE_INFO[mode].description;
+}
+function effectivePermissionMode(input) {
+  if (input.override)
+    return input.override;
+  if (input.sessionHasInteractiveOverride)
+    return "default";
+  return input.botWideMode;
+}
+var OVERHEAD_VISIBILITY_VALUES, DEFAULT_OVERHEAD_VISIBILITY = "full", DEFAULT_MEMORY_CONFIG, MEMORY_DISABLED, BOT_MCP_SERVER_NAME = "claude-threads-mcp", STDIO_KEYS, REMOTE_KEYS, LIMITS_DEFAULTS, MODE_INFO;
+var init_types = __esm(() => {
+  OVERHEAD_VISIBILITY_VALUES = ["full", "minimal", "hidden"];
+  DEFAULT_MEMORY_CONFIG = {
+    enabled: true,
+    repoLayer: true,
+    channelLayer: true,
+    distillation: true
+  };
+  MEMORY_DISABLED = {
+    enabled: false,
+    repoLayer: false,
+    channelLayer: false,
+    distillation: false
+  };
+  STDIO_KEYS = new Set(["type", "command", "args", "env"]);
+  REMOTE_KEYS = new Set(["type", "url", "headers"]);
+  LIMITS_DEFAULTS = {
+    maxSessions: 5,
+    sessionTimeoutMinutes: 30,
+    sessionWarningMinutes: 5,
+    cleanupIntervalMinutes: 60,
+    maxWorktreeAgeHours: 24,
+    cleanupWorktrees: true,
+    permissionTimeoutSeconds: 120,
+    flushDelayMs: 500,
+    maxRoutines: 10,
+    maxWatches: 10,
+    watchCooldownMinutes: 5,
+    watchDailyCap: 20
+  };
+  MODE_INFO = {
+    default: {
+      icon: "\uD83D\uDD10",
+      label: "Default",
+      description: "Every tool-use prompts for approval."
+    },
+    auto: {
+      icon: "⚡",
+      label: "Auto",
+      description: "Claude classifier auto-approves low-risk tools; high-risk still prompts."
+    },
+    bypass: {
+      icon: "⚠️",
+      label: "Bypass",
+      description: "No prompts — every tool-use is allowed."
+    }
+  };
+});
+
 // src/utils/spawn.ts
 import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "child_process";
 function addWindowsShell(options) {
@@ -4058,7 +4283,7 @@ var require_semver2 = __commonJS((exports, module) => {
 
 // src/claude/version-check.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { join as join3 } from "path";
 function tryClaudeVersion(claudePath) {
   try {
@@ -4117,7 +4342,7 @@ function getClaudeCliVersion() {
     return pathResult;
   }
   for (const path of COMMON_CLAUDE_PATHS) {
-    if (existsSync2(path)) {
+    if (existsSync3(path)) {
       const result = tryClaudeVersion(path);
       if (!result.error) {
         return result;
@@ -4156,7 +4381,7 @@ function getClaudePath() {
     return whichResult;
   }
   for (const path of COMMON_CLAUDE_PATHS) {
-    if (existsSync2(path)) {
+    if (existsSync3(path)) {
       const result = tryClaudeVersion(path);
       if (!result.error) {
         discoveredClaudePath = path;
@@ -4239,6 +4464,690 @@ var init_version_check = __esm(() => {
   ];
 });
 
+// src/mcp/outbound-env.ts
+var OUTBOUND_ENV;
+var init_outbound_env = __esm(() => {
+  OUTBOUND_ENV = {
+    SESSION_WORKING_DIR: "SESSION_WORKING_DIR",
+    SESSION_UPLOAD_DIR: "SESSION_UPLOAD_DIR",
+    OUTBOUND_FILES_ENABLED: "OUTBOUND_FILES_ENABLED",
+    OUTBOUND_FILES_MAX_BYTES: "OUTBOUND_FILES_MAX_BYTES"
+  };
+});
+
+// src/mcp/agent-features-env.ts
+var AGENT_FEATURES_ENV;
+var init_agent_features_env = __esm(() => {
+  AGENT_FEATURES_ENV = {
+    MEMORY_CHANNEL_ENABLED: "CT_MEMORY_CHANNEL_ENABLED",
+    ROUTINES_ENABLED: "CT_ROUTINES_ENABLED",
+    WATCHES_ENABLED: "CT_WATCHES_ENABLED",
+    UNATTENDED: "CT_UNATTENDED",
+    DCM: "CT_DCM"
+  };
+});
+
+// src/claude/rate-limit-detector.ts
+function detectRateLimit(text, now = Date.now()) {
+  if (!text)
+    return { detected: false };
+  let matched;
+  for (const phrase of RATE_LIMIT_PHRASES) {
+    const m = text.match(phrase);
+    if (m) {
+      matched = m[0];
+      break;
+    }
+  }
+  if (!matched)
+    return { detected: false };
+  const resetAtEpochMs = extractResetAt(text, now);
+  return { detected: true, matched, resetAtEpochMs };
+}
+function cooldownDeadline(hit, now = Date.now()) {
+  if (!hit.detected)
+    return now;
+  return hit.resetAtEpochMs ?? now + DEFAULT_COOLDOWN_MS;
+}
+function extractResetAt(text, now) {
+  const relative = text.match(/(?:retry[_\s-]?after|resets?\s+in)\s+(\d+)\s*(second|minute|hour|day)s?/i);
+  if (relative) {
+    const value = parseInt(relative[1], 10);
+    const unit = relative[2].toLowerCase();
+    const unitMs = {
+      second: 1000,
+      minute: 60000,
+      hour: 3600000,
+      day: 86400000
+    };
+    return now + value * unitMs[unit];
+  }
+  const unix = text.match(/\breset(?:_at)?\b\s*["']?\s*[:=]\s*(\d{10,13})/);
+  if (unix) {
+    const raw = parseInt(unix[1], 10);
+    return unix[1].length === 13 ? raw : raw * 1000;
+  }
+  const clock = text.match(/resets?\s+at\s+(\d{1,2}):(\d{2})\s*(utc|gmt)?/i);
+  if (clock) {
+    const hh = parseInt(clock[1], 10);
+    const mm = parseInt(clock[2], 10);
+    if (hh < 24 && mm < 60) {
+      const reference = new Date(now);
+      const target = new Date(Date.UTC(reference.getUTCFullYear(), reference.getUTCMonth(), reference.getUTCDate(), hh, mm)).getTime();
+      return target > now ? target : target + 86400000;
+    }
+  }
+  return;
+}
+function parseRateLimitEvent(event, now = Date.now()) {
+  const info = event?.rate_limit_info;
+  if (!info || typeof info !== "object")
+    return { detected: false };
+  const { status, resetsAt } = info;
+  if (status !== "rejected")
+    return { detected: false };
+  const PAST_SKEW_TOLERANCE_MS = 2 * 60000;
+  let resetAtEpochMs;
+  if (typeof resetsAt === "number") {
+    const ms = resetsAt * 1000;
+    if (ms > now && ms - now < 8 * 86400000) {
+      resetAtEpochMs = ms;
+    } else if (ms <= now && now - ms < PAST_SKEW_TOLERANCE_MS) {
+      resetAtEpochMs = now + 60000;
+    }
+  }
+  return { detected: true, matched: `rate_limit_event status=${status}`, resetAtEpochMs };
+}
+var RATE_LIMIT_PHRASES, DEFAULT_COOLDOWN_MS;
+var init_rate_limit_detector = __esm(() => {
+  RATE_LIMIT_PHRASES = [
+    /usage limit reached/i,
+    /rate[_\s-]?limit[_\s-]?error/i,
+    /you have hit the rate limit/i,
+    /quota (has been )?exceeded/i,
+    /\b429\b.*(rate|limit|quota)/i
+  ];
+  DEFAULT_COOLDOWN_MS = 60 * 60 * 1000;
+});
+
+// src/claude/cli.ts
+import { EventEmitter } from "events";
+import { resolve as resolve2, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync4, readFileSync as readFileSync2, watchFile, unwatchFile, unlinkSync, statSync, readdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join4 } from "path";
+function cleanupBrowserBridgeSockets() {
+  try {
+    const tempDir = tmpdir2();
+    const files = readdirSync(tempDir);
+    for (const file of files) {
+      if (file.startsWith("claude-mcp-browser-bridge-")) {
+        const filePath = join4(tempDir, file);
+        try {
+          const stats = statSync(filePath);
+          if (stats.isSocket()) {
+            unlinkSync(filePath);
+            log3.debug(`Removed stale browser bridge socket: ${file}`);
+          }
+        } catch {}
+      }
+    }
+  } catch (err) {
+    log3.debug(`Browser bridge cleanup failed: ${err}`);
+  }
+}
+function buildClaudeChildEnv(parentEnv, account, opts) {
+  const env = { ...parentEnv };
+  if (opts?.claudeAiConnectors !== true) {
+    env.ENABLE_CLAUDEAI_MCP_SERVERS = "false";
+  }
+  if (env.MCP_CONNECTION_NONBLOCKING === undefined) {
+    env.MCP_CONNECTION_NONBLOCKING = "true";
+  }
+  if (env.ENABLE_PROMPT_CACHING_1H === undefined) {
+    env.ENABLE_PROMPT_CACHING_1H = "true";
+  }
+  if (opts?.disableAutoMemory) {
+    env.CLAUDE_CODE_DISABLE_AUTO_MEMORY = "1";
+  }
+  if (opts?.decisionBridge && env.MCP_TOOL_TIMEOUT === undefined) {
+    env.MCP_TOOL_TIMEOUT = "3600000";
+  }
+  if (account?.home) {
+    env.HOME = account.home;
+    env.USERPROFILE = account.home;
+    delete env.ANTHROPIC_API_KEY;
+    delete env.CLAUDE_CODE_OAUTH_TOKEN;
+    delete env.ANTHROPIC_AUTH_TOKEN;
+    delete env.CLAUDE_CONFIG_DIR;
+    delete env.CLAUDE_SECURESTORAGE_CONFIG_DIR;
+  } else if (account?.apiKey) {
+    env.ANTHROPIC_API_KEY = account.apiKey;
+    delete env.CLAUDE_CODE_OAUTH_TOKEN;
+    delete env.ANTHROPIC_AUTH_TOKEN;
+  }
+  return env;
+}
+function buildInlineSettings(statusLineCommand, memory, mcp = {}) {
+  const settings = {};
+  if (mcp.claudeAiConnectors !== true) {
+    settings.disableClaudeAiConnectors = true;
+  }
+  if (statusLineCommand) {
+    settings.statusLine = {
+      type: "command",
+      command: statusLineCommand,
+      padding: 0
+    };
+  }
+  if (memory) {
+    settings.autoMemoryEnabled = true;
+    settings.autoMemoryDirectory = memory.autoMemoryDir;
+  }
+  return Object.keys(settings).length > 0 ? settings : null;
+}
+function runtimeForScriptPath(scriptPath) {
+  return scriptPath.endsWith(".ts") ? process.execPath : "node";
+}
+function isErrorResultEvent(event) {
+  const ev = event;
+  if (typeof ev.subtype === "string" && ev.subtype.startsWith("error"))
+    return true;
+  if (ev.is_error === true)
+    return true;
+  return false;
+}
+function materializeMcpConfig(config, sessionId, opts = {}) {
+  if (opts.inline) {
+    return { mode: "inline", value: JSON.stringify(config) };
+  }
+  const dir = opts.tmpDirOverride ?? tmpdir2();
+  const path = join4(dir, `claude-threads-mcp-${sessionId ?? process.pid}-${Date.now()}.json`);
+  writeFileSync2(path, JSON.stringify(config), { mode: 384 });
+  return { mode: "file", path };
+}
+function buildPermissionArgs(opts) {
+  const args = [];
+  if (opts.permissionMode === "bypass" && !opts.platformConfig) {
+    args.push("--dangerously-skip-permissions");
+    return { args, tempFile: null };
+  }
+  if (!opts.platformConfig) {
+    throw new Error(`platformConfig is required when permissionMode is '${opts.permissionMode}'`);
+  }
+  const mcpEnv = {
+    PLATFORM_TYPE: opts.platformConfig.type,
+    PLATFORM_URL: opts.platformConfig.url,
+    PLATFORM_TOKEN: opts.platformConfig.token,
+    PLATFORM_CHANNEL_ID: opts.platformConfig.channelId,
+    PLATFORM_THREAD_ID: opts.threadId || "",
+    ALLOWED_USERS: opts.platformConfig.allowedUsers.join(","),
+    DEBUG: opts.debug ? "1" : "",
+    PERMISSION_TIMEOUT_MS: String(opts.permissionTimeoutMs),
+    SESSION_OWNER_USERNAME: opts.sessionOwnerUsername || ""
+  };
+  if (opts.decisionBridgePath) {
+    mcpEnv.DECISION_BRIDGE_PATH = opts.decisionBridgePath;
+    if (process.env.DECISION_BRIDGE_TIMEOUT_MS) {
+      mcpEnv.DECISION_BRIDGE_TIMEOUT_MS = process.env.DECISION_BRIDGE_TIMEOUT_MS;
+    }
+    const features = opts.agentFeatures;
+    if (features) {
+      if (features.memoryChannel)
+        mcpEnv[AGENT_FEATURES_ENV.MEMORY_CHANNEL_ENABLED] = "1";
+      if (features.routines)
+        mcpEnv[AGENT_FEATURES_ENV.ROUTINES_ENABLED] = "1";
+      if (features.watches)
+        mcpEnv[AGENT_FEATURES_ENV.WATCHES_ENABLED] = "1";
+      if (features.unattended)
+        mcpEnv[AGENT_FEATURES_ENV.UNATTENDED] = "1";
+      if (features.dcm)
+        mcpEnv[AGENT_FEATURES_ENV.DCM] = "1";
+    }
+  }
+  if (opts.platformConfig.appToken) {
+    mcpEnv.PLATFORM_APP_TOKEN = opts.platformConfig.appToken;
+  }
+  if (opts.workingDir) {
+    mcpEnv[OUTBOUND_ENV.SESSION_WORKING_DIR] = opts.workingDir;
+  }
+  if (opts.uploadDir) {
+    mcpEnv[OUTBOUND_ENV.SESSION_UPLOAD_DIR] = opts.uploadDir;
+  }
+  if (opts.outboundFiles?.enabled === false) {
+    mcpEnv[OUTBOUND_ENV.OUTBOUND_FILES_ENABLED] = "0";
+  }
+  if (typeof opts.outboundFiles?.maxBytes === "number" && Number.isFinite(opts.outboundFiles.maxBytes) && opts.outboundFiles.maxBytes > 0) {
+    mcpEnv[OUTBOUND_ENV.OUTBOUND_FILES_MAX_BYTES] = String(opts.outboundFiles.maxBytes);
+  }
+  const mcpConfig = {
+    mcpServers: {
+      "claude-threads-mcp": {
+        type: "stdio",
+        command: runtimeForScriptPath(opts.mcpServerPath),
+        args: [opts.mcpServerPath],
+        env: mcpEnv
+      }
+    }
+  };
+  for (const [name, server] of Object.entries(opts.platformConfig.mcpServers ?? {})) {
+    if (name === BOT_MCP_SERVER_NAME)
+      continue;
+    mcpConfig.mcpServers[name] = isRemoteMcpServer(server) ? { type: server.type, url: server.url, ...server.headers ? { headers: server.headers } : {} } : { type: "stdio", command: server.command, args: server.args ?? [], env: server.env ?? {} };
+  }
+  const materialized = materializeMcpConfig(mcpConfig, opts.sessionId, { inline: opts.inline });
+  let tempFile = null;
+  if (materialized.mode === "file") {
+    tempFile = materialized.path;
+    args.push("--mcp-config", materialized.path);
+  } else {
+    args.push("--mcp-config", materialized.value);
+  }
+  if (opts.platformConfig.strictMcpConfig === true) {
+    args.push("--strict-mcp-config");
+  }
+  if (opts.permissionMode === "bypass") {
+    args.push("--dangerously-skip-permissions");
+  } else {
+    args.push("--permission-prompt-tool", "mcp__claude-threads-mcp__permission_prompt");
+    if (opts.permissionMode === "auto") {
+      args.push("--permission-mode", "auto");
+    }
+  }
+  return { args, tempFile };
+}
+var log3, STDERR_PER_INSTANCE_CAP = 10240, STDERR_AGGREGATE_SOFT_CAP, totalStderrBytes = 0, ClaudeCli;
+var init_cli = __esm(() => {
+  init_types();
+  init_spawn();
+  init_logger();
+  init_version_check();
+  init_outbound_env();
+  init_agent_features_env();
+  init_rate_limit_detector();
+  log3 = createLogger("claude");
+  STDERR_AGGREGATE_SOFT_CAP = 10 * 1024 * 1024;
+  ClaudeCli = class ClaudeCli extends EventEmitter {
+    process = null;
+    options;
+    buffer = "";
+    debug = process.env.DEBUG === "1" || process.argv.includes("--debug");
+    statusFilePath = null;
+    lastStatusData = null;
+    stderrBuffer = "";
+    mcpConfigTempFile = null;
+    lastEmittedRateLimitDeadline = 0;
+    lastEmittedHitHadExplicitReset = false;
+    log;
+    constructor(options) {
+      super();
+      this.options = options;
+      this.log = options.logSessionId ? createLogger("claude").forSession(options.logSessionId) : createLogger("claude");
+    }
+    getStatusFilePath() {
+      return this.statusFilePath;
+    }
+    getStatusData() {
+      if (!this.statusFilePath)
+        return null;
+      try {
+        if (existsSync4(this.statusFilePath)) {
+          const data = readFileSync2(this.statusFilePath, "utf8");
+          this.lastStatusData = JSON.parse(data);
+        }
+      } catch (err) {
+        this.log.debug(`Failed to read status file: ${err}`);
+      }
+      return this.lastStatusData;
+    }
+    startStatusWatch() {
+      if (!this.statusFilePath) {
+        this.log.debug("No status file path, skipping status watch");
+        return;
+      }
+      this.log.debug(`Starting status watch: ${this.statusFilePath}`);
+      const checkStatus = () => {
+        const data = this.getStatusData();
+        if (data && data.timestamp !== this.lastStatusData?.timestamp) {
+          this.lastStatusData = data;
+          this.emit("status", data);
+        }
+      };
+      watchFile(this.statusFilePath, { interval: 1000 }, checkStatus);
+    }
+    stopStatusWatch() {
+      if (this.statusFilePath) {
+        unwatchFile(this.statusFilePath);
+        try {
+          if (existsSync4(this.statusFilePath)) {
+            unlinkSync(this.statusFilePath);
+          }
+        } catch {}
+      }
+    }
+    start() {
+      if (this.process)
+        throw new Error("Already running");
+      totalStderrBytes -= this.stderrBuffer.length;
+      this.stderrBuffer = "";
+      this.lastEmittedRateLimitDeadline = 0;
+      this.lastEmittedHitHadExplicitReset = false;
+      cleanupBrowserBridgeSockets();
+      const claudePath = getClaudePath();
+      const args = [
+        "--input-format",
+        "stream-json",
+        "--output-format",
+        "stream-json",
+        "--verbose"
+      ];
+      if (this.options.sessionId) {
+        if (this.options.resume) {
+          args.push("--resume", this.options.sessionId);
+        } else {
+          args.push("--session-id", this.options.sessionId);
+        }
+      }
+      const permissionMode = this.options.permissionMode ?? "default";
+      const permResult = buildPermissionArgs({
+        permissionMode,
+        mcpServerPath: this.getMcpServerPath(),
+        platformConfig: this.options.platformConfig,
+        threadId: this.options.threadId,
+        sessionId: this.options.sessionId,
+        permissionTimeoutMs: this.options.permissionTimeoutMs ?? 120000,
+        debug: this.debug,
+        workingDir: this.options.workingDir,
+        uploadDir: this.options.uploadDir,
+        outboundFiles: this.options.outboundFiles,
+        sessionOwnerUsername: this.options.sessionOwnerUsername,
+        decisionBridgePath: this.options.decisionBridgePath,
+        agentFeatures: this.options.agentFeatures
+      });
+      args.push(...permResult.args);
+      this.mcpConfigTempFile = permResult.tempFile;
+      if (this.options.chrome) {
+        args.push("--chrome");
+      }
+      if (this.options.appendSystemPrompt) {
+        args.push("--append-system-prompt", this.options.appendSystemPrompt);
+      }
+      let statusLineCommand;
+      if (this.options.sessionId) {
+        this.statusFilePath = join4(tmpdir2(), `claude-threads-status-${this.options.sessionId}.json`);
+        const statusLineWriterPath = this.getStatusLineWriterPath();
+        const runtime = runtimeForScriptPath(statusLineWriterPath);
+        statusLineCommand = `${runtime} ${statusLineWriterPath} ${this.options.sessionId}`;
+      }
+      const settings = buildInlineSettings(statusLineCommand, this.options.memory, {
+        claudeAiConnectors: this.options.platformConfig?.claudeAiConnectors
+      });
+      if (settings) {
+        args.push("--settings", JSON.stringify(settings));
+      }
+      this.log.debug(`Starting: ${claudePath} ${args.slice(0, 5).join(" ")}...`);
+      const childEnv = this.buildChildEnv();
+      if (this.options.account) {
+        this.log.debug(`Spawning under Claude account "${this.options.account.id}"`);
+      }
+      this.process = crossSpawn(claudePath, args, {
+        cwd: this.options.workingDir,
+        env: childEnv,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      this.log.debug(`Claude process spawned: pid=${this.process.pid}`);
+      this.process.stdout?.on("data", (chunk) => {
+        this.parseOutput(chunk.toString());
+      });
+      this.process.stderr?.on("data", (chunk) => {
+        const text = chunk.toString();
+        const before = this.stderrBuffer.length;
+        this.stderrBuffer += text;
+        const cap = totalStderrBytes > STDERR_AGGREGATE_SOFT_CAP ? 1024 : STDERR_PER_INSTANCE_CAP;
+        if (this.stderrBuffer.length > cap) {
+          this.stderrBuffer = this.stderrBuffer.slice(-cap);
+        }
+        totalStderrBytes += this.stderrBuffer.length - before;
+        this.log.debug(`stderr: ${text.trim()}`);
+        if (process.env.INTEGRATION_TEST === "1") {
+          process.stderr.write(text);
+        }
+        this.maybeEmitRateLimit(text);
+      });
+      this.process.on("error", (err) => {
+        this.log.error(`Claude error: ${err}`);
+        this.emit("error", err);
+      });
+      this.process.on("exit", (code) => {
+        this.log.debug(`Exited ${code}`);
+        this.process = null;
+        this.buffer = "";
+        totalStderrBytes -= this.stderrBuffer.length;
+        if (this.mcpConfigTempFile) {
+          const path = this.mcpConfigTempFile;
+          this.mcpConfigTempFile = null;
+          try {
+            unlinkSync(path);
+          } catch {}
+        }
+        this.emit("exit", code);
+      });
+    }
+    sendMessage(content) {
+      if (!this.process?.stdin)
+        throw new Error("Not running");
+      const msg = JSON.stringify({
+        type: "user",
+        message: { role: "user", content }
+      }) + `
+`;
+      const preview = content.substring(0, 50);
+      this.log.debug(`Sending: ${preview}...`);
+      if (process.env.INTEGRATION_TEST === "1") {
+        const stack = new Error().stack?.split(`
+`).slice(2, 6).join(" > ").replace(/\s+at\s+/g, " < ") ?? "?";
+        process.stderr.write(`[claude-cli sendMessage pid=${this.process.pid}] ${preview} | ${stack}
+`);
+      }
+      this.process.stdin.write(msg);
+    }
+    sendToolResult(toolUseId, content) {
+      if (!this.process?.stdin)
+        throw new Error("Not running");
+      const msg = JSON.stringify({
+        type: "user",
+        message: {
+          role: "user",
+          content: [{
+            type: "tool_result",
+            tool_use_id: toolUseId,
+            content: typeof content === "string" ? content : JSON.stringify(content)
+          }]
+        }
+      }) + `
+`;
+      this.log.debug(`Sending tool_result for ${toolUseId}`);
+      this.process.stdin.write(msg);
+    }
+    parseOutput(data) {
+      this.buffer += data;
+      const lines = this.buffer.split(`
+`);
+      this.buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+          continue;
+        let event;
+        try {
+          event = JSON.parse(trimmed);
+        } catch {
+          continue;
+        }
+        try {
+          this.emit("event", event);
+        } catch (err) {
+          this.log.error(`'event' listener threw while handling a ${event.type} event: ${err}`);
+        }
+        if (event.type === "result" && isErrorResultEvent(event)) {
+          this.maybeEmitRateLimit(trimmed);
+        }
+        if (event.type === "rate_limit_event") {
+          this.maybeEmitRateLimitHit(parseRateLimitEvent(event));
+        }
+      }
+    }
+    maybeEmitRateLimit(text) {
+      this.maybeEmitRateLimitHit(detectRateLimit(text));
+    }
+    maybeEmitRateLimitHit(hit) {
+      if (!hit.detected)
+        return;
+      if (!hit.resetAtEpochMs && this.lastEmittedHitHadExplicitReset && this.lastEmittedRateLimitDeadline > Date.now()) {
+        return;
+      }
+      const newDeadline = cooldownDeadline(hit);
+      const MIN_ADVANCE_MS = 60000;
+      if (newDeadline - this.lastEmittedRateLimitDeadline < MIN_ADVANCE_MS) {
+        if (hit.resetAtEpochMs !== undefined) {
+          this.lastEmittedHitHadExplicitReset = true;
+        }
+        return;
+      }
+      this.lastEmittedRateLimitDeadline = newDeadline;
+      this.lastEmittedHitHadExplicitReset = hit.resetAtEpochMs !== undefined;
+      this.log.warn(`Rate limit detected: ${hit.matched ?? "(no match text)"}`);
+      this.emit("rate-limit", hit);
+    }
+    isRunning() {
+      return this.process !== null;
+    }
+    getLastStderr() {
+      return this.stderrBuffer;
+    }
+    isPermanentFailure() {
+      const stderr = this.stderrBuffer;
+      if (stderr.includes("claude-mcp-browser-bridge") && (stderr.includes("EOPNOTSUPP") || stderr.includes("ENOENT"))) {
+        return true;
+      }
+      if (stderr.includes("No conversation found with session ID")) {
+        return true;
+      }
+      return false;
+    }
+    getPermanentFailureReason() {
+      const stderr = this.stderrBuffer;
+      if (stderr.includes("claude-mcp-browser-bridge") && (stderr.includes("EOPNOTSUPP") || stderr.includes("ENOENT"))) {
+        return "Claude browser bridge state from a previous session is no longer accessible. This typically happens when a session with Chrome integration is resumed after a restart.";
+      }
+      if (stderr.includes("No conversation found with session ID")) {
+        return "The conversation history for this session no longer exists. This can happen if Claude's history was cleared or if the session was created on a different machine.";
+      }
+      return null;
+    }
+    kill() {
+      this.stopStatusWatch();
+      if (!this.process) {
+        this.log.debug("Kill called but process not running");
+        return Promise.resolve();
+      }
+      const proc = this.process;
+      const pid = proc.pid;
+      this.process = null;
+      this.log.debug(`Killing Claude process (pid=${pid})`);
+      if (process.env.INTEGRATION_TEST === "1") {
+        const stack = new Error().stack?.split(`
+`).slice(2, 7).join(" > ").replace(/\s+at\s+/g, " < ") ?? "?";
+        process.stderr.write(`[claude-cli kill pid=${pid}] | ${stack}
+`);
+      }
+      return new Promise((resolve3) => {
+        this.log.debug("Sending first SIGINT");
+        proc.kill("SIGINT");
+        const secondSigint = setTimeout(() => {
+          try {
+            this.log.debug("Sending second SIGINT");
+            proc.kill("SIGINT");
+          } catch {}
+        }, 100);
+        const forceKillTimeout = setTimeout(() => {
+          try {
+            this.log.debug("Sending SIGTERM (force kill)");
+            proc.kill("SIGTERM");
+          } catch {}
+        }, 2000);
+        const settle = (reason) => {
+          this.log.debug(`Claude process gone (${reason})`);
+          clearTimeout(secondSigint);
+          clearTimeout(forceKillTimeout);
+          clearTimeout(lastResort);
+          resolve3();
+        };
+        const lastResort = setTimeout(() => {
+          try {
+            this.log.warn("Claude process did not exit after SIGTERM — sending SIGKILL");
+            proc.kill("SIGKILL");
+          } catch {}
+          settle("kill timeout");
+        }, 5000);
+        proc.once("close", (code) => settle(`closed, code=${code}`));
+        proc.once("error", () => settle("spawn error"));
+      });
+    }
+    interrupt() {
+      if (!this.process) {
+        this.log.debug("Interrupt called but process not running");
+        return false;
+      }
+      this.log.debug(`Interrupting Claude process (pid=${this.process.pid})`);
+      this.process.kill("SIGINT");
+      return true;
+    }
+    buildChildEnv() {
+      return buildClaudeChildEnv(process.env, this.options.account, {
+        claudeAiConnectors: this.options.platformConfig?.claudeAiConnectors,
+        decisionBridge: this.options.decisionBridgePath !== undefined,
+        disableAutoMemory: this.options.memory === null
+      });
+    }
+    getMcpServerPath() {
+      const __filename2 = fileURLToPath(import.meta.url);
+      const __dirname2 = dirname2(__filename2);
+      const bundledPath = resolve2(__dirname2, "mcp", "mcp-server.js");
+      if (existsSync4(bundledPath)) {
+        return bundledPath;
+      }
+      const sourceLayoutPath = resolve2(__dirname2, "..", "mcp", "mcp-server.js");
+      if (existsSync4(sourceLayoutPath)) {
+        return sourceLayoutPath;
+      }
+      const tsPath = resolve2(__dirname2, "..", "mcp", "mcp-server.ts");
+      if (existsSync4(tsPath)) {
+        return tsPath;
+      }
+      return sourceLayoutPath;
+    }
+    getStatusLineWriterPath() {
+      const __filename2 = fileURLToPath(import.meta.url);
+      const __dirname2 = dirname2(__filename2);
+      const bundledPath = resolve2(__dirname2, "statusline", "writer.js");
+      if (existsSync4(bundledPath)) {
+        return bundledPath;
+      }
+      const sourceLayoutPath = resolve2(__dirname2, "..", "statusline", "writer.js");
+      if (existsSync4(sourceLayoutPath)) {
+        return sourceLayoutPath;
+      }
+      const tsPath = resolve2(__dirname2, "..", "statusline", "writer.ts");
+      if (existsSync4(tsPath)) {
+        return tsPath;
+      }
+      return sourceLayoutPath;
+    }
+  };
+});
+
 // src/utils/emoji.ts
 var exports_emoji = {};
 __export(exports_emoji, {
@@ -8699,7 +9608,7 @@ async function quickQuery(options) {
     let resolved = false;
     const proc = crossSpawn(claudePath, args, {
       cwd: workingDir || process.cwd(),
-      env: process.env,
+      env: buildClaudeChildEnv(process.env),
       stdio: ["pipe", "pipe", "pipe"]
     });
     const timeoutId = setTimeout(() => {
@@ -8763,6 +9672,7 @@ async function quickQuery(options) {
 var log20;
 var init_quick_query = __esm(() => {
   init_spawn();
+  init_cli();
   init_version_check();
   init_logger();
   log20 = createLogger("query");
@@ -18445,7 +19355,7 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
       return hook.checkDCE ? true : false;
     }
     function setIsStrictModeForDevtools(newIsStrictMode) {
-      typeof log54 === "function" && unstable_setDisableYieldValue2(newIsStrictMode);
+      typeof log55 === "function" && unstable_setDisableYieldValue2(newIsStrictMode);
       if (injectedHook && typeof injectedHook.setStrictMode === "function")
         try {
           injectedHook.setStrictMode(rendererID, newIsStrictMode);
@@ -26529,7 +27439,7 @@ Check the render method of %s.`, getComponentNameFromFiber(current) || "Unknown"
     var fiberStack = [];
     var index$jscomp$0 = -1, emptyContextObject = {};
     Object.freeze(emptyContextObject);
-    var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback, log$1 = Math.log, LN2 = Math.LN2, nextTransitionUpdateLane = 256, nextTransitionDeferredLane = 262144, nextRetryLane = 4194304, scheduleCallback$3 = Scheduler.unstable_scheduleCallback, cancelCallback$1 = Scheduler.unstable_cancelCallback, shouldYield = Scheduler.unstable_shouldYield, requestPaint = Scheduler.unstable_requestPaint, now$1 = Scheduler.unstable_now, ImmediatePriority = Scheduler.unstable_ImmediatePriority, UserBlockingPriority = Scheduler.unstable_UserBlockingPriority, NormalPriority$1 = Scheduler.unstable_NormalPriority, IdlePriority = Scheduler.unstable_IdlePriority, log54 = Scheduler.log, unstable_setDisableYieldValue2 = Scheduler.unstable_setDisableYieldValue, rendererID = null, injectedHook = null, hasLoggedError = false, isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined", lastResetTime = 0;
+    var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback, log$1 = Math.log, LN2 = Math.LN2, nextTransitionUpdateLane = 256, nextTransitionDeferredLane = 262144, nextRetryLane = 4194304, scheduleCallback$3 = Scheduler.unstable_scheduleCallback, cancelCallback$1 = Scheduler.unstable_cancelCallback, shouldYield = Scheduler.unstable_shouldYield, requestPaint = Scheduler.unstable_requestPaint, now$1 = Scheduler.unstable_now, ImmediatePriority = Scheduler.unstable_ImmediatePriority, UserBlockingPriority = Scheduler.unstable_UserBlockingPriority, NormalPriority$1 = Scheduler.unstable_NormalPriority, IdlePriority = Scheduler.unstable_IdlePriority, log55 = Scheduler.log, unstable_setDisableYieldValue2 = Scheduler.unstable_setDisableYieldValue, rendererID = null, injectedHook = null, hasLoggedError = false, isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined", lastResetTime = 0;
     if (typeof performance === "object" && typeof performance.now === "function") {
       var localPerformance = performance;
       var getCurrentTime = function() {
@@ -46489,7 +47399,7 @@ function getSessionStatus(session) {
 }
 
 // src/config/index.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync as mkdirSync2, chmodSync as chmodSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync as mkdirSync2, chmodSync as chmodSync2 } from "fs";
 import { resolve, dirname } from "path";
 import { homedir as homedir2 } from "os";
 
@@ -49610,154 +50520,43 @@ function requireJsYaml() {
 var jsYamlExports = requireJsYaml();
 var yaml = /* @__PURE__ */ getDefaultExportFromCjs(jsYamlExports);
 
-// src/config/types.ts
-var OVERHEAD_VISIBILITY_VALUES = ["full", "minimal", "hidden"];
-var DEFAULT_OVERHEAD_VISIBILITY = "full";
-function isOverheadVisibility(value) {
-  return typeof value === "string" && OVERHEAD_VISIBILITY_VALUES.includes(value);
-}
-function resolveOverheadVisibility(value, fieldPath) {
-  if (value === undefined || value === null)
-    return DEFAULT_OVERHEAD_VISIBILITY;
-  if (isOverheadVisibility(value))
-    return value;
-  throw new Error(`Invalid ${fieldPath}: expected one of ${OVERHEAD_VISIBILITY_VALUES.join(", ")}, got ${JSON.stringify(value)}`);
-}
-var DEFAULT_MEMORY_CONFIG = {
-  enabled: true,
-  repoLayer: true,
-  channelLayer: true,
-  distillation: true
-};
-var MEMORY_DISABLED = {
-  enabled: false,
-  repoLayer: false,
-  channelLayer: false,
-  distillation: false
-};
-function resolveMemoryConfig(value, fieldPath) {
-  if (value === undefined || value === null || value === true)
-    return DEFAULT_MEMORY_CONFIG;
-  if (value === false)
-    return MEMORY_DISABLED;
-  if (typeof value === "object" && !Array.isArray(value)) {
-    const obj = value;
-    const bool2 = (v, name, dflt) => resolveBooleanFeature(v, `${fieldPath ?? "memory"}.${name}`, { default: dflt, verb: `using default (${dflt})` });
-    const enabled = bool2(obj.enabled, "enabled", true);
-    if (!enabled)
-      return MEMORY_DISABLED;
-    return {
-      enabled: true,
-      repoLayer: bool2(obj.repoLayer, "repoLayer", true),
-      channelLayer: bool2(obj.channelLayer, "channelLayer", true),
-      distillation: bool2(obj.distillation, "distillation", true)
-    };
-  }
-  console.warn(`Invalid ${fieldPath ?? "memory"} config: expected boolean or {enabled, repoLayer, channelLayer, distillation}, got ${JSON.stringify(value)} — using defaults`);
-  return DEFAULT_MEMORY_CONFIG;
-}
-function resolveRoutinesEnabled(value, fieldPath) {
-  return resolveBooleanFeature(value, fieldPath ?? "routines", { default: true, verb: "routines stay enabled" });
-}
-function resolveTranscriptionEnabled(value, fieldPath) {
-  if (value === undefined || value === null)
-    return true;
-  if (typeof value === "boolean")
-    return value;
-  console.warn(`Invalid ${fieldPath ?? "transcription"}: ${JSON.stringify(value)} — expected true or false. ` + `Transcription is DISABLED for this platform: a value we cannot read is not consent to upload its audio.`);
-  return false;
-}
-function resolveBooleanFeature(value, fieldPath, opts) {
-  if (value === true || value === false)
-    return value;
-  if (value === undefined || value === null)
-    return opts.default;
-  console.warn(`Invalid ${fieldPath} config: expected boolean, got ${JSON.stringify(value)} — ${opts.verb}`);
-  return opts.default;
-}
-function resolveWatchesEnabled(value, fieldPath) {
-  return resolveBooleanFeature(value, fieldPath ?? "watches", { default: true, verb: "watches stay enabled" });
-}
-function resolveAuditLogEnabled(value, fieldPath) {
-  return resolveBooleanFeature(value, fieldPath ?? "auditLog", { default: false, verb: "audit log stays off" });
-}
-var LIMITS_DEFAULTS = {
-  maxSessions: 5,
-  sessionTimeoutMinutes: 30,
-  sessionWarningMinutes: 5,
-  cleanupIntervalMinutes: 60,
-  maxWorktreeAgeHours: 24,
-  cleanupWorktrees: true,
-  permissionTimeoutSeconds: 120,
-  flushDelayMs: 500,
-  maxRoutines: 10,
-  maxWatches: 10,
-  watchCooldownMinutes: 5,
-  watchDailyCap: 20
+// src/config/index.ts
+init_types();
+
+// src/config/managed-mcp.ts
+import { existsSync } from "fs";
+var MANAGED_MCP_CONFIG_PATHS = {
+  darwin: "/Library/Application Support/ClaudeCode/managed-mcp.json",
+  linux: "/etc/claude-code/managed-mcp.json",
+  win32: "C:\\Program Files\\ClaudeCode\\managed-mcp.json"
 };
-function resolveLimits(limits) {
-  const envMaxSessions = process.env.MAX_SESSIONS ? parseInt(process.env.MAX_SESSIONS, 10) : undefined;
-  const envSessionTimeout = process.env.SESSION_TIMEOUT_MS ? Math.round(parseInt(process.env.SESSION_TIMEOUT_MS, 10) / 60000) : undefined;
-  return {
-    maxSessions: limits?.maxSessions ?? envMaxSessions ?? LIMITS_DEFAULTS.maxSessions,
-    sessionTimeoutMinutes: limits?.sessionTimeoutMinutes ?? envSessionTimeout ?? LIMITS_DEFAULTS.sessionTimeoutMinutes,
-    sessionWarningMinutes: limits?.sessionWarningMinutes ?? LIMITS_DEFAULTS.sessionWarningMinutes,
-    cleanupIntervalMinutes: limits?.cleanupIntervalMinutes ?? LIMITS_DEFAULTS.cleanupIntervalMinutes,
-    maxWorktreeAgeHours: limits?.maxWorktreeAgeHours ?? LIMITS_DEFAULTS.maxWorktreeAgeHours,
-    cleanupWorktrees: limits?.cleanupWorktrees ?? LIMITS_DEFAULTS.cleanupWorktrees,
-    permissionTimeoutSeconds: limits?.permissionTimeoutSeconds ?? LIMITS_DEFAULTS.permissionTimeoutSeconds,
-    flushDelayMs: limits?.flushDelayMs ?? LIMITS_DEFAULTS.flushDelayMs,
-    maxRoutines: limits?.maxRoutines ?? LIMITS_DEFAULTS.maxRoutines,
-    maxWatches: limits?.maxWatches ?? LIMITS_DEFAULTS.maxWatches,
-    watchCooldownMinutes: limits?.watchCooldownMinutes ?? LIMITS_DEFAULTS.watchCooldownMinutes,
-    watchDailyCap: limits?.watchDailyCap ?? LIMITS_DEFAULTS.watchDailyCap
-  };
+function managedMcpConfigPath(platform = process.platform) {
+  return MANAGED_MCP_CONFIG_PATHS[platform] ?? null;
 }
-function resolvePermissionMode(opts) {
-  if (opts.permissionMode)
-    return opts.permissionMode;
-  if (opts.skipPermissions === true)
-    return "bypass";
-  if (opts.skipPermissions === false)
-    return "default";
-  return "default";
+function managedMcpConfigPresent(platform = process.platform, exists = existsSync) {
+  const path = managedMcpConfigPath(platform);
+  return path !== null && exists(path);
 }
-var MODE_INFO = {
-  default: {
-    icon: "\uD83D\uDD10",
-    label: "Default",
-    description: "Every tool-use prompts for approval."
-  },
-  auto: {
-    icon: "⚡",
-    label: "Auto",
-    description: "Claude classifier auto-approves low-risk tools; high-risk still prompts."
-  },
-  bypass: {
-    icon: "⚠️",
-    label: "Bypass",
-    description: "No prompts — every tool-use is allowed."
+// src/config/mcp-posture.ts
+init_types();
+function resolvePlatformMcpPosture(platforms, globalMcpServers, managedPresent = () => managedMcpConfigPresent()) {
+  const warnings = [];
+  for (const p of platforms) {
+    p.mcpServers = resolveMcpServers(globalMcpServers, p.mcpServers, `platforms[${p.id}].mcpServers`);
+    p.strictMcpConfig = resolveStrictMcpConfig(p.strictMcpConfig, `platforms[${p.id}].strictMcpConfig`);
+    p.claudeAiConnectors = resolveClaudeAiConnectors(p.claudeAiConnectors, `platforms[${p.id}].claudeAiConnectors`);
+    if (p.strictMcpConfig && managedPresent()) {
+      warnings.push(`platforms[${p.id}].strictMcpConfig ignored: an enterprise managed MCP config is present ` + `(${managedMcpConfigPath() ?? "managed-mcp.json"}) and the Claude CLI refuses --strict-mcp-config alongside it.`);
+      p.strictMcpConfig = false;
+    }
   }
-};
-function permissionModeDisplay(mode) {
-  const info = MODE_INFO[mode];
-  return { icon: info.icon, label: info.label, chip: `${info.icon} ${info.label}` };
-}
-function permissionModeDescription(mode) {
-  return MODE_INFO[mode].description;
-}
-function effectivePermissionMode(input) {
-  if (input.override)
-    return input.override;
-  if (input.sessionHasInteractiveOverride)
-    return "default";
-  return input.botWideMode;
+  return { warnings };
 }
 
 // src/config/index.ts
 var CONFIG_PATH = resolve(homedir2(), ".config", "claude-threads", "config.yaml");
 function loadConfigWithMigration() {
-  if (existsSync(CONFIG_PATH)) {
+  if (existsSync2(CONFIG_PATH)) {
     const content = readFileSync(CONFIG_PATH, "utf-8");
     return yaml.load(content);
   }
@@ -49765,7 +50564,7 @@ function loadConfigWithMigration() {
 }
 function saveConfig(config, path = CONFIG_PATH) {
   const configDir = dirname(path);
-  if (!existsSync(configDir)) {
+  if (!existsSync2(configDir)) {
     mkdirSync2(configDir, { recursive: true, mode: 448 });
   }
   const yamlContent = yaml.dump(config, {
@@ -49781,7 +50580,7 @@ function saveConfig(config, path = CONFIG_PATH) {
   } catch {}
 }
 function configExists() {
-  return existsSync(CONFIG_PATH);
+  return existsSync2(CONFIG_PATH);
 }
 
 // src/session/authorization.ts
@@ -49909,664 +50708,12 @@ class DecisionBridgeServer {
   }
 }
 
-// src/claude/cli.ts
-init_spawn();
-init_logger();
-init_version_check();
-import { EventEmitter } from "events";
-import { resolve as resolve2, dirname as dirname2 } from "path";
-import { fileURLToPath } from "url";
-import { existsSync as existsSync3, readFileSync as readFileSync2, watchFile, unwatchFile, unlinkSync, statSync, readdirSync, writeFileSync as writeFileSync2 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join4 } from "path";
-
-// src/mcp/outbound-env.ts
-var OUTBOUND_ENV = {
-  SESSION_WORKING_DIR: "SESSION_WORKING_DIR",
-  SESSION_UPLOAD_DIR: "SESSION_UPLOAD_DIR",
-  OUTBOUND_FILES_ENABLED: "OUTBOUND_FILES_ENABLED",
-  OUTBOUND_FILES_MAX_BYTES: "OUTBOUND_FILES_MAX_BYTES"
-};
-
-// src/mcp/agent-features-env.ts
-var AGENT_FEATURES_ENV = {
-  MEMORY_CHANNEL_ENABLED: "CT_MEMORY_CHANNEL_ENABLED",
-  ROUTINES_ENABLED: "CT_ROUTINES_ENABLED",
-  WATCHES_ENABLED: "CT_WATCHES_ENABLED",
-  UNATTENDED: "CT_UNATTENDED",
-  DCM: "CT_DCM"
-};
-
-// src/claude/rate-limit-detector.ts
-var RATE_LIMIT_PHRASES = [
-  /usage limit reached/i,
-  /rate[_\s-]?limit[_\s-]?error/i,
-  /you have hit the rate limit/i,
-  /quota (has been )?exceeded/i,
-  /\b429\b.*(rate|limit|quota)/i
-];
-var DEFAULT_COOLDOWN_MS = 60 * 60 * 1000;
-function detectRateLimit(text, now = Date.now()) {
-  if (!text)
-    return { detected: false };
-  let matched;
-  for (const phrase of RATE_LIMIT_PHRASES) {
-    const m = text.match(phrase);
-    if (m) {
-      matched = m[0];
-      break;
-    }
-  }
-  if (!matched)
-    return { detected: false };
-  const resetAtEpochMs = extractResetAt(text, now);
-  return { detected: true, matched, resetAtEpochMs };
-}
-function cooldownDeadline(hit, now = Date.now()) {
-  if (!hit.detected)
-    return now;
-  return hit.resetAtEpochMs ?? now + DEFAULT_COOLDOWN_MS;
-}
-function extractResetAt(text, now) {
-  const relative = text.match(/(?:retry[_\s-]?after|resets?\s+in)\s+(\d+)\s*(second|minute|hour|day)s?/i);
-  if (relative) {
-    const value = parseInt(relative[1], 10);
-    const unit = relative[2].toLowerCase();
-    const unitMs = {
-      second: 1000,
-      minute: 60000,
-      hour: 3600000,
-      day: 86400000
-    };
-    return now + value * unitMs[unit];
-  }
-  const unix = text.match(/\breset(?:_at)?\b\s*["']?\s*[:=]\s*(\d{10,13})/);
-  if (unix) {
-    const raw = parseInt(unix[1], 10);
-    return unix[1].length === 13 ? raw : raw * 1000;
-  }
-  const clock = text.match(/resets?\s+at\s+(\d{1,2}):(\d{2})\s*(utc|gmt)?/i);
-  if (clock) {
-    const hh = parseInt(clock[1], 10);
-    const mm = parseInt(clock[2], 10);
-    if (hh < 24 && mm < 60) {
-      const reference = new Date(now);
-      const target = new Date(Date.UTC(reference.getUTCFullYear(), reference.getUTCMonth(), reference.getUTCDate(), hh, mm)).getTime();
-      return target > now ? target : target + 86400000;
-    }
-  }
-  return;
-}
-function parseRateLimitEvent(event, now = Date.now()) {
-  const info = event?.rate_limit_info;
-  if (!info || typeof info !== "object")
-    return { detected: false };
-  const { status, resetsAt } = info;
-  if (status !== "rejected")
-    return { detected: false };
-  const PAST_SKEW_TOLERANCE_MS = 2 * 60000;
-  let resetAtEpochMs;
-  if (typeof resetsAt === "number") {
-    const ms = resetsAt * 1000;
-    if (ms > now && ms - now < 8 * 86400000) {
-      resetAtEpochMs = ms;
-    } else if (ms <= now && now - ms < PAST_SKEW_TOLERANCE_MS) {
-      resetAtEpochMs = now + 60000;
-    }
-  }
-  return { detected: true, matched: `rate_limit_event status=${status}`, resetAtEpochMs };
-}
-
-// src/claude/cli.ts
-var log3 = createLogger("claude");
-function cleanupBrowserBridgeSockets() {
-  try {
-    const tempDir = tmpdir2();
-    const files = readdirSync(tempDir);
-    for (const file of files) {
-      if (file.startsWith("claude-mcp-browser-bridge-")) {
-        const filePath = join4(tempDir, file);
-        try {
-          const stats = statSync(filePath);
-          if (stats.isSocket()) {
-            unlinkSync(filePath);
-            log3.debug(`Removed stale browser bridge socket: ${file}`);
-          }
-        } catch {}
-      }
-    }
-  } catch (err) {
-    log3.debug(`Browser bridge cleanup failed: ${err}`);
-  }
-}
-function buildClaudeChildEnv(parentEnv, account, opts) {
-  const env = { ...parentEnv };
-  if (env.MCP_CONNECTION_NONBLOCKING === undefined) {
-    env.MCP_CONNECTION_NONBLOCKING = "true";
-  }
-  if (env.ENABLE_PROMPT_CACHING_1H === undefined) {
-    env.ENABLE_PROMPT_CACHING_1H = "true";
-  }
-  if (opts?.disableAutoMemory) {
-    env.CLAUDE_CODE_DISABLE_AUTO_MEMORY = "1";
-  }
-  if (opts?.decisionBridge && env.MCP_TOOL_TIMEOUT === undefined) {
-    env.MCP_TOOL_TIMEOUT = "3600000";
-  }
-  if (account?.home) {
-    env.HOME = account.home;
-    env.USERPROFILE = account.home;
-    delete env.ANTHROPIC_API_KEY;
-    delete env.CLAUDE_CODE_OAUTH_TOKEN;
-    delete env.ANTHROPIC_AUTH_TOKEN;
-    delete env.CLAUDE_CONFIG_DIR;
-    delete env.CLAUDE_SECURESTORAGE_CONFIG_DIR;
-  } else if (account?.apiKey) {
-    env.ANTHROPIC_API_KEY = account.apiKey;
-    delete env.CLAUDE_CODE_OAUTH_TOKEN;
-    delete env.ANTHROPIC_AUTH_TOKEN;
-  }
-  return env;
-}
-function buildInlineSettings(statusLineCommand, memory) {
-  const settings = {};
-  if (statusLineCommand) {
-    settings.statusLine = {
-      type: "command",
-      command: statusLineCommand,
-      padding: 0
-    };
-  }
-  if (memory) {
-    settings.autoMemoryEnabled = true;
-    settings.autoMemoryDirectory = memory.autoMemoryDir;
-  }
-  return Object.keys(settings).length > 0 ? settings : null;
-}
-function runtimeForScriptPath(scriptPath) {
-  return scriptPath.endsWith(".ts") ? process.execPath : "node";
-}
-function isErrorResultEvent(event) {
-  const ev = event;
-  if (typeof ev.subtype === "string" && ev.subtype.startsWith("error"))
-    return true;
-  if (ev.is_error === true)
-    return true;
-  return false;
-}
-function materializeMcpConfig(config, sessionId, opts = {}) {
-  if (opts.inline) {
-    return { mode: "inline", value: JSON.stringify(config) };
-  }
-  const dir = opts.tmpDirOverride ?? tmpdir2();
-  const path = join4(dir, `claude-threads-mcp-${sessionId ?? process.pid}-${Date.now()}.json`);
-  writeFileSync2(path, JSON.stringify(config), { mode: 384 });
-  return { mode: "file", path };
-}
-function buildPermissionArgs(opts) {
-  const args = [];
-  if (opts.permissionMode === "bypass" && !opts.platformConfig) {
-    args.push("--dangerously-skip-permissions");
-    return { args, tempFile: null };
-  }
-  if (!opts.platformConfig) {
-    throw new Error(`platformConfig is required when permissionMode is '${opts.permissionMode}'`);
-  }
-  const mcpEnv = {
-    PLATFORM_TYPE: opts.platformConfig.type,
-    PLATFORM_URL: opts.platformConfig.url,
-    PLATFORM_TOKEN: opts.platformConfig.token,
-    PLATFORM_CHANNEL_ID: opts.platformConfig.channelId,
-    PLATFORM_THREAD_ID: opts.threadId || "",
-    ALLOWED_USERS: opts.platformConfig.allowedUsers.join(","),
-    DEBUG: opts.debug ? "1" : "",
-    PERMISSION_TIMEOUT_MS: String(opts.permissionTimeoutMs),
-    SESSION_OWNER_USERNAME: opts.sessionOwnerUsername || ""
-  };
-  if (opts.decisionBridgePath) {
-    mcpEnv.DECISION_BRIDGE_PATH = opts.decisionBridgePath;
-    if (process.env.DECISION_BRIDGE_TIMEOUT_MS) {
-      mcpEnv.DECISION_BRIDGE_TIMEOUT_MS = process.env.DECISION_BRIDGE_TIMEOUT_MS;
-    }
-    const features = opts.agentFeatures;
-    if (features) {
-      if (features.memoryChannel)
-        mcpEnv[AGENT_FEATURES_ENV.MEMORY_CHANNEL_ENABLED] = "1";
-      if (features.routines)
-        mcpEnv[AGENT_FEATURES_ENV.ROUTINES_ENABLED] = "1";
-      if (features.watches)
-        mcpEnv[AGENT_FEATURES_ENV.WATCHES_ENABLED] = "1";
-      if (features.unattended)
-        mcpEnv[AGENT_FEATURES_ENV.UNATTENDED] = "1";
-      if (features.dcm)
-        mcpEnv[AGENT_FEATURES_ENV.DCM] = "1";
-    }
-  }
-  if (opts.platformConfig.appToken) {
-    mcpEnv.PLATFORM_APP_TOKEN = opts.platformConfig.appToken;
-  }
-  if (opts.workingDir) {
-    mcpEnv[OUTBOUND_ENV.SESSION_WORKING_DIR] = opts.workingDir;
-  }
-  if (opts.uploadDir) {
-    mcpEnv[OUTBOUND_ENV.SESSION_UPLOAD_DIR] = opts.uploadDir;
-  }
-  if (opts.outboundFiles?.enabled === false) {
-    mcpEnv[OUTBOUND_ENV.OUTBOUND_FILES_ENABLED] = "0";
-  }
-  if (typeof opts.outboundFiles?.maxBytes === "number" && Number.isFinite(opts.outboundFiles.maxBytes) && opts.outboundFiles.maxBytes > 0) {
-    mcpEnv[OUTBOUND_ENV.OUTBOUND_FILES_MAX_BYTES] = String(opts.outboundFiles.maxBytes);
-  }
-  const mcpConfig = {
-    mcpServers: {
-      "claude-threads-mcp": {
-        type: "stdio",
-        command: runtimeForScriptPath(opts.mcpServerPath),
-        args: [opts.mcpServerPath],
-        env: mcpEnv
-      }
-    }
-  };
-  const materialized = materializeMcpConfig(mcpConfig, opts.sessionId, { inline: opts.inline });
-  let tempFile = null;
-  if (materialized.mode === "file") {
-    tempFile = materialized.path;
-    args.push("--mcp-config", materialized.path);
-  } else {
-    args.push("--mcp-config", materialized.value);
-  }
-  if (opts.permissionMode === "bypass") {
-    args.push("--dangerously-skip-permissions");
-  } else {
-    args.push("--permission-prompt-tool", "mcp__claude-threads-mcp__permission_prompt");
-    if (opts.permissionMode === "auto") {
-      args.push("--permission-mode", "auto");
-    }
-  }
-  return { args, tempFile };
-}
-var STDERR_PER_INSTANCE_CAP = 10240;
-var STDERR_AGGREGATE_SOFT_CAP = 10 * 1024 * 1024;
-var totalStderrBytes = 0;
-
-class ClaudeCli extends EventEmitter {
-  process = null;
-  options;
-  buffer = "";
-  debug = process.env.DEBUG === "1" || process.argv.includes("--debug");
-  statusFilePath = null;
-  lastStatusData = null;
-  stderrBuffer = "";
-  mcpConfigTempFile = null;
-  lastEmittedRateLimitDeadline = 0;
-  lastEmittedHitHadExplicitReset = false;
-  log;
-  constructor(options) {
-    super();
-    this.options = options;
-    this.log = options.logSessionId ? createLogger("claude").forSession(options.logSessionId) : createLogger("claude");
-  }
-  getStatusFilePath() {
-    return this.statusFilePath;
-  }
-  getStatusData() {
-    if (!this.statusFilePath)
-      return null;
-    try {
-      if (existsSync3(this.statusFilePath)) {
-        const data = readFileSync2(this.statusFilePath, "utf8");
-        this.lastStatusData = JSON.parse(data);
-      }
-    } catch (err) {
-      this.log.debug(`Failed to read status file: ${err}`);
-    }
-    return this.lastStatusData;
-  }
-  startStatusWatch() {
-    if (!this.statusFilePath) {
-      this.log.debug("No status file path, skipping status watch");
-      return;
-    }
-    this.log.debug(`Starting status watch: ${this.statusFilePath}`);
-    const checkStatus = () => {
-      const data = this.getStatusData();
-      if (data && data.timestamp !== this.lastStatusData?.timestamp) {
-        this.lastStatusData = data;
-        this.emit("status", data);
-      }
-    };
-    watchFile(this.statusFilePath, { interval: 1000 }, checkStatus);
-  }
-  stopStatusWatch() {
-    if (this.statusFilePath) {
-      unwatchFile(this.statusFilePath);
-      try {
-        if (existsSync3(this.statusFilePath)) {
-          unlinkSync(this.statusFilePath);
-        }
-      } catch {}
-    }
-  }
-  start() {
-    if (this.process)
-      throw new Error("Already running");
-    totalStderrBytes -= this.stderrBuffer.length;
-    this.stderrBuffer = "";
-    this.lastEmittedRateLimitDeadline = 0;
-    this.lastEmittedHitHadExplicitReset = false;
-    cleanupBrowserBridgeSockets();
-    const claudePath = getClaudePath();
-    const args = [
-      "--input-format",
-      "stream-json",
-      "--output-format",
-      "stream-json",
-      "--verbose"
-    ];
-    if (this.options.sessionId) {
-      if (this.options.resume) {
-        args.push("--resume", this.options.sessionId);
-      } else {
-        args.push("--session-id", this.options.sessionId);
-      }
-    }
-    const permissionMode = this.options.permissionMode ?? "default";
-    const permResult = buildPermissionArgs({
-      permissionMode,
-      mcpServerPath: this.getMcpServerPath(),
-      platformConfig: this.options.platformConfig,
-      threadId: this.options.threadId,
-      sessionId: this.options.sessionId,
-      permissionTimeoutMs: this.options.permissionTimeoutMs ?? 120000,
-      debug: this.debug,
-      workingDir: this.options.workingDir,
-      uploadDir: this.options.uploadDir,
-      outboundFiles: this.options.outboundFiles,
-      sessionOwnerUsername: this.options.sessionOwnerUsername,
-      decisionBridgePath: this.options.decisionBridgePath,
-      agentFeatures: this.options.agentFeatures
-    });
-    args.push(...permResult.args);
-    this.mcpConfigTempFile = permResult.tempFile;
-    if (this.options.chrome) {
-      args.push("--chrome");
-    }
-    if (this.options.appendSystemPrompt) {
-      args.push("--append-system-prompt", this.options.appendSystemPrompt);
-    }
-    let statusLineCommand;
-    if (this.options.sessionId) {
-      this.statusFilePath = join4(tmpdir2(), `claude-threads-status-${this.options.sessionId}.json`);
-      const statusLineWriterPath = this.getStatusLineWriterPath();
-      const runtime = runtimeForScriptPath(statusLineWriterPath);
-      statusLineCommand = `${runtime} ${statusLineWriterPath} ${this.options.sessionId}`;
-    }
-    const settings = buildInlineSettings(statusLineCommand, this.options.memory);
-    if (settings) {
-      args.push("--settings", JSON.stringify(settings));
-    }
-    this.log.debug(`Starting: ${claudePath} ${args.slice(0, 5).join(" ")}...`);
-    const childEnv = this.buildChildEnv();
-    if (this.options.account) {
-      this.log.debug(`Spawning under Claude account "${this.options.account.id}"`);
-    }
-    this.process = crossSpawn(claudePath, args, {
-      cwd: this.options.workingDir,
-      env: childEnv,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    this.log.debug(`Claude process spawned: pid=${this.process.pid}`);
-    this.process.stdout?.on("data", (chunk) => {
-      this.parseOutput(chunk.toString());
-    });
-    this.process.stderr?.on("data", (chunk) => {
-      const text = chunk.toString();
-      const before = this.stderrBuffer.length;
-      this.stderrBuffer += text;
-      const cap = totalStderrBytes > STDERR_AGGREGATE_SOFT_CAP ? 1024 : STDERR_PER_INSTANCE_CAP;
-      if (this.stderrBuffer.length > cap) {
-        this.stderrBuffer = this.stderrBuffer.slice(-cap);
-      }
-      totalStderrBytes += this.stderrBuffer.length - before;
-      this.log.debug(`stderr: ${text.trim()}`);
-      if (process.env.INTEGRATION_TEST === "1") {
-        process.stderr.write(text);
-      }
-      this.maybeEmitRateLimit(text);
-    });
-    this.process.on("error", (err) => {
-      this.log.error(`Claude error: ${err}`);
-      this.emit("error", err);
-    });
-    this.process.on("exit", (code) => {
-      this.log.debug(`Exited ${code}`);
-      this.process = null;
-      this.buffer = "";
-      totalStderrBytes -= this.stderrBuffer.length;
-      if (this.mcpConfigTempFile) {
-        const path = this.mcpConfigTempFile;
-        this.mcpConfigTempFile = null;
-        try {
-          unlinkSync(path);
-        } catch {}
-      }
-      this.emit("exit", code);
-    });
-  }
-  sendMessage(content) {
-    if (!this.process?.stdin)
-      throw new Error("Not running");
-    const msg = JSON.stringify({
-      type: "user",
-      message: { role: "user", content }
-    }) + `
-`;
-    const preview = content.substring(0, 50);
-    this.log.debug(`Sending: ${preview}...`);
-    if (process.env.INTEGRATION_TEST === "1") {
-      const stack = new Error().stack?.split(`
-`).slice(2, 6).join(" > ").replace(/\s+at\s+/g, " < ") ?? "?";
-      process.stderr.write(`[claude-cli sendMessage pid=${this.process.pid}] ${preview} | ${stack}
-`);
-    }
-    this.process.stdin.write(msg);
-  }
-  sendToolResult(toolUseId, content) {
-    if (!this.process?.stdin)
-      throw new Error("Not running");
-    const msg = JSON.stringify({
-      type: "user",
-      message: {
-        role: "user",
-        content: [{
-          type: "tool_result",
-          tool_use_id: toolUseId,
-          content: typeof content === "string" ? content : JSON.stringify(content)
-        }]
-      }
-    }) + `
-`;
-    this.log.debug(`Sending tool_result for ${toolUseId}`);
-    this.process.stdin.write(msg);
-  }
-  parseOutput(data) {
-    this.buffer += data;
-    const lines = this.buffer.split(`
-`);
-    this.buffer = lines.pop() || "";
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed)
-        continue;
-      let event;
-      try {
-        event = JSON.parse(trimmed);
-      } catch {
-        continue;
-      }
-      try {
-        this.emit("event", event);
-      } catch (err) {
-        this.log.error(`'event' listener threw while handling a ${event.type} event: ${err}`);
-      }
-      if (event.type === "result" && isErrorResultEvent(event)) {
-        this.maybeEmitRateLimit(trimmed);
-      }
-      if (event.type === "rate_limit_event") {
-        this.maybeEmitRateLimitHit(parseRateLimitEvent(event));
-      }
-    }
-  }
-  maybeEmitRateLimit(text) {
-    this.maybeEmitRateLimitHit(detectRateLimit(text));
-  }
-  maybeEmitRateLimitHit(hit) {
-    if (!hit.detected)
-      return;
-    if (!hit.resetAtEpochMs && this.lastEmittedHitHadExplicitReset && this.lastEmittedRateLimitDeadline > Date.now()) {
-      return;
-    }
-    const newDeadline = cooldownDeadline(hit);
-    const MIN_ADVANCE_MS = 60000;
-    if (newDeadline - this.lastEmittedRateLimitDeadline < MIN_ADVANCE_MS) {
-      if (hit.resetAtEpochMs !== undefined) {
-        this.lastEmittedHitHadExplicitReset = true;
-      }
-      return;
-    }
-    this.lastEmittedRateLimitDeadline = newDeadline;
-    this.lastEmittedHitHadExplicitReset = hit.resetAtEpochMs !== undefined;
-    this.log.warn(`Rate limit detected: ${hit.matched ?? "(no match text)"}`);
-    this.emit("rate-limit", hit);
-  }
-  isRunning() {
-    return this.process !== null;
-  }
-  getLastStderr() {
-    return this.stderrBuffer;
-  }
-  isPermanentFailure() {
-    const stderr = this.stderrBuffer;
-    if (stderr.includes("claude-mcp-browser-bridge") && (stderr.includes("EOPNOTSUPP") || stderr.includes("ENOENT"))) {
-      return true;
-    }
-    if (stderr.includes("No conversation found with session ID")) {
-      return true;
-    }
-    return false;
-  }
-  getPermanentFailureReason() {
-    const stderr = this.stderrBuffer;
-    if (stderr.includes("claude-mcp-browser-bridge") && (stderr.includes("EOPNOTSUPP") || stderr.includes("ENOENT"))) {
-      return "Claude browser bridge state from a previous session is no longer accessible. This typically happens when a session with Chrome integration is resumed after a restart.";
-    }
-    if (stderr.includes("No conversation found with session ID")) {
-      return "The conversation history for this session no longer exists. This can happen if Claude's history was cleared or if the session was created on a different machine.";
-    }
-    return null;
-  }
-  kill() {
-    this.stopStatusWatch();
-    if (!this.process) {
-      this.log.debug("Kill called but process not running");
-      return Promise.resolve();
-    }
-    const proc = this.process;
-    const pid = proc.pid;
-    this.process = null;
-    this.log.debug(`Killing Claude process (pid=${pid})`);
-    if (process.env.INTEGRATION_TEST === "1") {
-      const stack = new Error().stack?.split(`
-`).slice(2, 7).join(" > ").replace(/\s+at\s+/g, " < ") ?? "?";
-      process.stderr.write(`[claude-cli kill pid=${pid}] | ${stack}
-`);
-    }
-    return new Promise((resolve3) => {
-      this.log.debug("Sending first SIGINT");
-      proc.kill("SIGINT");
-      const secondSigint = setTimeout(() => {
-        try {
-          this.log.debug("Sending second SIGINT");
-          proc.kill("SIGINT");
-        } catch {}
-      }, 100);
-      const forceKillTimeout = setTimeout(() => {
-        try {
-          this.log.debug("Sending SIGTERM (force kill)");
-          proc.kill("SIGTERM");
-        } catch {}
-      }, 2000);
-      const settle = (reason) => {
-        this.log.debug(`Claude process gone (${reason})`);
-        clearTimeout(secondSigint);
-        clearTimeout(forceKillTimeout);
-        clearTimeout(lastResort);
-        resolve3();
-      };
-      const lastResort = setTimeout(() => {
-        try {
-          this.log.warn("Claude process did not exit after SIGTERM — sending SIGKILL");
-          proc.kill("SIGKILL");
-        } catch {}
-        settle("kill timeout");
-      }, 5000);
-      proc.once("close", (code) => settle(`closed, code=${code}`));
-      proc.once("error", () => settle("spawn error"));
-    });
-  }
-  interrupt() {
-    if (!this.process) {
-      this.log.debug("Interrupt called but process not running");
-      return false;
-    }
-    this.log.debug(`Interrupting Claude process (pid=${this.process.pid})`);
-    this.process.kill("SIGINT");
-    return true;
-  }
-  buildChildEnv() {
-    return buildClaudeChildEnv(process.env, this.options.account, {
-      decisionBridge: this.options.decisionBridgePath !== undefined,
-      disableAutoMemory: this.options.memory === null
-    });
-  }
-  getMcpServerPath() {
-    const __filename2 = fileURLToPath(import.meta.url);
-    const __dirname2 = dirname2(__filename2);
-    const bundledPath = resolve2(__dirname2, "mcp", "mcp-server.js");
-    if (existsSync3(bundledPath)) {
-      return bundledPath;
-    }
-    const sourceLayoutPath = resolve2(__dirname2, "..", "mcp", "mcp-server.js");
-    if (existsSync3(sourceLayoutPath)) {
-      return sourceLayoutPath;
-    }
-    const tsPath = resolve2(__dirname2, "..", "mcp", "mcp-server.ts");
-    if (existsSync3(tsPath)) {
-      return tsPath;
-    }
-    return sourceLayoutPath;
-  }
-  getStatusLineWriterPath() {
-    const __filename2 = fileURLToPath(import.meta.url);
-    const __dirname2 = dirname2(__filename2);
-    const bundledPath = resolve2(__dirname2, "statusline", "writer.js");
-    if (existsSync3(bundledPath)) {
-      return bundledPath;
-    }
-    const sourceLayoutPath = resolve2(__dirname2, "..", "statusline", "writer.js");
-    if (existsSync3(sourceLayoutPath)) {
-      return sourceLayoutPath;
-    }
-    const tsPath = resolve2(__dirname2, "..", "statusline", "writer.ts");
-    if (existsSync3(tsPath)) {
-      return tsPath;
-    }
-    return sourceLayoutPath;
-  }
-}
+// src/session/lifecycle.ts
+init_cli();
+init_rate_limit_detector();
 
 // src/persistence/session-store.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3 } from "fs";
 
 // src/persistence/atomic-file.ts
 import { chmodSync as chmodSync3, renameSync, writeFileSync as writeFileSync3 } from "fs";
@@ -50641,13 +50788,13 @@ class SessionStore {
       this.sessionsFile = DEFAULT_SESSIONS_FILE;
       this.configDir = DEFAULT_CONFIG_DIR;
     }
-    if (!existsSync4(this.configDir)) {
+    if (!existsSync5(this.configDir)) {
       mkdirSync3(this.configDir, { recursive: true });
     }
   }
   load() {
     const sessions = new Map;
-    if (!existsSync4(this.sessionsFile)) {
+    if (!existsSync5(this.sessionsFile)) {
       log4.debug("No sessions file found");
       return sessions;
     }
@@ -50858,7 +51005,7 @@ class SessionStore {
   }
   lastReadDegraded = false;
   loadRaw() {
-    if (!existsSync4(this.sessionsFile)) {
+    if (!existsSync5(this.sessionsFile)) {
       this.lastReadDegraded = false;
       return { version: STORE_VERSION, sessions: {} };
     }
@@ -50903,7 +51050,7 @@ class SessionStore {
 
 // src/persistence/thread-logger.ts
 init_logger();
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, appendFileSync, readdirSync as readdirSync2, statSync as statSync2, unlinkSync as unlinkSync2, rmdirSync, readFileSync as readFileSync4, chmodSync as chmodSync4 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, appendFileSync, readdirSync as readdirSync2, statSync as statSync2, unlinkSync as unlinkSync2, rmdirSync, readFileSync as readFileSync4, chmodSync as chmodSync4 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join6, dirname as dirname3 } from "path";
 var log5 = createLogger("thread-log");
@@ -50930,7 +51077,7 @@ class ThreadLoggerImpl {
     this.logPath = join6(LOGS_BASE_DIR, platformId, `${claudeSessionId}.jsonl`);
     if (this.enabled) {
       const dir = dirname3(this.logPath);
-      if (!existsSync5(dir)) {
+      if (!existsSync6(dir)) {
         mkdirSync4(dir, { recursive: true });
       }
       this.flushTimer = setInterval(() => {
@@ -51065,7 +51212,7 @@ class ThreadLoggerImpl {
       const lines = this.buffer.map((entry) => JSON.stringify(entry)).join(`
 `) + `
 `;
-      const isNewFile = !existsSync5(this.logPath);
+      const isNewFile = !existsSync6(this.logPath);
       appendFileSync(this.logPath, lines, { encoding: "utf8", mode: 384 });
       if (isNewFile) {
         chmodSync4(this.logPath, 384);
@@ -51103,7 +51250,7 @@ function createThreadLogger(platformId, threadId, claudeSessionId, options) {
 function cleanupOldLogs(retentionDays = 30) {
   const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
   let deletedCount = 0;
-  if (!existsSync5(LOGS_BASE_DIR)) {
+  if (!existsSync6(LOGS_BASE_DIR)) {
     return 0;
   }
   try {
@@ -51151,7 +51298,7 @@ function getLogFilePath(platformId, sessionId) {
 function readRecentLogEntries(platformId, sessionId, maxLines = 50) {
   const logPath = getLogFilePath(platformId, sessionId);
   log5.debug(`Reading log entries from: ${logPath}`);
-  if (!existsSync5(logPath)) {
+  if (!existsSync6(logPath)) {
     log5.debug(`Log file does not exist: ${logPath}`);
     return [];
   }
@@ -51178,7 +51325,7 @@ function readRecentLogEntries(platformId, sessionId, maxLines = 50) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync7 } from "fs";
 import { dirname as dirname4, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __dirname2 = dirname4(fileURLToPath2(import.meta.url));
@@ -51189,7 +51336,7 @@ function loadPackageJson() {
     resolve3(process.cwd(), "package.json")
   ];
   for (const candidate of candidates) {
-    if (existsSync6(candidate)) {
+    if (existsSync7(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync5(candidate, "utf-8"));
         if (pkg.name === "claude-threads") {
@@ -51639,7 +51786,7 @@ ${formatter.formatBold("Reactions:")}
 }
 
 // src/changelog.ts
-import { readFileSync as readFileSync6, existsSync as existsSync7 } from "fs";
+import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
 import { dirname as dirname5, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __dirname3 = dirname5(fileURLToPath3(import.meta.url));
@@ -51650,7 +51797,7 @@ function getReleaseNotes(version) {
   ];
   let changelogPath = null;
   for (const p of possiblePaths) {
-    if (existsSync7(p)) {
+    if (existsSync8(p)) {
       changelogPath = p;
       break;
     }
@@ -52345,7 +52492,7 @@ ${avoidCommands.map((c) => `- \`!${c.command}\` - ${c.reason}`).join(`
 }
 // src/session/lifecycle.ts
 import { randomUUID as randomUUID7 } from "crypto";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 
 // src/utils/keep-alive.ts
 init_logger();
@@ -52800,6 +52947,9 @@ function updateLastMessage(session, post2) {
   }
 }
 
+// src/operations/commands/handler.ts
+init_cli();
+
 // src/operations/streaming/handler.ts
 import { lstat, mkdir as mkdir2, mkdtemp, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
@@ -53146,7 +53296,7 @@ function buildRestartCliOptions(session, ctx) {
 // src/operations/commands/handler.ts
 import { randomUUID as randomUUID6 } from "crypto";
 import { resolve as resolve6 } from "path";
-import { existsSync as existsSync11, statSync as statSync4 } from "fs";
+import { existsSync as existsSync12, statSync as statSync4 } from "fs";
 
 // node_modules/update-notifier/update-notifier.js
 import process10 from "node:process";
@@ -62129,6 +62279,10 @@ async function buildStatusBar(sessionCount, config, formatter, platformId) {
     }
     items.push(formatter.formatCode(label));
   }
+  if (config.connectorsOff && config.connectorsOff > 0) {
+    const n = config.connectorsOff;
+    items.push(formatter.formatCode(`\uD83D\uDD0C ${n} claude.ai connector${n === 1 ? "" : "s"} off`));
+  }
   items.push(formatter.formatCode(permissionModeDisplay(config.permissionMode).chip));
   if (config.worktreeMode === "require") {
     items.push(formatter.formatCode("\uD83C\uDF3F Worktree: require"));
@@ -62537,7 +62691,7 @@ async function cleanupOldStickyMessages(platform, botUserId, forceRun = false, e
 // src/memory/store.ts
 import { createHash } from "crypto";
 import {
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync5,
   readFileSync as readFileSync7,
   realpathSync
@@ -62749,7 +62903,7 @@ _(older entries omitted — \`!memory\` shows all)_` : rendered;
   }
   loadLines(platformId) {
     const file = this.channelMemoryPath(platformId);
-    if (!existsSync8(file))
+    if (!existsSync9(file))
       return [];
     const raw = readFileSync7(file, "utf-8");
     const lines = [];
@@ -62791,7 +62945,7 @@ _(older entries omitted — \`!memory\` shows all)_` : rendered;
     writeFileAtomic(file, content);
   }
   ensureDir(dir) {
-    if (!existsSync8(dir)) {
+    if (!existsSync9(dir)) {
       mkdirSync5(dir, { recursive: true, mode: 448 });
     }
   }
@@ -62938,7 +63092,7 @@ import { join as join12 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 
 // src/persistence/platform-list-store.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync8, statSync as statSync3 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync8, statSync as statSync3 } from "fs";
 import { homedir as homedir7 } from "os";
 import { join as join11 } from "path";
 var STORES_CONFIG_DIR = join11(homedir7(), ".config", "claude-threads");
@@ -63015,7 +63169,7 @@ class PlatformListStore {
     return this.queue.run(fn);
   }
   loadRaw(forWrite = false) {
-    if (!existsSync9(this.file)) {
+    if (!existsSync10(this.file)) {
       this.cache = null;
       return { version: STORE_VERSION2, items: {} };
     }
@@ -63712,6 +63866,7 @@ async function suggestBranchNames(workingDir, userMessage) {
 
 // src/operations/worktree/handler.ts
 init_worktree();
+init_cli();
 import { randomUUID as randomUUID5 } from "crypto";
 init_logger();
 var log26 = createLogger("worktree");
@@ -64410,6 +64565,24 @@ function handleEventPreProcessing(session, event, ctx) {
   }
   if (event.type === "system") {
     const e = event;
+    if (e.subtype === "init" && Array.isArray(e.mcp_servers)) {
+      const summary = [...e.mcp_servers].sort((a, b) => (a.name ?? "").localeCompare(b.name ?? "")).map((s) => `${s.name ?? "?"} (${s.status ?? "unknown"})`).join(", ") || "none";
+      if (session.mcpServersSummary !== summary) {
+        session.mcpServersSummary = summary;
+        sessionLog6(session).info(`MCP servers: ${summary}`);
+        const down = e.mcp_servers.filter((s) => s.status !== "connected" && s.status !== "pending");
+        if (down.length > 0) {
+          sessionLog6(session).warn(`MCP servers not connected: ${down.map((s) => `${s.name ?? "?"} (${s.status ?? "unknown"})`).join(", ")}`);
+        }
+        const connectors = e.mcp_servers.filter((s) => (s.name ?? "").startsWith("claude.ai "));
+        if (connectors.length > 0 && session.platform.getMcpConfig().claudeAiConnectors !== true) {
+          const names = connectors.map((s) => s.name).join(", ");
+          sessionLog6(session).warn(`claude.ai connectors are active although claudeAiConnectors is off: ${names}. ` + `This Claude CLI ignores both disableClaudeAiConnectors and ENABLE_CLAUDEAI_MCP_SERVERS; upgrade it.`);
+          const f = session.platform.getFormatter();
+          withErrorHandling(() => post(session, "warning", `${f.formatBold("claude.ai connectors are active in this session")} (${names}) although ` + `${f.formatCode("claudeAiConnectors")} is off for this platform. This Claude CLI version ignores the ` + `switch; upgrade the CLI on the bot's machine.`), { action: "Post connector warning", session });
+        }
+      }
+    }
     if (e.subtype === "init" && typeof e.model === "string") {
       session.currentModel = e.model;
     }
@@ -65110,7 +65283,7 @@ async function suggestSessionMetadata(context) {
 init_quick_query();
 
 // src/persistence/github-emails-store.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync9 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join14 } from "path";
 init_logger();
@@ -65136,7 +65309,7 @@ class GitHubEmailsStore {
       this.file = DEFAULT_FILE3;
       this.configDir = DEFAULT_CONFIG_DIR2;
     }
-    if (!existsSync10(this.configDir)) {
+    if (!existsSync11(this.configDir)) {
       mkdirSync7(this.configDir, { recursive: true });
     }
   }
@@ -65171,7 +65344,7 @@ class GitHubEmailsStore {
   }
   lastReadDegraded = false;
   loadRaw() {
-    if (!existsSync10(this.file)) {
+    if (!existsSync11(this.file)) {
       this.lastReadDegraded = false;
       return { version: STORE_VERSION3, emails: {} };
     }
@@ -65377,7 +65550,7 @@ async function changeDirectory(session, newDir, username, ctx) {
   const expandedDir = newDir.startsWith("~") ? newDir.replace("~", process.env.HOME || "") : newDir;
   const absoluteDir = resolve6(expandedDir);
   const formatter = session.platform.getFormatter();
-  if (!existsSync11(absoluteDir)) {
+  if (!existsSync12(absoluteDir)) {
     await postError(session, `Directory does not exist: ${formatter.formatCode(newDir)}`);
     sessionLog8(session).warn(`\uD83D\uDCC2 Directory does not exist: ${newDir}`);
     return;
@@ -65727,6 +65900,16 @@ async function updateSessionHeader(session, ctx) {
     const label = account?.displayName ?? session.claudeAccountId;
     items.push(["\uD83D\uDD11", "Claude account", formatter.formatCode(label)]);
   }
+  {
+    const mcp = session.platform.getMcpConfig();
+    const posture = [];
+    if (mcp.claudeAiConnectors === true)
+      posture.push(`claude.ai connectors ${formatter.formatBold("on")}`);
+    if (mcp.strictMcpConfig === true)
+      posture.push("strict (declared servers only)");
+    if (posture.length > 0)
+      items.push(["\uD83D\uDD0C", "MCP", posture.join(", ")]);
+  }
   items.push(["\uD83C\uDD94", "Session ID", formatter.formatCode(session.claudeSessionId.substring(0, 8))]);
   const logPath = getLogFilePath(session.platform.platformId, session.claudeSessionId);
   const shortLogPath = logPath.replace(process.env.HOME || "", "~");
@@ -66907,7 +67090,7 @@ async function startSessionImpl(options, username, displayName, replyToPostId, p
     const { resolve: resolve7 } = await import("path");
     const requestedDir = initialOptions.workingDir.startsWith("~") ? initialOptions.workingDir.replace("~", process.env.HOME || "") : initialOptions.workingDir;
     const resolvedDir = resolve7(requestedDir);
-    if (!existsSync12(resolvedDir)) {
+    if (!existsSync13(resolvedDir)) {
       const msg = `❌ Directory does not exist: ${formatter.formatCode(initialOptions.workingDir)}`;
       if (startPost) {
         await platform.updatePost(startPost.id, msg);
@@ -67147,7 +67330,7 @@ async function resumeSessionImpl(state, ctx, resumedBy) {
     log37.warn(`Max sessions reached, skipping resume for ${shortId}...`);
     return;
   }
-  if (!existsSync12(state.workingDir)) {
+  if (!existsSync13(state.workingDir)) {
     log37.warn(`Working directory ${state.workingDir} no longer exists, skipping resume for ${shortId}...`);
     ctx.state.sessionStore.remove(`${state.platformId}:${state.threadId}`);
     const resumeFormatter = platform.getFormatter();
@@ -67475,7 +67658,10 @@ async function handleExit(sessionId, code, ctx, source) {
       auditReason: "early-exit"
     });
     const earlyExitFormatter = session.platform.getFormatter();
-    await withErrorHandling(() => post(session, "warning", `${earlyExitFormatter.formatBold("Session ended")} before Claude could respond (exit code ${code}). Please start a new session.`), { action: "Post early exit notification", session });
+    const lastStderr = typeof session.claude?.getLastStderr === "function" ? session.claude.getLastStderr() : "";
+    const strictRefused = lastStderr.includes("You cannot use --strict-mcp-config");
+    const earlyExitText = strictRefused ? `${earlyExitFormatter.formatBold("Session ended")} before Claude could respond: the Claude CLI refuses ${earlyExitFormatter.formatCode("--strict-mcp-config")} because an enterprise-managed MCP config is present. Set ${earlyExitFormatter.formatCode("strictMcpConfig: false")} on this platform and restart the bot.` : `${earlyExitFormatter.formatBold("Session ended")} before Claude could respond (exit code ${code}). Please start a new session.`;
+    await withErrorHandling(() => post(session, "warning", earlyExitText), { action: "Post early exit notification", session });
     sessionLog11(session).info(`⚠ Session ended early (exit code ${code})`);
     await ctx.ops.updateStickyMessage();
     return;
@@ -67841,7 +68027,7 @@ function createDmDiscoveryRuntime(deps) {
 
 // src/onboarding.ts
 var import_prompts = __toESM(require_prompts3(), 1);
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync10 } from "fs";
 import { join as join15, dirname as dirname8 } from "path";
 import { spawn as spawn3 } from "child_process";
 import { fileURLToPath as fileURLToPath6 } from "url";
@@ -68066,7 +68252,7 @@ async function runOnboarding(reconfigure = false) {
   console.log(dim("  ─────────────────────────────────"));
   console.log("");
   let existingConfig = null;
-  if (reconfigure && existsSync13(CONFIG_PATH)) {
+  if (reconfigure && existsSync14(CONFIG_PATH)) {
     try {
       const content = readFileSync10(CONFIG_PATH, "utf-8");
       existingConfig = yaml.load(content);
@@ -69520,6 +69706,9 @@ class MattermostClient extends BasePlatformClient {
   channelId;
   directMessages;
   outboundFiles;
+  mcpServers;
+  strictMcpConfig;
+  claudeAiConnectors;
   userCache = new Map;
   botUserId = null;
   formatter = new MattermostFormatter;
@@ -69535,6 +69724,9 @@ class MattermostClient extends BasePlatformClient {
     this.botName = platformConfig.botName;
     this.allowedUsers = platformConfig.allowedUsers;
     this.outboundFiles = platformConfig.outboundFiles;
+    this.mcpServers = platformConfig.mcpServers;
+    this.strictMcpConfig = platformConfig.strictMcpConfig;
+    this.claudeAiConnectors = platformConfig.claudeAiConnectors;
     this.directChannelMode = resolveDirectChannelMode(platformConfig.directChannelMode);
     this.approvals = platformConfig.approvals;
     this.ackReaction = normalizeAckReaction(platformConfig.ackReaction, `platforms[${platformConfig.id}].ackReaction`);
@@ -69978,7 +70170,10 @@ class MattermostClient extends BasePlatformClient {
       token: this.token,
       channelId: this.channelId,
       allowedUsers: this.allowedUsers,
-      outboundFiles: this.outboundFiles
+      outboundFiles: this.outboundFiles,
+      mcpServers: this.mcpServers,
+      strictMcpConfig: this.strictMcpConfig,
+      claudeAiConnectors: this.claudeAiConnectors
     };
   }
   getFormatter() {
@@ -70190,6 +70385,9 @@ class SlackClient extends BasePlatformClient {
   rateLimitDelay = 0;
   rateLimitRetryAfter = 0;
   outboundFiles;
+  mcpServers;
+  strictMcpConfig;
+  claudeAiConnectors;
   statusSentAt = new Map;
   formatter = new SlackFormatter;
   channelClients = new Map;
@@ -70208,6 +70406,9 @@ class SlackClient extends BasePlatformClient {
     this.allowedUsers = platformConfig.allowedUsers;
     this.apiUrl = platformConfig.apiUrl || "https://slack.com/api";
     this.outboundFiles = platformConfig.outboundFiles;
+    this.mcpServers = platformConfig.mcpServers;
+    this.strictMcpConfig = platformConfig.strictMcpConfig;
+    this.claudeAiConnectors = platformConfig.claudeAiConnectors;
     this.directChannelMode = resolveDirectChannelMode(platformConfig.directChannelMode);
     this.approvals = platformConfig.approvals;
     this.ackReaction = normalizeAckReaction(platformConfig.ackReaction, `platforms[${platformConfig.id}].ackReaction`);
@@ -70689,7 +70890,10 @@ class SlackClient extends BasePlatformClient {
       channelId: this.channelId,
       allowedUsers: this.allowedUsers,
       appToken: this.appToken,
-      outboundFiles: this.outboundFiles
+      outboundFiles: this.outboundFiles,
+      mcpServers: this.mcpServers,
+      strictMcpConfig: this.strictMcpConfig,
+      claudeAiConnectors: this.claudeAiConnectors
     };
   }
   getFormatter() {
@@ -72221,6 +72425,7 @@ init_logger();
 // src/claude/usage-probe.ts
 init_spawn();
 init_version_check();
+init_cli();
 init_logger();
 var log47 = createLogger("usage-probe");
 var DEFAULT_USAGE_PROBE_TIMEOUT_MS = 30000;
@@ -72474,13 +72679,91 @@ class AccountPool {
   }
 }
 
+// src/claude/connector-probe.ts
+init_spawn();
+init_version_check();
+init_cli();
+init_logger();
+var log49 = createLogger("connector-probe");
+var CONNECTOR_PREFIX = "claude.ai ";
+var DEFAULT_CONNECTOR_PROBE_TIMEOUT_MS = 15000;
+function parseConnectorNames(stdout) {
+  for (const line of stdout.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{"))
+      continue;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (event.type !== "system" || event.subtype !== "init")
+      continue;
+    return (event.mcp_servers ?? []).map((s) => s.name ?? "").filter((name) => name.startsWith(CONNECTOR_PREFIX)).map((name) => name.slice(CONNECTOR_PREFIX.length));
+  }
+  return null;
+}
+async function probeClaudeAiConnectors(account, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_CONNECTOR_PROBE_TIMEOUT_MS;
+  const label = account?.id ?? "default account";
+  const claudePath = getClaudePath();
+  const env4 = buildClaudeChildEnv(process.env, account, { claudeAiConnectors: true });
+  return new Promise((resolve7) => {
+    let settled = false;
+    let stdout = "";
+    const finish = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve7(value);
+    };
+    let child;
+    try {
+      child = crossSpawn(claudePath, ["-p", "/usage", "--output-format", "stream-json", "--verbose"], {
+        env: env4,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (err) {
+      log49.warn(`Connector probe for ${label} failed to spawn: ${err}`);
+      resolve7(null);
+      return;
+    }
+    const timer = setTimeout(() => {
+      log49.debug(`Connector probe for ${label} timed out after ${timeoutMs}ms`);
+      try {
+        child.kill("SIGKILL");
+      } catch {}
+      finish(parseConnectorNames(stdout));
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+      const names = parseConnectorNames(stdout);
+      if (names !== null) {
+        try {
+          child.kill("SIGTERM");
+        } catch {}
+        finish(names);
+      }
+    });
+    child.stderr?.on("data", () => {});
+    child.on("error", (err) => {
+      log49.warn(`Connector probe for ${label} errored: ${err}`);
+      finish(null);
+    });
+    child.on("close", () => finish(parseConnectorNames(stdout)));
+  });
+}
+
 // src/cleanup/scheduler.ts
 init_logger();
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { readdir, rm as rm3 } from "fs/promises";
 import { join as join16 } from "path";
 init_worktree();
-var log49 = createLogger("cleanup");
+var log50 = createLogger("cleanup");
 var DEFAULT_CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
 var MAX_WORKTREE_AGE_MS = 24 * 60 * 60 * 1000;
 
@@ -72503,17 +72786,17 @@ class CleanupScheduler {
   }
   start() {
     if (this.isRunning) {
-      log49.debug("Cleanup scheduler already running");
+      log50.debug("Cleanup scheduler already running");
       return;
     }
     this.isRunning = true;
-    log49.info(`Cleanup scheduler started (interval: ${Math.round(this.intervalMs / 60000)}min)`);
+    log50.info(`Cleanup scheduler started (interval: ${Math.round(this.intervalMs / 60000)}min)`);
     this.runCleanup().catch((err) => {
-      log49.warn(`Initial cleanup failed: ${err}`);
+      log50.warn(`Initial cleanup failed: ${err}`);
     });
     this.timer = setInterval(() => {
       this.runCleanup().catch((err) => {
-        log49.warn(`Periodic cleanup failed: ${err}`);
+        log50.warn(`Periodic cleanup failed: ${err}`);
       });
     }, this.intervalMs);
   }
@@ -72523,11 +72806,11 @@ class CleanupScheduler {
       this.timer = null;
     }
     this.isRunning = false;
-    log49.debug("Cleanup scheduler stopped");
+    log50.debug("Cleanup scheduler stopped");
   }
   async runCleanup() {
     const startTime = Date.now();
-    log49.debug("Running background cleanup...");
+    log50.debug("Running background cleanup...");
     const stats = {
       logsDeleted: 0,
       worktreesCleaned: 0,
@@ -72553,9 +72836,9 @@ class CleanupScheduler {
     const elapsed = Date.now() - startTime;
     const totalCleaned = stats.logsDeleted + stats.worktreesCleaned + stats.metadataCleaned;
     if (totalCleaned > 0 || stats.errors.length > 0) {
-      log49.info(`Cleanup completed in ${elapsed}ms: ` + `${stats.logsDeleted} logs, ${stats.worktreesCleaned} worktrees, ${stats.metadataCleaned} metadata` + (stats.errors.length > 0 ? ` (${stats.errors.length} errors)` : ""));
+      log50.info(`Cleanup completed in ${elapsed}ms: ` + `${stats.logsDeleted} logs, ${stats.worktreesCleaned} worktrees, ${stats.metadataCleaned} metadata` + (stats.errors.length > 0 ? ` (${stats.errors.length} errors)` : ""));
     } else {
-      log49.debug(`Cleanup completed in ${elapsed}ms (nothing to clean)`);
+      log50.debug(`Cleanup completed in ${elapsed}ms (nothing to clean)`);
     }
     return stats;
   }
@@ -72568,7 +72851,7 @@ class CleanupScheduler {
         const deleted = cleanupOldLogs(this.logRetentionDays);
         resolve7(deleted);
       } catch (err) {
-        log49.warn(`Log cleanup error: ${err}`);
+        log50.warn(`Log cleanup error: ${err}`);
         resolve7(0);
       }
     });
@@ -72576,8 +72859,8 @@ class CleanupScheduler {
   async cleanupOrphanedWorktrees() {
     const worktreesDir = getWorktreesDir();
     const result = { cleaned: 0, metadata: 0 };
-    if (!existsSync14(worktreesDir)) {
-      log49.debug("No worktrees directory exists, nothing to clean");
+    if (!existsSync15(worktreesDir)) {
+      log50.debug("No worktrees directory exists, nothing to clean");
       return result;
     }
     const persisted = this.sessionStore.load();
@@ -72595,7 +72878,7 @@ class CleanupScheduler {
           continue;
         const worktreePath = join16(worktreesDir, entry.name);
         if (activeWorktrees.has(worktreePath)) {
-          log49.debug(`Worktree in use by persisted session, skipping: ${entry.name}`);
+          log50.debug(`Worktree in use by persisted session, skipping: ${entry.name}`);
           continue;
         }
         const meta = await readWorktreeMetadata(worktreePath);
@@ -72605,7 +72888,7 @@ class CleanupScheduler {
           const lastActivity = new Date(meta.lastActivityAt).getTime();
           const age = now - lastActivity;
           if (meta.sessionId && age < this.maxWorktreeAgeMs) {
-            log49.debug(`Worktree has active session (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
+            log50.debug(`Worktree has active session (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
             continue;
           }
           const merged = age >= this.maxWorktreeAgeMs ? await isBranchMerged(meta.repoRoot, meta.branch).catch(() => false) : false;
@@ -72616,7 +72899,7 @@ class CleanupScheduler {
             shouldCleanup = true;
             cleanupReason = `inactive for ${Math.round(age / 3600000)}h`;
           } else {
-            log49.debug(`Worktree recent (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
+            log50.debug(`Worktree recent (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
             continue;
           }
         } else {
@@ -72625,7 +72908,7 @@ class CleanupScheduler {
         }
         if (!shouldCleanup)
           continue;
-        log49.info(`Cleaning worktree (${cleanupReason}): ${entry.name}`);
+        log50.info(`Cleaning worktree (${cleanupReason}): ${entry.name}`);
         try {
           if (meta?.repoRoot) {
             await removeWorktree(meta.repoRoot, worktreePath);
@@ -72636,19 +72919,19 @@ class CleanupScheduler {
           await removeWorktreeMetadata(worktreePath);
           result.metadata++;
         } catch (err) {
-          log49.warn(`Failed to clean orphaned worktree ${entry.name}: ${err}`);
+          log50.warn(`Failed to clean orphaned worktree ${entry.name}: ${err}`);
           try {
             await rm3(worktreePath, { recursive: true, force: true });
             result.cleaned++;
             await removeWorktreeMetadata(worktreePath);
             result.metadata++;
           } catch (rmErr) {
-            log49.error(`Failed to force remove worktree ${entry.name}: ${rmErr}`);
+            log50.error(`Failed to force remove worktree ${entry.name}: ${rmErr}`);
           }
         }
       }
     } catch (err) {
-      log49.warn(`Failed to scan worktrees directory: ${err}`);
+      log50.warn(`Failed to scan worktrees directory: ${err}`);
     }
     return result;
   }
@@ -72657,8 +72940,8 @@ class CleanupScheduler {
 init_version_check();
 init_spawn();
 init_logger();
-var log50 = createLogger("plugin");
-var sessionLog12 = createSessionLog(log50);
+var log51 = createLogger("plugin");
+var sessionLog12 = createSessionLog(log51);
 async function buildPluginRestartCliOptions(session, ctx) {
   const account = session.claudeAccountId ? ctx.ops.getClaudeAccount(session.claudeAccountId) : undefined;
   const memoryConfig = ctx.ops.getPlatformMemoryConfig(session.platformId);
@@ -72701,7 +72984,7 @@ async function runPluginCommand(args, cwd, timeout2 = 60000) {
     });
     proc.on("error", (err) => {
       resolve7({ stdout, stderr, exitCode: 1 });
-      log50.error(`Plugin command error: ${err.message}`);
+      log51.error(`Plugin command error: ${err.message}`);
     });
   });
 }
@@ -72742,6 +73025,9 @@ ${formatter.formatCodeBlock(errorMsg, "text")}`);
   }
   await post(session, "success", `✅ Plugin installed: ${formatter.formatCode(pluginName)}
 \uD83D\uDD04 Restarting Claude to load plugin...`);
+  if (session.platform.getMcpConfig().strictMcpConfig === true) {
+    await post(session, "warning", `This platform runs with ${formatter.formatCode("strictMcpConfig: true")}: MCP servers bundled with the plugin will not load. ` + `Declare them under ${formatter.formatCode("mcpServers")} or set ${formatter.formatCode("strictMcpConfig: false")}.`);
+  }
   const cliOptions = await buildPluginRestartCliOptions(session, ctx);
   const success = await restartClaudeSession(session, cliOptions, ctx, `Plugin installation: ${pluginName}`);
   if (success) {
@@ -72806,7 +73092,7 @@ function shouldPostResumeRefusal(platformId, threadId, username, now = Date.now(
 
 // src/session/reaction-router.ts
 init_logger();
-var log51 = createLogger("manager");
+var log52 = createLogger("manager");
 async function handleReaction(deps, platformId, postId, emojiName, username, action) {
   const normalizedEmoji = normalizeEmojiName(emojiName);
   if (action === "added" && isResumeEmoji(normalizedEmoji)) {
@@ -72821,7 +73107,7 @@ async function handleReaction(deps, platformId, postId, emojiName, username, act
     return;
   const ownerScoped = resolveApprovals(session.platform.approvals, isDcmThreadId(session.threadId)) === "owner";
   if (!session.sessionAllowedUsers.has(username) && (ownerScoped || !session.platform.isUserAllowed(username))) {
-    log51.info(`\uD83D\uDEAB rejected reaction from unauthorized user`, {
+    log52.info(`\uD83D\uDEAB rejected reaction from unauthorized user`, {
       event: "reaction.rejected",
       platformId,
       sessionId: session.sessionId,
@@ -72839,7 +73125,7 @@ async function tryResumeFromReaction(deps, platformId, postId, username) {
   if (!persistedSession)
     return false;
   if (!isRevivable(persistedSession)) {
-    log51.debug(`Ignoring resume reaction on stopped session ${persistedSession.threadId.substring(0, 8)}...`);
+    log52.debug(`Ignoring resume reaction on stopped session ${persistedSession.threadId.substring(0, 8)}...`);
     return false;
   }
   const sessionId = `${platformId}:${persistedSession.threadId}`;
@@ -72864,7 +73150,7 @@ async function tryResumeFromReaction(deps, platformId, postId, username) {
     return false;
   }
   const shortId = persistedSession.threadId.substring(0, 8);
-  log51.info(`\uD83D\uDD04 Resuming session ${shortId}... via emoji reaction by @${username}`);
+  log52.info(`\uD83D\uDD04 Resuming session ${shortId}... via emoji reaction by @${username}`);
   await resumeSession(persistedSession, deps.getContext(), username);
   return true;
 }
@@ -72894,7 +73180,7 @@ async function dispatch(deps, session, postId, emojiName, username, action) {
     }
     if (session.lastError?.postId === postId && isBugReportEmoji(emojiName)) {
       if (session.startedBy === username || session.platform.isUserAllowed(username) || session.sessionAllowedUsers.has(username)) {
-        log51.info(`\uD83D\uDC1B @${username} triggered bug report from error reaction`);
+        log52.info(`\uD83D\uDC1B @${username} triggered bug report from error reaction`);
         await reportBug(session, undefined, username, deps.getContext(), session.lastError);
         return;
       }
@@ -72909,7 +73195,7 @@ async function dispatch(deps, session, postId, emojiName, username, action) {
 
 // src/session/manager.ts
 init_logger();
-var log52 = createLogger("manager");
+var log53 = createLogger("manager");
 var USAGE_PROBE_TIMEOUT_MS = 1e4;
 var USAGE_REFRESH_DEADLINE_MS = 5000;
 var USAGE_CACHE_TTL_MS = 15000;
@@ -72948,6 +73234,7 @@ class SessionManager extends EventEmitter4 {
   platformWatches = new Map;
   autoUpdateManager = null;
   accountPool;
+  connectorsOff = null;
   usageRefreshInFlight = null;
   usageRefreshedAt = 0;
   constructor(workingDir, permissionModeOrSkipFlag = "default", chromeEnabled = false, worktreeMode = "prompt", sessionsPath, threadLogsEnabled = true, threadLogsRetentionDays = 30, limits, claudeAccounts, respondOnlyWhenMentioned = false, userAttribution = true) {
@@ -73039,7 +73326,7 @@ class SessionManager extends EventEmitter4 {
       markNeedsBump(platformId);
       this.updateStickyMessage();
     });
-    log52.info(`\uD83D\uDCE1 Platform "${platformId}" registered`);
+    log53.info(`\uD83D\uDCE1 Platform "${platformId}" registered`);
   }
   removePlatform(platformId) {
     this.platforms.delete(platformId);
@@ -73060,7 +73347,7 @@ class SessionManager extends EventEmitter4 {
     if (users) {
       users.add(sessionId);
     }
-    log52.debug(`Registered session ${sessionId.substring(0, 20)} as worktree user for ${worktreePath}`);
+    log53.debug(`Registered session ${sessionId.substring(0, 20)} as worktree user for ${worktreePath}`);
   }
   unregisterWorktreeUser(worktreePath, sessionId) {
     const users = this.worktreeUsers.get(worktreePath);
@@ -73283,7 +73570,7 @@ class SessionManager extends EventEmitter4 {
     try {
       this.persistSessionUnsafe(session);
     } catch (err) {
-      log52.error(`Failed to persist session ${session.sessionId}: ${err}`);
+      log53.error(`Failed to persist session ${session.sessionId}: ${err}`);
     }
   }
   persistSessionUnsafe(session) {
@@ -73369,9 +73656,34 @@ class SessionManager extends EventEmitter4 {
       debug: this.debug,
       description: this.customDescription,
       footer: this.customFooter,
-      accountPoolStatus: this.accountPool.isEmpty ? undefined : this.accountPool.status()
+      accountPoolStatus: this.accountPool.isEmpty ? undefined : this.accountPool.status(),
+      connectorsOff: this.connectorsOff ?? undefined
     }, overheadByPlatform);
   }
+  async noticeClaudeAiConnectors() {
+    try {
+      const accounts = this.accountPool.isEmpty ? [undefined] : [...this.accountPool.all];
+      const found = new Set;
+      await Promise.all(accounts.map(async (acc) => {
+        const names2 = await probeClaudeAiConnectors(acc);
+        for (const n of names2 ?? [])
+          found.add(n);
+      }));
+      if (found.size === 0)
+        return;
+      const allowedOn = [...this.platforms.entries()].filter(([, client]) => client.getMcpConfig().claudeAiConnectors === true).map(([id]) => id);
+      const names = [...found].sort().join(", ");
+      if (allowedOn.length > 0) {
+        log53.info(`claude.ai connectors (${names}) are available to sessions on: ${allowedOn.join(", ")}`);
+        return;
+      }
+      log53.warn(`This Claude account has claude.ai connectors (${names}). Sessions do not get them: ` + `since 1.35.0 the bot disables them per session. To let a platform's sessions use them, set ` + `claudeAiConnectors: true on that platform in config.yaml (everyone on its allowedUsers gets them).`);
+      this.connectorsOff = found.size;
+      await this.updateAllStickyMessages();
+    } catch (err) {
+      log53.debug(`Connector notice skipped: ${err}`);
+    }
+  }
   async updateAllStickyMessages() {
     await this.updateStickyMessage();
   }
@@ -73408,11 +73720,11 @@ class SessionManager extends EventEmitter4 {
       }
     }
     if (sessionsToKill.length === 0) {
-      log52.info(`No active sessions to pause for platform ${platformId}`);
+      log53.info(`No active sessions to pause for platform ${platformId}`);
       await this.updateStickyMessage();
       return;
     }
-    log52.info(`⏸️ Pausing ${sessionsToKill.length} session(s) for platform ${platformId}`);
+    log53.info(`⏸️ Pausing ${sessionsToKill.length} session(s) for platform ${platformId}`);
     for (const session of sessionsToKill) {
       try {
         const fmt = session.platform.getFormatter();
@@ -73428,9 +73740,9 @@ class SessionManager extends EventEmitter4 {
         session.claude.kill();
         this.registry.unregister(session.sessionId);
         this.emitSessionRemove(session.sessionId);
-        log52.info(`⏸️ Paused session ${session.threadId.substring(0, 8)}`);
+        log53.info(`⏸️ Paused session ${session.threadId.substring(0, 8)}`);
       } catch (err) {
-        log52.warn(`Failed to pause session ${session.threadId}: ${err}`);
+        log53.warn(`Failed to pause session ${session.threadId}: ${err}`);
       }
     }
     for (const session of sessionsToKill) {
@@ -73451,17 +73763,17 @@ class SessionManager extends EventEmitter4 {
       sessionsToResume.push(state);
     }
     if (sessionsToResume.length === 0) {
-      log52.info(`No paused sessions to resume for platform ${platformId}`);
+      log53.info(`No paused sessions to resume for platform ${platformId}`);
       await this.updateStickyMessage();
       return;
     }
-    log52.info(`▶️ Resuming ${sessionsToResume.length} paused session(s) for platform ${platformId}`);
+    log53.info(`▶️ Resuming ${sessionsToResume.length} paused session(s) for platform ${platformId}`);
     for (const state of sessionsToResume) {
       try {
         await resumeSession(state, this.getContext());
-        log52.info(`▶️ Resumed session ${state.threadId.substring(0, 8)}`);
+        log53.info(`▶️ Resumed session ${state.threadId.substring(0, 8)}`);
       } catch (err) {
-        log52.warn(`Failed to resume session ${state.threadId}: ${err}`);
+        log53.warn(`Failed to resume session ${state.threadId}: ${err}`);
       }
     }
     await this.updateStickyMessage();
@@ -73500,14 +73812,14 @@ class SessionManager extends EventEmitter4 {
     const sessionTimeoutMs = this.limits.sessionTimeoutMinutes * 60 * 1000;
     const staleIds = this.sessionStore.cleanStale(sessionTimeoutMs * 2);
     if (staleIds.length > 0) {
-      log52.info(`\uD83E\uDDF9 Soft-deleted ${staleIds.length} stale session(s) (kept for history)`);
+      log53.info(`\uD83E\uDDF9 Soft-deleted ${staleIds.length} stale session(s) (kept for history)`);
     }
     const removedCount = this.sessionStore.cleanHistory();
     if (removedCount > 0) {
-      log52.info(`\uD83D\uDDD1️ Permanently removed ${removedCount} old session(s) from history`);
+      log53.info(`\uD83D\uDDD1️ Permanently removed ${removedCount} old session(s) from history`);
     }
     const persisted = this.sessionStore.load();
-    log52.info(`\uD83D\uDCC2 Loaded ${persisted.size} session(s) from persistence`);
+    log53.info(`\uD83D\uDCC2 Loaded ${persisted.size} session(s) from persistence`);
     const excludePostIdsByPlatform = new Map;
     for (const session of persisted.values()) {
       const platformId = session.platformId;
@@ -73527,10 +73839,10 @@ class SessionManager extends EventEmitter4 {
       const excludePostIds = excludePostIdsByPlatform.get(platform.platformId);
       platform.getBotUser().then((botUser) => {
         cleanupOldStickyMessages(platform, botUser.id, true, excludePostIds).catch((err) => {
-          log52.warn(`Failed to cleanup old sticky messages for ${platform.platformId}: ${err}`);
+          log53.warn(`Failed to cleanup old sticky messages for ${platform.platformId}: ${err}`);
         });
       }).catch((err) => {
-        log52.warn(`Failed to get bot user for cleanup on ${platform.platformId}: ${err}`);
+        log53.warn(`Failed to get bot user for cleanup on ${platform.platformId}: ${err}`);
       });
     }
     if (persisted.size > 0) {
@@ -73544,10 +73856,10 @@ class SessionManager extends EventEmitter4 {
         }
       }
       if (pausedToSkip.length > 0) {
-        log52.info(`⏸️ ${pausedToSkip.length} session(s) remain paused (waiting for user message)`);
+        log53.info(`⏸️ ${pausedToSkip.length} session(s) remain paused (waiting for user message)`);
       }
       if (activeToResume.length > 0) {
-        log52.info(`\uD83D\uDD04 Attempting to resume ${activeToResume.length} active session(s)...`);
+        log53.info(`\uD83D\uDD04 Attempting to resume ${activeToResume.length} active session(s)...`);
         for (const state of activeToResume) {
           await resumeSession(state, this.getContext());
         }
@@ -73663,7 +73975,7 @@ class SessionManager extends EventEmitter4 {
     try {
       return await transcribeForEvaluation(transcriber, platform, getSessionUploadDir(platformId, post2.rootId || post2.id), files);
     } catch (err) {
-      log52.warn(`Watch transcription failed for ${platformId}: ${err instanceof Error ? err.message : String(err)}`);
+      log53.warn(`Watch transcription failed for ${platformId}: ${err instanceof Error ? err.message : String(err)}`);
       return "";
     }
   }
@@ -73999,7 +74311,7 @@ Mention me to start a session in this worktree.`, threadId);
         const message = messageBuilder(formatter);
         await post(session, "info", message);
       } catch (err) {
-        log52.warn(`Failed to broadcast to session ${session.threadId}: ${err}`);
+        log53.warn(`Failed to broadcast to session ${session.threadId}: ${err}`);
       }
     }
   }
@@ -74018,7 +74330,7 @@ Mention me to start a session in this worktree.`, threadId);
         session.messageManager?.setPendingUpdatePrompt({ postId: post2.id });
         this.registerPost(post2.id, session.threadId);
       } catch (err) {
-        log52.warn(`Failed to post ask message to ${threadId}: ${err}`);
+        log53.warn(`Failed to post ask message to ${threadId}: ${err}`);
       }
     }
   }
@@ -83941,29 +84253,29 @@ function SessionLog({ logs, maxLines = 20 }) {
   return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
     flexDirection: "column",
     flexShrink: 0,
-    children: displayLogs.map((log53) => /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
+    children: displayLogs.map((log54) => /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
       flexShrink: 0,
       children: [
         /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
-          color: getColorForLevel(log53.level),
+          color: getColorForLevel(log54.level),
           dimColor: true,
           wrap: "truncate",
           children: [
             "[",
-            padComponent(log53.component),
+            padComponent(log54.component),
             "]"
           ]
         }, undefined, true, undefined, this),
         /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
-          color: getColorForLevel(log53.level),
+          color: getColorForLevel(log54.level),
           wrap: "truncate",
           children: [
             " ",
-            log53.message
+            log54.message
           ]
         }, undefined, true, undefined, this)
       ]
-    }, log53.id, true, undefined, this))
+    }, log54.id, true, undefined, this))
   }, undefined, false, undefined, this);
 }
 // src/ui/components/Footer.tsx
@@ -84487,7 +84799,7 @@ function LogPanel({ logs, maxLines = 10, focused = false }) {
   const scrollRef = import_react62.default.useRef(null);
   const { stdout } = use_stdout_default();
   const isDebug = process.env.DEBUG === "1";
-  const displayLogs = logs.filter((log53) => isDebug || log53.level !== "debug");
+  const displayLogs = logs.filter((log54) => isDebug || log54.level !== "debug");
   const visibleLogs = displayLogs.slice(-Math.max(maxLines * 3, 100));
   import_react62.default.useEffect(() => {
     const handleResize = () => scrollRef.current?.remeasure();
@@ -84527,25 +84839,25 @@ function LogPanel({ logs, maxLines = 10, focused = false }) {
     overflow: "hidden",
     children: /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(ScrollView, {
       ref: scrollRef,
-      children: visibleLogs.map((log53) => /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
+      children: visibleLogs.map((log54) => /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
         children: [
           /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
             dimColor: true,
             children: [
               "[",
-              padComponent2(log53.component),
+              padComponent2(log54.component),
               "]"
             ]
           }, undefined, true, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
-            color: getLevelColor(log53.level),
+            color: getLevelColor(log54.level),
             children: [
               " ",
-              log53.message
+              log54.message
             ]
           }, undefined, true, undefined, this)
         ]
-      }, log53.id, true, undefined, this))
+      }, log54.id, true, undefined, this))
     }, undefined, false, undefined, this)
   }, undefined, false, undefined, this);
 }
@@ -85071,10 +85383,10 @@ function useAppState(initialConfig) {
     });
   }, []);
   const getLogsForSession = import_react63.useCallback((sessionId) => {
-    return state.logs.filter((log53) => log53.sessionId === sessionId);
+    return state.logs.filter((log54) => log54.sessionId === sessionId);
   }, [state.logs]);
   const getGlobalLogs = import_react63.useCallback(() => {
-    return state.logs.filter((log53) => !log53.sessionId);
+    return state.logs.filter((log54) => !log54.sessionId);
   }, [state.logs]);
   const togglePlatformEnabled = import_react63.useCallback((platformId) => {
     let newEnabled = false;
@@ -86214,7 +86526,7 @@ import { EventEmitter as EventEmitter9 } from "events";
 // src/auto-update/checker.ts
 init_logger();
 import { EventEmitter as EventEmitter7 } from "events";
-var log53 = createLogger("checker");
+var log54 = createLogger("checker");
 var PACKAGE_NAME = "claude-threads";
 function compareVersions(a, b) {
   const partsA = a.replace(/^v/, "").split(".").map(Number);
@@ -86237,13 +86549,13 @@ async function fetchLatestVersion() {
       }
     });
     if (!response.ok) {
-      log53.warn(`Failed to fetch latest version: HTTP ${response.status}`);
+      log54.warn(`Failed to fetch latest version: HTTP ${response.status}`);
       return null;
     }
     const data = await response.json();
     return data.version ?? null;
   } catch (err) {
-    log53.warn(`Failed to fetch latest version: ${err}`);
+    log54.warn(`Failed to fetch latest version: ${err}`);
     return null;
   }
 }
@@ -86260,38 +86572,38 @@ class UpdateChecker extends EventEmitter7 {
   }
   start() {
     if (!this.config.enabled) {
-      log53.debug("Auto-update disabled, not starting checker");
+      log54.debug("Auto-update disabled, not starting checker");
       return;
     }
     setTimeout(() => {
       this.check().catch((err) => {
-        log53.warn(`Initial update check failed: ${err}`);
+        log54.warn(`Initial update check failed: ${err}`);
       });
     }, 5000);
     const intervalMs = this.config.checkIntervalMinutes * 60 * 1000;
     this.checkInterval = setInterval(() => {
       this.check().catch((err) => {
-        log53.warn(`Periodic update check failed: ${err}`);
+        log54.warn(`Periodic update check failed: ${err}`);
       });
     }, intervalMs);
-    log53.info(`\uD83D\uDD04 Update checker started (every ${this.config.checkIntervalMinutes} minutes)`);
+    log54.info(`\uD83D\uDD04 Update checker started (every ${this.config.checkIntervalMinutes} minutes)`);
   }
   stop() {
     if (this.checkInterval) {
       clearInterval(this.checkInterval);
       this.checkInterval = null;
     }
-    log53.debug("Update checker stopped");
+    log54.debug("Update checker stopped");
   }
   async check() {
     if (this.isChecking) {
-      log53.debug("Check already in progress, skipping");
+      log54.debug("Check already in progress, skipping");
       return this.lastUpdateInfo;
     }
     this.isChecking = true;
     this.emit("check:start");
     try {
-      log53.debug("Checking for updates...");
+      log54.debug("Checking for updates...");
       const latestVersion2 = await fetchLatestVersion();
       if (!latestVersion2) {
         this.emit("check:complete", false);
@@ -86308,18 +86620,18 @@ class UpdateChecker extends EventEmitter7 {
           detectedAt: new Date
         };
         if (!this.lastUpdateInfo || this.lastUpdateInfo.latestVersion !== latestVersion2) {
-          log53.info(`\uD83C\uDD95 Update available: v${currentVersion} → v${latestVersion2}`);
+          log54.info(`\uD83C\uDD95 Update available: v${currentVersion} → v${latestVersion2}`);
           this.lastUpdateInfo = updateInfo;
           this.emit("update", updateInfo);
         }
         this.emit("check:complete", true);
         return updateInfo;
       }
-      log53.debug(`Up to date (v${currentVersion})`);
+      log54.debug(`Up to date (v${currentVersion})`);
       this.emit("check:complete", false);
       return null;
     } catch (err) {
-      log53.warn(`Update check failed: ${err}`);
+      log54.warn(`Update check failed: ${err}`);
       this.emit("check:error", err);
       return null;
     } finally {
@@ -86390,7 +86702,7 @@ function isInScheduledWindow(window2) {
 }
 
 // src/auto-update/scheduler.ts
-var log54 = createLogger("scheduler");
+var log55 = createLogger("scheduler");
 
 class UpdateScheduler extends EventEmitter8 {
   config;
@@ -86414,7 +86726,7 @@ class UpdateScheduler extends EventEmitter8 {
   scheduleUpdate(updateInfo) {
     this.pendingUpdate = updateInfo;
     if (this.config.autoRestartMode === "immediate") {
-      log54.info("Immediate mode: triggering update now");
+      log55.info("Immediate mode: triggering update now");
       this.emit("ready", updateInfo);
       return;
     }
@@ -86427,19 +86739,19 @@ class UpdateScheduler extends EventEmitter8 {
     this.scheduledRestartAt = null;
     this.askApprovals.clear();
     this.askStartTime = null;
-    log54.debug("Update schedule cancelled");
+    log55.debug("Update schedule cancelled");
   }
   deferUpdate(minutes) {
     const deferUntil = new Date(Date.now() + minutes * 60 * 1000);
     this.scheduledRestartAt = null;
     this.idleStartTime = null;
     this.emit("deferred", deferUntil);
-    log54.info(`Update deferred until ${deferUntil.toLocaleTimeString()}`);
+    log55.info(`Update deferred until ${deferUntil.toLocaleTimeString()}`);
     return deferUntil;
   }
   recordAskResponse(threadId, approved) {
     this.askApprovals.set(threadId, approved);
-    log54.debug(`Thread ${threadId.substring(0, 8)} ${approved ? "approved" : "denied"} update`);
+    log55.debug(`Thread ${threadId.substring(0, 8)} ${approved ? "approved" : "denied"} update`);
     this.checkAskCondition();
   }
   getScheduledRestartAt() {
@@ -86460,7 +86772,7 @@ class UpdateScheduler extends EventEmitter8 {
       return;
     this.checkCondition();
     this.checkTimer = setInterval(() => this.checkCondition(), 1e4);
-    log54.debug(`Started checking for ${this.config.autoRestartMode} condition`);
+    log55.debug(`Started checking for ${this.config.autoRestartMode} condition`);
   }
   stopChecking() {
     if (this.checkTimer) {
@@ -86491,17 +86803,17 @@ class UpdateScheduler extends EventEmitter8 {
     if (activity.activeSessionCount === 0) {
       if (!this.idleStartTime) {
         this.idleStartTime = new Date;
-        log54.debug("No active sessions, starting idle timer");
+        log55.debug("No active sessions, starting idle timer");
       }
       const idleMs = Date.now() - this.idleStartTime.getTime();
       const requiredMs = this.config.idleTimeoutMinutes * 60 * 1000;
       if (idleMs >= requiredMs) {
-        log54.info(`Idle for ${this.config.idleTimeoutMinutes} minutes, triggering update`);
+        log55.info(`Idle for ${this.config.idleTimeoutMinutes} minutes, triggering update`);
         this.triggerCountdown();
       }
     } else {
       if (this.idleStartTime) {
-        log54.debug("Sessions became active, resetting idle timer");
+        log55.debug("Sessions became active, resetting idle timer");
         this.idleStartTime = null;
       }
     }
@@ -86512,7 +86824,7 @@ class UpdateScheduler extends EventEmitter8 {
       const quietMs = Date.now() - activity.lastActivityAt.getTime();
       const requiredMs = this.config.quietTimeoutMinutes * 60 * 1000;
       if (quietMs >= requiredMs && !activity.anySessionBusy) {
-        log54.info(`Sessions quiet for ${this.config.quietTimeoutMinutes} minutes, triggering update`);
+        log55.info(`Sessions quiet for ${this.config.quietTimeoutMinutes} minutes, triggering update`);
         this.triggerCountdown();
       }
     } else if (activity.activeSessionCount === 0) {
@@ -86522,7 +86834,7 @@ class UpdateScheduler extends EventEmitter8 {
       const idleMs = Date.now() - this.idleStartTime.getTime();
       const requiredMs = this.config.quietTimeoutMinutes * 60 * 1000;
       if (idleMs >= requiredMs) {
-        log54.info("No sessions and quiet timeout reached, triggering update");
+        log55.info("No sessions and quiet timeout reached, triggering update");
         this.triggerCountdown();
       }
     }
@@ -86533,13 +86845,13 @@ class UpdateScheduler extends EventEmitter8 {
     }
     const activity = this.getSessionActivity();
     if (activity.activeSessionCount === 0) {
-      log54.info("Within scheduled window and no active sessions, triggering update");
+      log55.info("Within scheduled window and no active sessions, triggering update");
       this.triggerCountdown();
     } else if (activity.lastActivityAt) {
       const quietMs = Date.now() - activity.lastActivityAt.getTime();
       const requiredMs = this.config.idleTimeoutMinutes * 60 * 1000;
       if (quietMs >= requiredMs && !activity.anySessionBusy) {
-        log54.info("Within scheduled window and sessions quiet, triggering update");
+        log55.info("Within scheduled window and sessions quiet, triggering update");
         this.triggerCountdown();
       }
     }
@@ -86547,14 +86859,14 @@ class UpdateScheduler extends EventEmitter8 {
   checkAskCondition() {
     const threadIds = this.getActiveThreadIds();
     if (threadIds.length === 0) {
-      log54.info("No active threads, proceeding with update");
+      log55.info("No active threads, proceeding with update");
       this.triggerCountdown();
       return;
     }
     if (!this.askStartTime && this.pendingUpdate) {
       this.askStartTime = new Date;
       this.postAskMessage(threadIds, this.pendingUpdate.latestVersion).catch((err) => {
-        log54.warn(`Failed to post ask message: ${err}`);
+        log55.warn(`Failed to post ask message: ${err}`);
       });
       return;
     }
@@ -86567,12 +86879,12 @@ class UpdateScheduler extends EventEmitter8 {
         denials++;
     }
     if (approvals > threadIds.length / 2) {
-      log54.info(`Majority approved (${approvals}/${threadIds.length}), triggering update`);
+      log55.info(`Majority approved (${approvals}/${threadIds.length}), triggering update`);
       this.triggerCountdown();
       return;
     }
     if (denials > threadIds.length / 2) {
-      log54.info(`Majority denied (${denials}/${threadIds.length}), deferring update`);
+      log55.info(`Majority denied (${denials}/${threadIds.length}), deferring update`);
       this.deferUpdate(60);
       return;
     }
@@ -86580,7 +86892,7 @@ class UpdateScheduler extends EventEmitter8 {
       const elapsedMs = Date.now() - this.askStartTime.getTime();
       const timeoutMs = this.config.askTimeoutMinutes * 60 * 1000;
       if (elapsedMs >= timeoutMs) {
-        log54.info(`Ask timeout reached (${this.config.askTimeoutMinutes} min), triggering update`);
+        log55.info(`Ask timeout reached (${this.config.askTimeoutMinutes} min), triggering update`);
         this.triggerCountdown();
       }
     }
@@ -86600,7 +86912,7 @@ class UpdateScheduler extends EventEmitter8 {
         this.emit("ready", this.pendingUpdate);
       }
     }, 1000);
-    log54.info("Update countdown started (60 seconds)");
+    log55.info("Update countdown started (60 seconds)");
   }
   stopCountdown() {
     if (this.countdownTimer) {
@@ -86612,28 +86924,28 @@ class UpdateScheduler extends EventEmitter8 {
 
 // src/auto-update/installer.ts
 import { spawn as spawn4, spawnSync } from "child_process";
-import { existsSync as existsSync16, readFileSync as readFileSync12, mkdirSync as mkdirSync8 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync12, mkdirSync as mkdirSync8 } from "fs";
 import { dirname as dirname9, resolve as resolve7 } from "path";
 import { homedir as homedir9 } from "os";
 init_logger();
-var log55 = createLogger("installer");
+var log56 = createLogger("installer");
 function detectPackageManager() {
   const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
   const originalInstaller = detectOriginalInstaller();
   if (originalInstaller) {
-    log55.debug(`Detected original installer: ${originalInstaller}`);
+    log56.debug(`Detected original installer: ${originalInstaller}`);
     if (originalInstaller === "bun") {
       const bunCheck2 = spawnSync("bun", ["--version"], { stdio: "ignore" });
       if (bunCheck2.status === 0) {
         return { cmd: "bun", isBun: true };
       }
-      log55.warn("Originally installed with bun, but bun not found. Falling back to npm.");
+      log56.warn("Originally installed with bun, but bun not found. Falling back to npm.");
     } else {
       const npmCheck2 = spawnSync(npmCmd, ["--version"], { stdio: "ignore" });
       if (npmCheck2.status === 0) {
         return { cmd: npmCmd, isBun: false };
       }
-      log55.warn("Originally installed with npm, but npm not found. Falling back to bun.");
+      log56.warn("Originally installed with npm, but npm not found. Falling back to bun.");
     }
   }
   const bunCheck = spawnSync("bun", ["--version"], { stdio: "ignore" });
@@ -86679,34 +86991,34 @@ var STATE_PATH = resolve7(homedir9(), ".config", "claude-threads", UPDATE_STATE_
 var PACKAGE_NAME2 = "claude-threads";
 function loadUpdateState() {
   try {
-    if (existsSync16(STATE_PATH)) {
+    if (existsSync17(STATE_PATH)) {
       const content = readFileSync12(STATE_PATH, "utf-8");
       return JSON.parse(content);
     }
   } catch (err) {
-    log55.warn(`Failed to load update state: ${err}`);
+    log56.warn(`Failed to load update state: ${err}`);
   }
   return {};
 }
 function saveUpdateState(state) {
   try {
     const dir = dirname9(STATE_PATH);
-    if (!existsSync16(dir)) {
+    if (!existsSync17(dir)) {
       mkdirSync8(dir, { recursive: true, mode: 448 });
     }
     writeFileAtomic(STATE_PATH, JSON.stringify(state, null, 2));
-    log55.debug("Update state saved");
+    log56.debug("Update state saved");
   } catch (err) {
-    log55.warn(`Failed to save update state: ${err}`);
+    log56.warn(`Failed to save update state: ${err}`);
   }
 }
 function clearUpdateState() {
   try {
-    if (existsSync16(STATE_PATH)) {
+    if (existsSync17(STATE_PATH)) {
       writeFileAtomic(STATE_PATH, "{}");
     }
   } catch (err) {
-    log55.warn(`Failed to clear update state: ${err}`);
+    log56.warn(`Failed to clear update state: ${err}`);
   }
 }
 function checkJustUpdated() {
@@ -86738,11 +87050,11 @@ function clearRuntimeSettings() {
   }
 }
 async function installVersion(version) {
-  log55.info(`\uD83D\uDCE6 Installing ${PACKAGE_NAME2}@${version}...`);
+  log56.info(`\uD83D\uDCE6 Installing ${PACKAGE_NAME2}@${version}...`);
   const pm = detectPackageManager();
   if (!pm) {
     const error = "Neither bun nor npm found in PATH. Cannot install update.";
-    log55.error(`❌ ${error}`);
+    log56.error(`❌ ${error}`);
     return { success: false, error };
   }
   saveUpdateState({
@@ -86754,7 +87066,7 @@ async function installVersion(version) {
   return new Promise((resolve8) => {
     const { cmd, isBun: isBun3 } = pm;
     const args = ["install", "-g", `${PACKAGE_NAME2}@${version}`];
-    log55.debug(`Using ${isBun3 ? "bun" : "npm"} for installation`);
+    log56.debug(`Using ${isBun3 ? "bun" : "npm"} for installation`);
     const child = spawn4(cmd, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: {
@@ -86772,7 +87084,7 @@ async function installVersion(version) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        log55.info(`✅ Successfully installed ${PACKAGE_NAME2}@${version}`);
+        log56.info(`✅ Successfully installed ${PACKAGE_NAME2}@${version}`);
         saveUpdateState({
           previousVersion: VERSION,
           targetVersion: version,
@@ -86782,20 +87094,20 @@ async function installVersion(version) {
         resolve8({ success: true });
       } else {
         const errorMsg = stderr || stdout || `Exit code: ${code}`;
-        log55.error(`❌ Installation failed: ${errorMsg}`);
+        log56.error(`❌ Installation failed: ${errorMsg}`);
         clearUpdateState();
         resolve8({ success: false, error: errorMsg });
       }
     });
     child.on("error", (err) => {
-      log55.error(`❌ Failed to spawn npm: ${err}`);
+      log56.error(`❌ Failed to spawn npm: ${err}`);
       clearUpdateState();
       resolve8({ success: false, error: err.message });
     });
     setTimeout(() => {
       if (child.exitCode === null) {
         child.kill();
-        log55.error("❌ Installation timed out");
+        log56.error("❌ Installation timed out");
         clearUpdateState();
         resolve8({ success: false, error: "Installation timed out" });
       }
@@ -86839,9 +87151,9 @@ class UpdateInstaller {
 // src/auto-update/respawn.ts
 init_logger();
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync17, statSync as statSync5 } from "fs";
+import { existsSync as existsSync18, statSync as statSync5 } from "fs";
 import { delimiter, join as join17 } from "path";
-var log56 = createLogger("respawn");
+var log57 = createLogger("respawn");
 function decideRespawn(env5 = process.env, isTTY = !!process.stdout.isTTY) {
   if (env5.CLAUDE_THREADS_BIN) {
     return { kind: "exit-for-supervisor", supervisor: "claude-threads-daemon" };
@@ -86860,7 +87172,7 @@ function decideRespawn(env5 = process.env, isTTY = !!process.stdout.isTTY) {
   }
   return { kind: "self-respawn" };
 }
-function resolveClaudeThreadsBin(_env = process.env, _existsSync = existsSync17, _isFileExecutable = isFileExecutable) {
+function resolveClaudeThreadsBin(_env = process.env, _existsSync = existsSync18, _isFileExecutable = isFileExecutable) {
   const isWin2 = process.platform === "win32";
   const names = isWin2 ? ["claude-threads.cmd", "claude-threads.exe", "claude-threads.bat"] : ["claude-threads"];
   const path10 = _env.PATH || _env.Path || "";
@@ -86897,7 +87209,7 @@ function isFileExecutable(path10) {
 }
 function spawnReplacement(argv = process.argv.slice(2), binPath = resolveClaudeThreadsBin()) {
   if (!binPath) {
-    log56.error("Could not resolve claude-threads on PATH; self-respawn aborted");
+    log57.error("Could not resolve claude-threads on PATH; self-respawn aborted");
     return false;
   }
   if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
@@ -86918,23 +87230,23 @@ function spawnReplacement(argv = process.argv.slice(2), binPath = resolveClaudeT
       shell: useShell
     });
   } catch (err) {
-    log56.error(`spawn() threw: ${err instanceof Error ? err.message : String(err)}`);
+    log57.error(`spawn() threw: ${err instanceof Error ? err.message : String(err)}`);
     return false;
   }
   child.once("error", (err) => {
-    log56.error(`Replacement process error: ${err.message}`);
+    log57.error(`Replacement process error: ${err.message}`);
   });
   if (child.pid === undefined) {
-    log56.error("Spawn returned no pid (binary likely not executable)");
+    log57.error("Spawn returned no pid (binary likely not executable)");
     return false;
   }
   child.unref();
-  log56.info(`Spawned replacement pid=${child.pid} from ${binPath}`);
+  log57.info(`Spawned replacement pid=${child.pid} from ${binPath}`);
   return true;
 }
 
 // src/auto-update/manager.ts
-var log57 = createLogger("updater");
+var log58 = createLogger("updater");
 
 class AutoUpdateManager extends EventEmitter9 {
   config;
@@ -86957,23 +87269,23 @@ class AutoUpdateManager extends EventEmitter9 {
   }
   start() {
     if (!this.config.enabled) {
-      log57.info("Auto-update is disabled");
+      log58.info("Auto-update is disabled");
       return;
     }
     const updateResult = this.installer.checkJustUpdated();
     if (updateResult) {
-      log57.info(`\uD83C\uDF89 Updated from v${updateResult.previousVersion} to v${updateResult.currentVersion}`);
+      log58.info(`\uD83C\uDF89 Updated from v${updateResult.previousVersion} to v${updateResult.currentVersion}`);
       this.callbacks.broadcastUpdate((fmt) => `\uD83C\uDF89 ${fmt.formatBold("Bot updated")} from v${updateResult.previousVersion} to v${updateResult.currentVersion}`).catch((err) => {
-        log57.warn(`Failed to broadcast update notification: ${err}`);
+        log58.warn(`Failed to broadcast update notification: ${err}`);
       });
     }
     this.checker.start();
-    log57.info(`\uD83D\uDD04 Auto-update manager started (mode: ${this.config.autoRestartMode})`);
+    log58.info(`\uD83D\uDD04 Auto-update manager started (mode: ${this.config.autoRestartMode})`);
   }
   stop() {
     this.checker.stop();
     this.scheduler.stop();
-    log57.debug("Auto-update manager stopped");
+    log58.debug("Auto-update manager stopped");
   }
   getState() {
     return { ...this.state };
@@ -86987,10 +87299,10 @@ class AutoUpdateManager extends EventEmitter9 {
   async forceUpdate() {
     const updateInfo = this.state.updateInfo || await this.checker.check();
     if (!updateInfo) {
-      log57.info("No update available");
+      log58.info("No update available");
       return;
     }
-    log57.info("Forcing immediate update");
+    log58.info("Forcing immediate update");
     await this.performUpdate(updateInfo);
   }
   deferUpdate(minutes = 60) {
@@ -87056,11 +87368,11 @@ class AutoUpdateManager extends EventEmitter9 {
         await this.callbacks.prepareForRestart();
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
-        log57.error(`prepareForRestart failed: ${reason}`);
+        log58.error(`prepareForRestart failed: ${reason}`);
         await this.callbacks.broadcastUpdate((fmt) => `⚠️ ${fmt.formatBold("Restart aborted")}: shutdown sequence failed (${reason}). Sessions may be in an inconsistent state; please run ${fmt.formatCode("claude-threads")} manually.`).catch(() => {});
         process.exit(1);
       }
-      log57.info(`\uD83D\uDD04 Restarting for update to v${updateInfo.latestVersion}`);
+      log58.info(`\uD83D\uDD04 Restarting for update to v${updateInfo.latestVersion}`);
       process.stdout.write("\x1B[2J\x1B[H");
       process.stdout.write("\x1B[?25h");
       if (decision.kind === "self-respawn") {
@@ -87069,14 +87381,14 @@ class AutoUpdateManager extends EventEmitter9 {
           if (ok) {
             process.exit(0);
           }
-          log57.error("Self-respawn launch failed after binary resolution succeeded");
+          log58.error("Self-respawn launch failed after binary resolution succeeded");
           await this.callbacks.broadcastUpdate((fmt) => `⚠️ ${fmt.formatBold("Auto-restart failed")} after install: please run ${fmt.formatCode("claude-threads")} to bring the bot back. Sessions are persisted and will resume.`).catch(() => {});
         } else {
-          log57.error("claude-threads not found on PATH; manual restart required");
+          log58.error("claude-threads not found on PATH; manual restart required");
         }
         process.exit(0);
       }
-      log57.debug(`Restart handled by supervisor: ${decision.supervisor}`);
+      log58.debug(`Restart handled by supervisor: ${decision.supervisor}`);
       process.exit(RESTART_EXIT_CODE);
     } else {
       const errorMsg = result.error ?? "Unknown error";
@@ -87282,6 +87594,15 @@ async function startWithoutDaemon() {
   if (!newConfig.platforms || newConfig.platforms.length === 0) {
     throw new Error("No platforms configured. Run with --setup to configure.");
   }
+  let mcpPostureWarnings = [];
+  try {
+    mcpPostureWarnings = resolvePlatformMcpPosture(newConfig.platforms, newConfig.mcpServers).warnings;
+  } catch (err) {
+    console.error(red(`  ❌ ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+  for (const w of mcpPostureWarnings)
+    console.warn(w);
   const config = newConfig;
   const firstPlatformConfig = config.platforms[0];
   const initialPermissionMode = resolvePermissionMode({
@@ -87433,6 +87754,9 @@ async function startWithoutDaemon() {
       }
     }
   });
+  for (const w of mcpPostureWarnings) {
+    ui.addLog({ level: "warn", component: "config", message: w });
+  }
   setLogHandler((level, component, message, sessionId) => {
     ui.addLog({ level, component, message, sessionId });
   });
@@ -87655,6 +87979,7 @@ async function startWithoutDaemon() {
   });
   autoUpdateManager.start();
   ui.setReady();
+  session.noticeClaudeAiConnectors();
   const shutdown = async (_signal) => {
     if (isShuttingDown2)
       return;