@wrongstack/core 0.313.0 → 0.313.1

package/dist/chunk-FIV4IJL7.js

@@ -0,0 +1,2263 @@
+import {
+  toolMutates
+} from "./chunk-ZEHUCJHY.js";
+import {
+  allServers
+} from "./chunk-FXQLIX3K.js";
+import {
+  resolvePluginEnablement
+} from "./chunk-3XPVB7BA.js";
+import {
+  CouncilOrchestrator,
+  DEFAULT_COUNCIL_PROFILE_REGISTRY,
+  OneShotOrchestrator,
+  validateCouncilOptions
+} from "./chunk-CE4ZOCOI.js";
+import {
+  isValidMatrixKey,
+  phaseForRole,
+  resolveSubagentModelTarget
+} from "./chunk-2BUUIMQB.js";
+import {
+  AGENT_CATALOG
+} from "./chunk-FHAMQS7Q.js";
+import {
+  ToolCapabilities,
+  getDangerousCapabilities
+} from "./chunk-A455ATZB.js";
+import {
+  normalizeModelRef,
+  parseModelRef
+} from "./chunk-RJIZEJ42.js";
+import {
+  GOVERNED_TOOL_EXECUTOR_META_KEY
+} from "./chunk-XBDP4QPW.js";
+import {
+  mcpQualifiedToolName,
+  mcpServerToolPrefix,
+  readJsonObjectFile,
+  setJsonPath,
+  updateJsonObjectFile,
+  validateAgainstSchema
+} from "./chunk-FFSX2QDQ.js";
+import {
+  toErrorMessage
+} from "./chunk-TBRL2RCC.js";
+import {
+  expectDefined
+} from "./chunk-PFZO3C6H.js";
+
+// src/tools/council-tool.ts
+var COUNCIL_TOOL_NAME = "council";
+var MAX_COUNCIL_TOOL_OPTIONS = 12;
+var MAX_COUNCIL_QUESTION_CHARS = 2e4;
+var MAX_COUNCIL_CONTEXT_CHARS = 8e4;
+var INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    question: {
+      type: "string",
+      description: "The decision or open question for the Council.",
+      maxLength: MAX_COUNCIL_QUESTION_CHARS
+    },
+    context: {
+      type: "string",
+      description: "Optional evidence and constraints. Treated as untrusted quoted data.",
+      maxLength: MAX_COUNCIL_CONTEXT_CHARS
+    },
+    options: {
+      type: "array",
+      maxItems: MAX_COUNCIL_TOOL_OPTIONS,
+      items: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Stable option id." },
+          label: { type: "string", description: "Human-readable option label." },
+          consequence: { type: "string", description: "Optional consequence or trade-off." }
+        },
+        required: ["id", "label"],
+        additionalProperties: false
+      },
+      description: "Optional bounded list of choices. Omit for an open-ended Council answer."
+    },
+    profile: {
+      type: "string",
+      description: 'Registered Council profile id (e.g. "balanced", "fast", "risk-review"). Defaults to the host-configured profile.'
+    }
+  },
+  required: ["question"],
+  additionalProperties: false
+};
+function createCouncilTool(opts) {
+  const orchestrator = new CouncilOrchestrator({
+    ...opts,
+    fallbackProfileManager: opts.fallbackProfileManager
+  });
+  const profiles = opts.profiles ?? DEFAULT_COUNCIL_PROFILE_REGISTRY;
+  const profileIds = profiles.list().map((profile) => profile.id);
+  return {
+    name: COUNCIL_TOOL_NAME,
+    description: "Ask an independent, multi-persona Council to evaluate a decision or synthesize an answer. Uses bounded parallel voters, quorum/veto/weighted resolution, optional judging, model routing, fallback chains, and cancellation.",
+    usageHint: `Use for consequential or disputed decisions that benefit from independent lenses. Provide \`options\` for a vote or omit them for an open answer. Keep context evidence-focused; the Council treats it as untrusted data. Available profiles: ${profileIds.join(", ")}.`,
+    category: "meta",
+    inputSchema: INPUT_SCHEMA,
+    permission: "auto",
+    mutating: false,
+    riskTier: "safe",
+    managesOwnTimeout: true,
+    maxOutputBytes: 256e3,
+    async execute(input, _ctx, { signal }) {
+      const question = {
+        question: input.question,
+        ...input.context ? { context: input.context } : {},
+        ...input.options ? { options: input.options } : {},
+        ...input.profile ? { profile: input.profile } : {},
+        signal
+      };
+      return orchestrator.ask(question);
+    },
+    validate: (input) => validateCouncilToolInput(input, profileIds)
+  };
+}
+function validateCouncilToolInput(input, profileIds) {
+  const errors = [];
+  if (typeof input.profile === "string" && input.profile.trim()) {
+    const id = input.profile.trim();
+    if (!profileIds.includes(id)) {
+      errors.push(`Unknown \`profile\` "${id}". Available: ${profileIds.join(", ")}.`);
+    }
+  }
+  const question = input.question?.trim() ?? "";
+  if (!question) errors.push("`question` must not be empty.");
+  if (question.length > MAX_COUNCIL_QUESTION_CHARS) {
+    errors.push(`\`question\` must not exceed ${MAX_COUNCIL_QUESTION_CHARS} characters.`);
+  }
+  if ((input.context?.length ?? 0) > MAX_COUNCIL_CONTEXT_CHARS) {
+    errors.push(`\`context\` must not exceed ${MAX_COUNCIL_CONTEXT_CHARS} characters.`);
+  }
+  if ((input.options?.length ?? 0) > MAX_COUNCIL_TOOL_OPTIONS) {
+    errors.push(`\`options\` must not contain more than ${MAX_COUNCIL_TOOL_OPTIONS} items.`);
+  }
+  errors.push(...validateCouncilOptions(input.options));
+  return errors;
+}
+
+// src/tools/fallback-manage-helpers.ts
+function normalizeRef(ref) {
+  return ref.trim().replace(/\s*\/\s*/g, "/").replace(/\s+/g, " ");
+}
+function isFavoriteRef(ref, config) {
+  const favorites = config.favoriteModels ?? [];
+  if (favorites.length === 0) return true;
+  const canonical = normalizeModelRef(ref, config.provider);
+  return favorites.some((f) => normalizeModelRef(f, config.provider) === canonical);
+}
+function notFavoriteError(ref, config) {
+  const favorites = config.favoriteModels ?? [];
+  return `"${ref}" is not in your favorites list. ` + (favorites.length === 0 ? 'Add some favorites first with favorite_manage({ action: "add", model: "<provider/model>" }).' : `Current favorites: ${favorites.join(", ") || "(none)"}. Use favorite_manage to add this model first.`);
+}
+function modelList(config) {
+  return config.favoriteModels ?? [];
+}
+function profileList(config) {
+  return config.fallbackProfiles ?? {};
+}
+function chainList(config) {
+  return config.fallbackModels ?? [];
+}
+
+// src/tools/fallback-chain-manage-tool.ts
+var FALLBACK_CHAIN_MANAGE_TOOL_NAME = "fallback_chain_manage";
+var FALLBACK_CHAIN_SCHEMA = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      enum: ["list", "add", "insert", "remove", "clear"],
+      description: "Operation: list (show chain), add (append), insert (insert at position), remove (by index or ref), clear (empty the chain)."
+    },
+    model: {
+      type: "string",
+      description: 'Model reference for add/insert/remove (e.g. "anthropic/claude-haiku-3"). Must be in your favorites list for add/insert. Required for add, insert, and remove (when removing by ref).'
+    },
+    index: {
+      type: "number",
+      description: '1-based insertion position (for action="insert") or removal index (for action="remove"). For insert: the new entry is placed before this position. Omit to append. For remove: alternative to model. Omit to remove by model ref.'
+    }
+  },
+  required: ["action"],
+  additionalProperties: false
+};
+function createFallbackChainManageTool(opts) {
+  return {
+    name: FALLBACK_CHAIN_MANAGE_TOOL_NAME,
+    description: "View or change the active rate-limit fallback chain. When the primary model is overloaded (429/5xx), the agent rotates through this chain in order. Every new entry must be a FAVORITE model \u2014 add it via favorite_manage first. Use insert to place a fallback at a specific position; use remove to delete an entry.",
+    usageHint: '"list" to see the current chain. "add" with a favorite model to append. "insert" with an index (1-based) to place before that position. "remove" with index or model ref. "clear" to empty the chain (auto fallback takes over).',
+    category: "config",
+    inputSchema: FALLBACK_CHAIN_SCHEMA,
+    permission: "auto",
+    mutating: true,
+    riskTier: "standard",
+    icon: "settings",
+    async execute(input) {
+      const config = opts.getConfig();
+      const chain = [...chainList(config)];
+      if (input.action === "list") {
+        if (chain.length === 0) {
+          return {
+            status: "ok",
+            message: 'Fallback chain is empty. Add entries with "add" or enable auto fallback.',
+            chain: []
+          };
+        }
+        const msg = chain.map((ref, i) => `  ${i + 1}. ${ref}`).join("\n");
+        return {
+          status: "ok",
+          message: `Fallback chain (${chain.length}):
+${msg}`,
+          chain: [...chain]
+        };
+      }
+      if (input.action === "add") {
+        if (!input.model) {
+          return {
+            status: "error",
+            message: 'Provide "model" (e.g. "anthropic/claude-haiku-3") to add to the chain.'
+          };
+        }
+        const ref = normalizeRef(input.model);
+        if (!isFavoriteRef(ref, config)) {
+          return { status: "error", message: notFavoriteError(ref, config) };
+        }
+        if (chain.some((e) => normalizeRef(e) === ref)) {
+          return { status: "error", message: `"${ref}" is already in the chain.` };
+        }
+        chain.push(ref);
+        await opts.updateConfig((cfg) => {
+          cfg.fallbackModels = chain;
+        });
+        return {
+          status: "ok",
+          message: `\u2713 Added to chain: ${ref} (position ${chain.length})`,
+          chain: [...chain]
+        };
+      }
+      if (input.action === "insert") {
+        if (!input.model) {
+          return { status: "error", message: 'Provide "model" to insert into the chain.' };
+        }
+        const ref = normalizeRef(input.model);
+        if (!isFavoriteRef(ref, config)) {
+          return { status: "error", message: notFavoriteError(ref, config) };
+        }
+        if (chain.some((e) => normalizeRef(e) === ref)) {
+          return { status: "error", message: `"${ref}" is already in the chain.` };
+        }
+        let pos = chain.length;
+        if (input.index !== void 0) {
+          pos = Math.max(0, Math.min(chain.length, input.index - 1));
+        }
+        chain.splice(pos, 0, ref);
+        await opts.updateConfig((cfg) => {
+          cfg.fallbackModels = chain;
+        });
+        return {
+          status: "ok",
+          message: `\u2713 Inserted at position ${pos + 1}: ${ref}`,
+          chain: [...chain]
+        };
+      }
+      if (input.action === "remove") {
+        if (chain.length === 0) {
+          return { status: "error", message: "Chain is empty \u2014 nothing to remove." };
+        }
+        if (input.index !== void 0) {
+          const idx = input.index - 1;
+          if (idx < 0 || idx >= chain.length) {
+            return {
+              status: "error",
+              message: `Index ${input.index} is out of range (1\u2013${chain.length}).`
+            };
+          }
+          const [removed] = chain.splice(idx, 1);
+          await opts.updateConfig((cfg) => {
+            cfg.fallbackModels = chain;
+          });
+          return { status: "ok", message: `\u2713 Removed: ${removed}`, chain: [...chain] };
+        }
+        if (input.model) {
+          const ref = normalizeRef(input.model);
+          const idx = chain.findIndex((e) => normalizeRef(e) === ref);
+          if (idx === -1) {
+            return { status: "error", message: `"${ref}" not found in chain.` };
+          }
+          const [removed] = chain.splice(idx, 1);
+          await opts.updateConfig((cfg) => {
+            cfg.fallbackModels = chain;
+          });
+          return { status: "ok", message: `\u2713 Removed: ${removed}`, chain: [...chain] };
+        }
+        return { status: "error", message: 'Provide "index" or "model" to remove from the chain.' };
+      }
+      if (input.action === "clear") {
+        if (chain.length === 0) {
+          return { status: "ok", message: "Chain is already empty." };
+        }
+        await opts.updateConfig((cfg) => {
+          cfg.fallbackModels = [];
+        });
+        return {
+          status: "ok",
+          message: "\u2713 Cleared the fallback chain. Auto fallback will take over when enabled."
+        };
+      }
+      return { status: "error", message: `Unknown action: "${input.action}".` };
+    }
+  };
+}
+
+// src/tools/fallback-favorite-manage-tool.ts
+var FAVORITE_MANAGE_TOOL_NAME = "favorite_manage";
+var FAVORITE_MANAGE_SCHEMA = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      enum: ["list", "add", "remove"],
+      description: "Operation to perform: list (show all), add (add a favorite), remove (remove by index or ref)."
+    },
+    model: {
+      type: "string",
+      description: 'Model reference to add/remove (e.g. "anthropic/claude-haiku-3", "openai/gpt-4o-mini"). Required for "add" and "remove" (when removing by ref).'
+    },
+    index: {
+      type: "number",
+      description: '1-based index for removal. Alternative to `model`. Used when action="remove".'
+    }
+  },
+  required: ["action"],
+  additionalProperties: false
+};
+function createFavoriteManageTool(opts) {
+  return {
+    name: FAVORITE_MANAGE_TOOL_NAME,
+    description: "Manage your favorite provider/model list. Favorites are the only models that can be added to fallback chains and profiles. The LLM uses this tool to curate which models are available for fallback and role assignment.",
+    usageHint: 'Start with "list" to see current favorites. Use "add <provider/model>" to add. Use "remove <index|ref>" to remove.',
+    category: "config",
+    inputSchema: FAVORITE_MANAGE_SCHEMA,
+    permission: "auto",
+    mutating: true,
+    riskTier: "standard",
+    icon: "settings",
+    async execute(input) {
+      const config = opts.getConfig();
+      const favorites = [...modelList(config)];
+      if (input.action === "list") {
+        const msg = favorites.length === 0 ? 'No favorites set. Add one with favorite_manage({ action: "add", model: "<provider/model>" }).' : `Favorites (${favorites.length}):
+` + favorites.map((f, i) => `  ${i + 1}. ${f}`).join("\n");
+        return { status: "ok", message: msg, favorites: [...favorites] };
+      }
+      if (input.action === "add") {
+        if (!input.model) {
+          return { status: "error", message: 'Provide "model" (e.g. "anthropic/claude-haiku-3") to add a favorite.' };
+        }
+        const ref = normalizeRef(input.model);
+        const canonical = normalizeModelRef(ref, config.provider);
+        if (favorites.some((f) => normalizeModelRef(f, config.provider) === canonical)) {
+          return { status: "error", message: `"${ref}" is already a favorite.` };
+        }
+        favorites.push(ref);
+        await opts.updateConfig((cfg) => {
+          cfg.favoriteModels = favorites;
+        });
+        return {
+          status: "ok",
+          message: `\u2713 Added favorite: ${ref} (${favorites.length} total)`,
+          favorites: [...favorites]
+        };
+      }
+      if (input.action === "remove") {
+        if (input.index !== void 0) {
+          const idx = input.index - 1;
+          if (idx < 0 || idx >= favorites.length) {
+            return { status: "error", message: `Index ${input.index} is out of range (1\u2013${favorites.length}).` };
+          }
+          const [removed] = favorites.splice(idx, 1);
+          await opts.updateConfig((cfg) => {
+            cfg.favoriteModels = favorites;
+          });
+          return { status: "ok", message: `\u2713 Removed favorite: ${removed}`, favorites: [...favorites] };
+        }
+        if (input.model) {
+          const ref = normalizeRef(input.model);
+          const canonical = normalizeModelRef(ref, config.provider);
+          const idx = favorites.findIndex((f) => normalizeModelRef(f, config.provider) === canonical);
+          if (idx === -1) {
+            return { status: "error", message: `Favorite "${ref}" not found. Use "list" to see all favorites.` };
+          }
+          const [removed] = favorites.splice(idx, 1);
+          await opts.updateConfig((cfg) => {
+            cfg.favoriteModels = favorites;
+          });
+          return { status: "ok", message: `\u2713 Removed favorite: ${removed}`, favorites: [...favorites] };
+        }
+        return { status: "error", message: 'Provide either "model" or "index" to remove a favorite.' };
+      }
+      return { status: "error", message: `Unknown action: "${input.action}". Use "list", "add", or "remove".` };
+    }
+  };
+}
+
+// src/tools/fallback-profile-manage-tool.ts
+var FALLBACK_PROFILE_MANAGE_TOOL_NAME = "fallback_profile_manage";
+var FALLBACK_PROFILE_SCHEMA = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      enum: ["list", "set", "delete"],
+      description: "Operation: list (show all profiles), set (create/update), delete (remove a profile)."
+    },
+    name: {
+      type: "string",
+      description: 'Profile name (e.g. "fast", "economy", "reliable"). Required for "set" and "delete".'
+    },
+    chain: {
+      type: "array",
+      items: { type: "string" },
+      description: 'Ordered list of model references for the profile. Each entry must be a favorite model. Required for "set". Example: ["anthropic/claude-haiku-3", "openai/gpt-4o-mini"].'
+    }
+  },
+  required: ["action"],
+  additionalProperties: false
+};
+function createFallbackProfileManageTool(opts) {
+  return {
+    name: FALLBACK_PROFILE_MANAGE_TOOL_NAME,
+    description: "Manage named fallback profiles. A profile is a reusable, ordered list of model references that can be assigned to agent roles. Every entry in a profile must be a FAVORITE model \u2014 add it via favorite_manage first. Use /setmodel or agent_model_assign to assign a profile to a role.",
+    usageHint: '"list" to see all profiles. "set" with name and chain (array of model refs) to create or replace a profile. "delete" with name to remove a profile.',
+    category: "config",
+    inputSchema: FALLBACK_PROFILE_SCHEMA,
+    permission: "auto",
+    mutating: true,
+    riskTier: "standard",
+    icon: "settings",
+    async execute(input) {
+      const config = opts.getConfig();
+      const profiles = { ...profileList(config) };
+      if (input.action === "list") {
+        const names = Object.keys(profiles);
+        if (names.length === 0) {
+          return {
+            status: "ok",
+            message: 'No fallback profiles. Create one with "set".',
+            profiles: {}
+          };
+        }
+        const msg = names.sort().map((name) => `  ${name} \u2192 ${profiles[name]?.join(" \u2192 ") || "(empty)"}`).join("\n");
+        return { status: "ok", message: `Fallback profiles:
+${msg}`, profiles: { ...profiles } };
+      }
+      if (input.action === "set") {
+        if (!input.name) {
+          return { status: "error", message: 'Provide "name" for the profile (e.g. "fast").' };
+        }
+        if (!input.chain || input.chain.length === 0) {
+          return { status: "error", message: 'Provide "chain" \u2014 a non-empty array of model references.' };
+        }
+        const invalid = [];
+        for (const ref of input.chain) {
+          if (!isFavoriteRef(ref, config)) {
+            invalid.push(ref);
+          }
+        }
+        if (invalid.length > 0) {
+          return {
+            status: "error",
+            message: `The following entries are not in your favorites list:
+  ${invalid.join("\n  ")}
+
+Add them first with favorite_manage({ action: "add", model: "<ref>" }).`
+          };
+        }
+        profiles[input.name] = [...input.chain];
+        await opts.updateConfig((cfg) => {
+          cfg.fallbackProfiles = profiles;
+        });
+        return {
+          status: "ok",
+          message: `\u2713 Profile "${input.name}" \u2192 ${input.chain.join(" \u2192 ")}`,
+          profiles: { ...profiles }
+        };
+      }
+      if (input.action === "delete") {
+        if (!input.name) {
+          return { status: "error", message: 'Provide "name" of the profile to delete.' };
+        }
+        if (!(input.name in profiles)) {
+          return { status: "error", message: `Profile "${input.name}" not found.` };
+        }
+        delete profiles[input.name];
+        await opts.updateConfig((cfg) => {
+          cfg.fallbackProfiles = profiles;
+        });
+        return {
+          status: "ok",
+          message: `\u2713 Deleted profile: ${input.name}`,
+          profiles: { ...profiles }
+        };
+      }
+      return { status: "error", message: `Unknown action: "${input.action}".` };
+    }
+  };
+}
+
+// src/tools/fallback-agent-model-assign-tool.ts
+var AGENT_MODEL_ASSIGN_TOOL_NAME = "agent_model_assign";
+var AGENT_MODEL_ASSIGN_SCHEMA = {
+  type: "object",
+  properties: {
+    role: {
+      type: "string",
+      description: 'Matrix key: a catalog role (e.g. "security-scanner", "bug-hunter"), a phase name (e.g. "review", "implementation"), or "*" for the fleet-wide default.'
+    },
+    provider: {
+      type: "string",
+      description: 'Provider id (e.g. "anthropic", "openai"). When omitted, the leader provider is used. The provider.model combination must be in your favorites list.'
+    },
+    model: {
+      type: "string",
+      description: 'Model id (e.g. "claude-haiku-3", "gpt-4o-mini"). When omitted together with provider, the role falls back to the leader model. Must be in your favorites list.'
+    },
+    profile: {
+      type: "string",
+      description: 'Named fallback profile to assign (e.g. "fast", "economy"). Alternative to provider+model. When set, the first profile entry becomes the primary model and the rest are the fallback chain.'
+    },
+    clear: {
+      type: "boolean",
+      description: "Set to true to remove the matrix entry for this role (it will fall through to phase/*/leader)."
+    }
+  },
+  required: ["role"],
+  additionalProperties: false
+};
+function createAgentModelAssignTool(opts) {
+  return {
+    name: AGENT_MODEL_ASSIGN_TOOL_NAME,
+    description: "Assign a provider/model or a fallback profile to a specific agent role, phase, or the fleet-wide default. This is the LLM-accessible equivalent of /setmodel set. The provider+model combination must be in your favorites list (unless only clearing). Resolution precedence: exact role \u2192 phase \u2192 * \u2192 leader model.",
+    usageHint: 'Use "list" as role to see current assignments. Set with role + model, or role + provider + model, or role + profile. Set role + clear=true to remove a matrix entry. The provider/model must be a favorite.',
+    category: "config",
+    inputSchema: AGENT_MODEL_ASSIGN_SCHEMA,
+    permission: "auto",
+    mutating: true,
+    riskTier: "standard",
+    icon: "settings",
+    async execute(input) {
+      const config = opts.getConfig();
+      const modes = [input.clear ? "clear" : null, input.profile ? "profile" : null, input.model ? "model" : null].filter(Boolean);
+      if (modes.length > 1) {
+        return {
+          status: "error",
+          message: `Conflicting assignment modes: ${modes.join(" + ")}. Use exactly one: clear=true, profile="name", or model="name" (optionally with provider).`
+        };
+      }
+      if (input.role === "list") {
+        const matrix = config.modelMatrix ?? {};
+        const keys = Object.keys(matrix);
+        if (keys.length === 0) {
+          return { status: "ok", message: "No matrix assignments. All roles use the leader model." };
+        }
+        const msg = keys.sort().map((k) => `  ${k} \u2192 ${JSON.stringify(matrix[k])}`).join("\n");
+        return { status: "ok", message: `Model matrix (${keys.length} entries):
+${msg}` };
+      }
+      if (!isValidMatrixKey(input.role)) {
+        return {
+          status: "error",
+          message: `"${input.role}" is not a valid matrix key. Use a catalog role (e.g. "security-scanner"), a phase (e.g. "review"), or "*" for the fleet-wide default.`
+        };
+      }
+      if (input.clear) {
+        const matrix = { ...config.modelMatrix ?? {} };
+        if (!(input.role in matrix)) {
+          return { status: "ok", message: `No matrix entry for "${input.role}" to clear.` };
+        }
+        delete matrix[input.role];
+        await opts.updateConfig((cfg) => {
+          cfg.modelMatrix = matrix;
+        });
+        return { status: "ok", message: `\u2713 Cleared matrix entry for "${input.role}".` };
+      }
+      if (!input.model && !input.profile && !input.provider) {
+        const matrix = config.modelMatrix ?? {};
+        const entry = matrix[input.role];
+        if (!entry) {
+          return { status: "ok", message: `No specific assignment for "${input.role}". It uses the leader model or phase/* fallback.` };
+        }
+        return { status: "ok", message: `"${input.role}" \u2192 ${JSON.stringify(entry)}` };
+      }
+      if (input.profile && !input.model) {
+        const profiles = profileList(config);
+        if (!profiles[input.profile]) {
+          return { status: "error", message: `Profile "${input.profile}" not found. Create it with fallback_profile_manage first.` };
+        }
+        const matrix = { ...config.modelMatrix ?? {} };
+        matrix[input.role] = { fallbackProfile: input.profile };
+        await opts.updateConfig((cfg) => {
+          cfg.modelMatrix = matrix;
+        });
+        return { status: "ok", message: `\u2713 "${input.role}" \u2192 profile: ${input.profile}` };
+      }
+      if (input.model) {
+        const effectiveProvider = input.provider ?? config.provider;
+        const ref = `${effectiveProvider}/${input.model}`;
+        if (!isFavoriteRef(ref, config)) {
+          return { status: "error", message: notFavoriteError(ref, config) };
+        }
+        const matrix = { ...config.modelMatrix ?? {} };
+        const previousRuntime = matrix[input.role]?.modelRuntime;
+        matrix[input.role] = input.provider ? { provider: input.provider, model: input.model, ...previousRuntime ? { modelRuntime: previousRuntime } : {} } : { model: input.model, ...previousRuntime ? { modelRuntime: previousRuntime } : {} };
+        await opts.updateConfig((cfg) => {
+          cfg.modelMatrix = matrix;
+        });
+        const display = input.provider ? `${input.provider}/${input.model}` : `${input.model} (leader provider)`;
+        return { status: "ok", message: `\u2713 "${input.role}" \u2192 ${display}` };
+      }
+      return { status: "error", message: "Provide model, profile, or clear=true for the role assignment." };
+    }
+  };
+}
+
+// src/tools/fallback-provider-manage-tool.ts
+var PROVIDER_MANAGE_TOOL_NAME = "provider_manage";
+var PROVIDER_MANAGE_SCHEMA = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      enum: ["list", "add", "configure", "remove"],
+      description: "Operation: list (show all providers), add (add a new provider config), configure (update fields of an existing provider), remove (delete a provider config)."
+    },
+    provider: {
+      type: "string",
+      description: 'Provider id (e.g. "openai", "anthropic"). Required for all actions except list.'
+    },
+    type: {
+      type: "string",
+      description: 'Provider type (e.g. "openai", "anthropic"). Required for "add".'
+    },
+    models: {
+      type: "array",
+      items: { type: "string" },
+      description: "Model list to restrict visibility for this provider. Optional for add/configure."
+    },
+    baseUrl: {
+      type: "string",
+      description: "Custom base URL (e.g. for self-hosted endpoints). Optional."
+    },
+    family: {
+      type: "string",
+      description: 'Wire-family override (e.g. "openai", "openai-compatible", "anthropic"). When set, the provider can be constructed without a catalog entry.'
+    },
+    envVars: {
+      type: "array",
+      items: { type: "string" },
+      description: "Custom env var names to probe when apiKey is missing. Optional."
+    },
+    autoDiscoverModels: {
+      type: "boolean",
+      description: "Auto-fetch model list from {baseUrl}/models. Optional."
+    },
+    apiKey: {
+      type: "string",
+      description: "**NOT RECOMMENDED** \u2014 use provider_key_set instead. The LLM output may contain this value; use env var references for safety."
+    }
+  },
+  required: ["action"],
+  additionalProperties: false
+};
+var CREDENTIAL_SELECTOR_FIELDS = ["apiKey", "apiKeys", "activeKey", "envVars"];
+function envVarsClaimedByOtherProviders(providers, exceptProvider) {
+  const claimed = /* @__PURE__ */ new Map();
+  for (const [id, entry] of Object.entries(providers)) {
+    if (id === exceptProvider) continue;
+    const names = entry?.["envVars"];
+    if (!Array.isArray(names)) continue;
+    for (const name of names) {
+      if (typeof name === "string" && !claimed.has(name)) claimed.set(name, id);
+    }
+  }
+  return claimed;
+}
+function rejectBorrowedEnvVars(providers, provider, requested) {
+  if (!requested) return null;
+  const claimed = envVarsClaimedByOtherProviders(providers, provider);
+  for (const name of requested) {
+    const owner = typeof name === "string" ? claimed.get(name) : void 0;
+    if (owner !== void 0) {
+      return `Environment variable "${String(name)}" already supplies the key for provider "${owner}". Reading another provider's credential from "${provider}" is not allowed; use provider_key_set to give "${provider}" its own key.`;
+    }
+  }
+  return null;
+}
+function validateProviderBaseUrl(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return `Invalid baseUrl: ${raw} is not a valid URL.`;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return `Invalid baseUrl: ${url.protocol} is not supported \u2014 use http: or https:.`;
+  }
+  if (url.username || url.password) {
+    return "Invalid baseUrl: credentials embedded in the URL are not accepted.";
+  }
+  return null;
+}
+function createProviderManageTool(opts) {
+  return {
+    name: PROVIDER_MANAGE_TOOL_NAME,
+    description: "View or configure provider entries. List all configured providers with their type, model lists, base URL, and key status. Add new providers, update their settings, or remove unused ones. API keys should be set via provider_key_set instead of passing them here \u2014 they are visible in the LLM output.",
+    usageHint: '"list" to see all providers. "add" with provider id and type to create. "configure" to update models, baseUrl, family, or envVars. "remove" to delete a provider. Use provider_key_set for API key management.',
+    category: "config",
+    inputSchema: PROVIDER_MANAGE_SCHEMA,
+    permission: "auto",
+    mutating: true,
+    subjectKey: "baseUrl",
+    riskTier: "standard",
+    icon: "settings",
+    async execute(input) {
+      const config = opts.getConfig();
+      const providers = {
+        ...config.providers ?? {}
+      };
+      const leaderProvider = config.provider ?? "";
+      if (input.action === "list") {
+        const ids = Object.keys(providers);
+        if (ids.length === 0) {
+          return { status: "ok", message: "No providers configured.", providers: [] };
+        }
+        const msg = ids.sort().map((id) => {
+          const entry = providers[id] ?? {};
+          const type = entry.type ?? "(unknown)";
+          const models = Array.isArray(entry.models) ? entry.models.join(", ") : "(all)";
+          const hasKey = entry.apiKey ? "\u2713" : entry.apiKeys ? "\u2713" : "\u2717";
+          const prefix = id === leaderProvider ? "\u2605 " : "  ";
+          const baseUrl = entry.baseUrl ? ` url:${entry.baseUrl}` : "";
+          const family = entry.family ? ` family:${entry.family}` : "";
+          return `  ${prefix}${id} (${type}) key:${hasKey} models:[${models}]${baseUrl}${family}`;
+        }).join("\n");
+        return {
+          status: "ok",
+          message: `Providers (leader: ${leaderProvider}):
+${msg}`,
+          providers: ids
+        };
+      }
+      if (input.action === "add") {
+        if (!input.provider || !input.type) {
+          return { status: "error", message: 'Provide "provider" (id) and "type" to add a provider.' };
+        }
+        if (providers[input.provider]) {
+          return { status: "error", message: `Provider "${input.provider}" already exists. Use "configure" to update.` };
+        }
+        if (input.baseUrl) {
+          const invalid = validateProviderBaseUrl(input.baseUrl);
+          if (invalid) return { status: "error", message: invalid };
+        }
+        const borrowed = rejectBorrowedEnvVars(providers, input.provider, input.envVars);
+        if (borrowed) return { status: "error", message: borrowed };
+        const entry = { type: input.type };
+        if (input.models) entry.models = input.models;
+        if (input.baseUrl) entry.baseUrl = input.baseUrl;
+        if (input.family) entry.family = input.family;
+        if (input.envVars) entry.envVars = input.envVars;
+        if (input.autoDiscoverModels !== void 0) entry.autoDiscoverModels = input.autoDiscoverModels;
+        if (input.apiKey) entry.apiKey = input.apiKey;
+        providers[input.provider] = entry;
+        await opts.updateConfig((cfg) => {
+          cfg.providers = providers;
+        });
+        return { status: "ok", message: `\u2713 Added provider: ${input.provider} (type: ${input.type})` };
+      }
+      if (input.action === "configure") {
+        if (!input.provider) {
+          return { status: "error", message: 'Provide "provider" id to configure.' };
+        }
+        if (!providers[input.provider]) {
+          return { status: "error", message: `Provider "${input.provider}" not found. Use "add" first or check "list".` };
+        }
+        if (input.baseUrl) {
+          const invalid = validateProviderBaseUrl(input.baseUrl);
+          if (invalid) return { status: "error", message: invalid };
+        }
+        const previous = { ...providers[input.provider] };
+        const entry = { ...previous };
+        if (input.models !== void 0) entry.models = input.models;
+        if (input.baseUrl !== void 0) entry.baseUrl = input.baseUrl || void 0;
+        if (input.family !== void 0) entry.family = input.family || void 0;
+        if (input.envVars !== void 0) entry.envVars = input.envVars;
+        if (input.autoDiscoverModels !== void 0) entry.autoDiscoverModels = input.autoDiscoverModels;
+        if (input.apiKey !== void 0) entry.apiKey = input.apiKey || void 0;
+        const endpointChanged = input.baseUrl !== void 0 && (entry.baseUrl ?? void 0) !== (previous.baseUrl ?? void 0);
+        const explicitlySupplied = /* @__PURE__ */ new Set([
+          ...input.apiKey !== void 0 ? ["apiKey"] : [],
+          ...input.envVars !== void 0 ? ["envVars"] : []
+        ]);
+        const droppedFields = endpointChanged ? CREDENTIAL_SELECTOR_FIELDS.filter(
+          (field) => !explicitlySupplied.has(field) && previous[field] !== void 0
+        ) : [];
+        for (const field of droppedFields) entry[field] = void 0;
+        const borrowed = rejectBorrowedEnvVars(providers, input.provider, input.envVars);
+        if (borrowed) return { status: "error", message: borrowed };
+        providers[input.provider] = entry;
+        await opts.updateConfig((cfg) => {
+          cfg.providers = providers;
+        });
+        const updated = Object.keys({ ...entry }).filter((k) => k !== "apiKey").join(", ");
+        const keyNote = droppedFields.length > 0 ? ` \u2014 cleared ${droppedFields.join(", ")} because the base URL changed; set the key again with provider_key_set` : "";
+        return { status: "ok", message: `\u2713 Updated ${input.provider}: ${updated}${keyNote}` };
+      }
+      if (input.action === "remove") {
+        if (!input.provider) {
+          return { status: "error", message: 'Provide "provider" id to remove.' };
+        }
+        if (!providers[input.provider]) {
+          return { status: "error", message: `Provider "${input.provider}" not found.` };
+        }
+        if (input.provider === leaderProvider) {
+          return { status: "error", message: `Cannot remove the active leader provider "${input.provider}". Switch the leader first.` };
+        }
+        delete providers[input.provider];
+        await opts.updateConfig((cfg) => {
+          cfg.providers = providers;
+        });
+        return { status: "ok", message: `\u2713 Removed provider: ${input.provider}` };
+      }
+      return { status: "error", message: `Unknown action: "${input.action}".` };
+    }
+  };
+}
+
+// src/tools/fallback-provider-key-store.ts
+async function storeProviderKey(providers, input, keyValue, opts) {
+  const providerId = input.provider;
+  if (!providers[providerId]) {
+    providers[providerId] = { type: providerId };
+  }
+  const entry = providers[providerId];
+  const existingKeys = Array.isArray(entry.apiKeys) ? [...entry.apiKeys] : [];
+  const label = input.label ?? "default";
+  existingKeys.push({
+    label,
+    apiKey: keyValue,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  entry.apiKeys = existingKeys;
+  delete entry.apiKey;
+  if (input.setActive !== false) {
+    entry.activeKey = label;
+  }
+  providers[providerId] = entry;
+  await opts.updateConfig((cfg) => {
+    cfg.providers = providers;
+  });
+  const sourceName = input.envVar ? `env:${input.envVar}` : "direct key";
+  return {
+    status: "ok",
+    message: `\u2713 API key stored for "${providerId}" from ${sourceName}. Now add models to favorites with favorite_manage to use them in fallback chains.`
+  };
+}
+
+// src/tools/fallback-provider-key-set-tool.ts
+var PROVIDER_KEY_SET_TOOL_NAME = "provider_key_set";
+var PROVIDER_KEY_SET_SCHEMA = {
+  type: "object",
+  properties: {
+    provider: {
+      type: "string",
+      description: 'Provider id (e.g. "openai", "anthropic"). Required.'
+    },
+    key: {
+      type: "string",
+      description: "The API key value. When provided directly, it is stored as the provider's primary key. \u26A0\uFE0F This value is visible to the LLM \u2014 for secrets, omit this field and use envVar instead, or provide the key through the interactive prompt."
+    },
+    envVar: {
+      type: "string",
+      description: 'Environment variable name that contains the key (e.g. "OPENAI_API_KEY"). The key is read from the environment at tool execution time \u2014 the value is never visible to the LLM. Preferred over passing the key directly.'
+    },
+    label: {
+      type: "string",
+      description: 'Optional label for the key entry (e.g. "work", "personal"). Useful when managing multiple keys.'
+    },
+    setActive: {
+      type: "boolean",
+      description: "Whether to make this the active key. Default: true."
+    }
+  },
+  required: ["provider"],
+  additionalProperties: false
+};
+function createProviderKeySetTool(opts) {
+  return {
+    name: PROVIDER_KEY_SET_TOOL_NAME,
+    description: "Set the API key for a provider. For security, prefer using envVar (reads from environment variable, value never visible to the LLM) over passing the key directly. When neither key nor envVar is provided, the tool returns a prompt for interactive key entry \u2014 the UI will present an input field and the key is stored without LLM visibility.\n\nAfter setting a key, the provider becomes usable for model assignments and fallback chains. Add its models to favorites with favorite_manage to unlock them for fallback/profile use.",
+    usageHint: 'Preferred: provider_key_set({ provider: "openai", envVar: "OPENAI_API_KEY" }). For interactive input: provider_key_set({ provider: "openai" }) \u2014 the UI will prompt. Direct key: provider_key_set({ provider: "openai", key: "sk-..." }) \u2014 visible to LLM.',
+    category: "config",
+    inputSchema: PROVIDER_KEY_SET_SCHEMA,
+    permission: "confirm",
+    mutating: true,
+    riskTier: "standard",
+    icon: "settings",
+    async execute(input) {
+      const config = opts.getConfig();
+      const providers = {
+        ...config.providers ?? {}
+      };
+      if (input.key && input.envVar) {
+        return {
+          status: "error",
+          message: "Provide either key (direct, visible to LLM) OR envVar (reads from environment, never visible to LLM), not both. Use envVar for security."
+        };
+      }
+      if (!input.key && !input.envVar) {
+        if (opts.requestInput) {
+          try {
+            const value = await opts.requestInput(
+              `Enter API key for "${input.provider}" (will be stored securely, LLM will not see it):`
+            );
+            if (!value || value.trim().length === 0) {
+              return { status: "error", message: "No key was entered. Operation cancelled." };
+            }
+            return storeProviderKey(providers, input, value.trim(), opts);
+          } catch (err) {
+            return {
+              status: "error",
+              message: `Interactive input failed or was cancelled: ${err instanceof Error ? err.message : String(err)}`
+            };
+          }
+        }
+        return {
+          status: "needs_key",
+          message: `To set the API key for "${input.provider}", use provider_key_set with either:
+  1. envVar: "${input.provider.toUpperCase()}_API_KEY" (reads from env, LLM never sees it)
+  2. key: "sk-..." (pass directly, visible to LLM)
+
+Interactive key entry is handled by the UI \u2014 enter your key through the prompt surface.`
+        };
+      }
+      if (input.envVar) {
+        const envValue = process.env[input.envVar];
+        if (!envValue) {
+          return {
+            status: "error",
+            message: `Environment variable "${input.envVar}" is not set or empty. Set it first or use a different envVar.`
+          };
+        }
+        return storeProviderKey(providers, input, envValue, opts);
+      }
+      if (input.key) {
+        return storeProviderKey(providers, input, input.key, opts);
+      }
+      return { status: "error", message: "Unexpected \u2014 no key source available." };
+    }
+  };
+}
+
+// src/tools/fallback-leader-model-set-tool.ts
+var LEADER_MODEL_SET_TOOL_NAME = "leader_model_set";
+var LEADER_MODEL_SET_SCHEMA = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      enum: ["show", "set", "profile", "toggle"],
+      description: "Operation: show (current leader + toggles), set (change provider/model), profile (set from a fallback profile), toggle (change fallbackAuto/favoriteModelsOnly)."
+    },
+    provider: {
+      type: "string",
+      description: 'Provider id for the leader (e.g. "anthropic", "openai"). Required for "set".'
+    },
+    model: {
+      type: "string",
+      description: 'Model id for the leader (e.g. "claude-sonnet-4-20250514"). Required for "set".'
+    },
+    profile: {
+      type: "string",
+      description: 'Fallback profile name to derive the leader + chain from. Required for "profile".'
+    },
+    toggle: {
+      type: "string",
+      enum: ["fallbackAuto", "favoriteModelsOnly"],
+      description: 'Which toggle to change. Required for "toggle".'
+    },
+    value: {
+      type: "boolean",
+      description: 'New value for the toggle. Required for "toggle".'
+    }
+  },
+  additionalProperties: false
+};
+function createLeaderModelSetTool(opts) {
+  return {
+    name: LEADER_MODEL_SET_TOOL_NAME,
+    description: 'View or change the leader provider/model and system toggles. The leader is the primary model used for the main agent interactions. "set" changes it directly. "profile" derives it from a named fallback profile (first entry becomes leader, rest become the fallback chain). "toggle" controls fallbackAuto (smart default fallback) and favoriteModelsOnly (restrict auto-fallback to favorites only).',
+    usageHint: '"show" to see current state. "set" with provider+model to change. "profile" with name to derive from a profile. "toggle" with toggle name and value to change a boolean setting.',
+    category: "config",
+    inputSchema: LEADER_MODEL_SET_SCHEMA,
+    permission: "auto",
+    mutating: true,
+    riskTier: "standard",
+    icon: "settings",
+    async execute(input) {
+      const config = opts.getConfig();
+      if (input.action === "show") {
+        const lines = [
+          `  ${"leader"}: ${config.provider}/${config.model}`,
+          `  ${"fallbackAuto"}: ${config.fallbackAuto !== false ? "on" : "off"}`,
+          `  ${"favoriteModelsOnly"}: ${config.favoriteModelsOnly ? "on" : "off"}`,
+          "",
+          `  ${"fallback models"}: ${(config.fallbackModels ?? []).length > 0 ? (config.fallbackModels ?? []).join(" \u2192 ") : "empty (auto fallback)"}`,
+          `  ${"favorites"}: ${(config.favoriteModels ?? []).length > 0 ? `${(config.favoriteModels ?? []).length} models` : "(none)"}`,
+          `  ${"refiner"}: ${config.autonomy?.refinerProvider ? `${config.autonomy.refinerProvider}/${config.autonomy.refinerModel ?? "(default model)"}` : "(same as leader)"}`
+        ];
+        return { status: "ok", message: lines.join("\n") };
+      }
+      if (input.action === "set") {
+        if (!input.provider || !input.model) {
+          return { status: "error", message: 'Provide "provider" and "model" for the leader.' };
+        }
+        if (opts.switchProviderAndModel) {
+          const switchError = await opts.switchProviderAndModel(input.provider, input.model);
+          if (switchError) {
+            return {
+              status: "error",
+              message: `Could not switch to ${input.provider}/${input.model}: ${switchError}. Config was not changed.`
+            };
+          }
+        }
+        await opts.updateConfig((cfg) => {
+          cfg.provider = input.provider;
+          cfg.model = input.model;
+        });
+        const liveNote = opts.switchProviderAndModel ? "" : " (config updated \u2014 the live session keeps its current model until restart or /setmodel)";
+        return { status: "ok", message: `\u2713 Leader \u2192 ${input.provider}/${input.model}${liveNote}` };
+      }
+      if (input.action === "profile") {
+        if (!input.profile) {
+          return { status: "error", message: 'Provide "profile" name to derive the leader from.' };
+        }
+        const profiles = config.fallbackProfiles ?? {};
+        const chain = profiles[input.profile];
+        if (!chain || chain.length === 0) {
+          return { status: "error", message: `Profile "${input.profile}" not found or empty.` };
+        }
+        const first = chain[0];
+        const p = parseModelRef(first);
+        const provider = p.provider ?? config.provider;
+        const model = p.model;
+        if (!model) {
+          return { status: "error", message: `Cannot parse "${first}" as a valid model reference.` };
+        }
+        const rest = chain.slice(1);
+        if (opts.switchProviderAndModel) {
+          const switchError = await opts.switchProviderAndModel(provider, model);
+          if (switchError) {
+            return {
+              status: "error",
+              message: `Could not switch to ${provider}/${model}: ${switchError}. Config was not changed.`
+            };
+          }
+        }
+        await opts.updateConfig((cfg) => {
+          cfg.provider = provider;
+          cfg.model = model;
+          cfg.fallbackModels = rest;
+        });
+        const profileLiveNote = opts.switchProviderAndModel ? "" : "\n  (config updated \u2014 the live session keeps its current model until restart or /setmodel)";
+        return {
+          status: "ok",
+          message: `\u2713 Leader \u2192 ${provider}/${model} (profile: ${input.profile})` + (rest.length > 0 ? `
+  Fallback chain: ${rest.join(" \u2192 ")}` : "") + profileLiveNote
+        };
+      }
+      if (input.action === "toggle") {
+        if (!input.toggle || input.value === void 0) {
+          return { status: "error", message: 'Provide "toggle" (fallbackAuto | favoriteModelsOnly) and "value" (boolean).' };
+        }
+        await opts.updateConfig((cfg) => {
+          if (input.toggle === "fallbackAuto") {
+            cfg.fallbackAuto = input.value;
+          } else if (input.toggle === "favoriteModelsOnly") {
+            cfg.favoriteModelsOnly = input.value;
+          }
+        });
+        return {
+          status: "ok",
+          message: `\u2713 ${input.toggle} \u2192 ${input.value ? "on" : "off"}`
+        };
+      }
+      return { status: "error", message: `Unknown action: "${input.action}".` };
+    }
+  };
+}
+
+// src/tools/fallback-system-config-view-tool.ts
+var SYSTEM_CONFIG_VIEW_TOOL_NAME = "system_config_view";
+var SYSTEM_CONFIG_VIEW_SCHEMA = {
+  type: "object",
+  properties: {
+    section: {
+      type: "string",
+      enum: [
+        "all",
+        "providers",
+        "models",
+        "fallbacks",
+        "matrix",
+        "agents",
+        "fleet",
+        "refiner",
+        "doctor"
+      ],
+      description: "Which section to show: all (everything), providers (configured providers + keys), models (favorites + leader), fallbacks (chain + profiles + toggles), matrix (per-role assignments), agents (every catalog agent with resolved model), fleet (concurrency + lifetime spawn/token/cost budgets), refiner (goal refinement config), doctor (validate config and show issues/warnings). Default: all."
+    }
+  },
+  additionalProperties: false
+};
+function createSystemConfigViewTool(opts) {
+  return {
+    name: SYSTEM_CONFIG_VIEW_TOOL_NAME,
+    description: "Get a comprehensive view of all provider, model, fallback, and matrix configuration. Shows the complete state across all configurable areas so you can see what is available and make informed decisions when assigning models, creating fallback profiles, or managing providers. Use the section parameter to focus on specific areas.",
+    usageHint: '"section: all" for everything. "section: providers" for configured providers and key status. "section: models" for leader model and favorites. "section: fallbacks" for chains, profiles, and toggles. "section: matrix" for per-role assignments. "section: refiner" for goal refinement config.',
+    category: "config",
+    inputSchema: SYSTEM_CONFIG_VIEW_SCHEMA,
+    permission: "auto",
+    mutating: false,
+    riskTier: "safe",
+    icon: "settings",
+    async execute(input) {
+      const config = opts.getConfig();
+      const section = input.section ?? "all";
+      const sections = [];
+      const addSection = (title, content) => {
+        sections.push(`\u2500\u2500 ${title} \u2500\u2500
+${content}`);
+      };
+      addSection("Leader", `  ${config.provider}/${config.model}`);
+      if (section === "all" || section === "providers") {
+        const providers = config.providers ?? {};
+        const ids = Object.keys(providers);
+        if (ids.length === 0) {
+          addSection("Providers", "  (none configured)");
+        } else {
+          const lines = ids.sort().map((id) => {
+            const e = providers[id] ?? {};
+            const type = e.type ?? "?";
+            const models = Array.isArray(e.models) ? `[${e.models.join(", ")}]` : "(all)";
+            const hasKey = e.apiKey || Array.isArray(e.apiKeys) && e.apiKeys.length > 0 ? "\u2713" : "\u2717";
+            const baseUrl = e.baseUrl ? ` url:${e.baseUrl}` : "";
+            const family = e.family ? ` family:${e.family}` : "";
+            const envVars = Array.isArray(e.envVars) ? ` env:[${e.envVars.join(", ")}]` : "";
+            return `  ${id === config.provider ? "\u2605" : " "} ${id} (${type}) key:${hasKey} models:${models}${baseUrl}${family}${envVars}`;
+          });
+          addSection("Providers", lines.join("\n"));
+        }
+      }
+      if (section === "all" || section === "models") {
+        const favorites = config.favoriteModels ?? [];
+        addSection(
+          "Favorites",
+          favorites.length > 0 ? favorites.map((f, i) => `  ${i + 1}. ${f}`).join("\n") : "  (none \u2014 use favorite_manage to add)"
+        );
+        addSection(
+          "Settings",
+          `  fallbackAuto: ${config.fallbackAuto !== false ? "on" : "off"}
+  favoriteModelsOnly: ${config.favoriteModelsOnly ? "on" : "off"}`
+        );
+      }
+      if (section === "all" || section === "fallbacks") {
+        const fallbackModels = config.fallbackModels ?? [];
+        const profiles = config.fallbackProfiles ?? {};
+        addSection("Continuity Bridge", `  ${config.fallbackBridge?.trim() || "(disabled)"}`);
+        addSection(
+          "Fallback Chain",
+          fallbackModels.length > 0 ? fallbackModels.map((f, i) => `  ${i + 1}. ${f}`).join("\n") : "  (empty \u2014 auto fallback applies when fallbackAuto is on)"
+        );
+        const profileNames = Object.keys(profiles);
+        addSection(
+          "Fallback Profiles",
+          profileNames.length > 0 ? profileNames.sort().map((n) => `  ${n} \u2192 ${profiles[n]?.join(" \u2192 ") ?? "(empty)"}`).join("\n") : "  (none)"
+        );
+      }
+      if (section === "all" || section === "matrix") {
+        const matrix = config.modelMatrix ?? {};
+        const keys = Object.keys(matrix);
+        addSection(
+          "Model Matrix (role assignments)",
+          keys.length > 0 ? keys.sort().map((k) => `  ${k} \u2192 ${JSON.stringify(matrix[k])}`).join("\n") : "  (empty \u2014 all roles use the leader model)"
+        );
+      }
+      if (section === "all" || section === "agents") {
+        const roleNames = Object.keys(AGENT_CATALOG).sort();
+        const lines = roleNames.map((role) => {
+          const phase = phaseForRole(role) ?? "?";
+          const target = resolveSubagentModelTarget(config, role);
+          const model = target?.provider ? `${target.provider}/${target.model ?? "(default)"}` : `${config.provider}/${config.model ?? "(leader)"}`;
+          const src = target?.diversified ? " (diversified)" : target?.source === "matrix" ? ` (matrix:${target.matrixSource ?? "?"})` : "";
+          return `  ${role.padEnd(24)} ${phase.padEnd(14)} ${model}${src}`;
+        });
+        addSection(
+          `Agent Models (${roleNames.length} roles)`,
+          lines.length > 0 ? `  ${"ROLE".padEnd(24)} ${"PHASE".padEnd(14)} RESOLVED MODEL
+` + lines.join("\n") : "  (no agents in catalog)"
+        );
+      }
+      if (section === "all" || section === "doctor") {
+        const issues = [];
+        const warnings = [];
+        const ok = [];
+        const providers = config.providers ?? {};
+        const favorites = config.favoriteModels ?? [];
+        const profiles = config.fallbackProfiles ?? {};
+        const chain = config.fallbackModels ?? [];
+        const matrix = config.modelMatrix ?? {};
+        const fleetBudget = config.fleet?.budget;
+        const bridge = config.fallbackBridge?.trim();
+        if (bridge) {
+          const parsed = parseModelRef(bridge);
+          if (!parsed.provider || !parsed.model) {
+            issues.push(`Continuity bridge "${bridge}" must be a full provider/model reference`);
+          } else if (!providers[parsed.provider] && parsed.provider !== config.provider) {
+            issues.push(
+              `Continuity bridge "${bridge}" references unknown provider "${parsed.provider}"`
+            );
+          } else {
+            ok.push(`Continuity bridge "${bridge}" \u2014 provider OK`);
+          }
+        }
+        for (const fav of favorites) {
+          const p = parseModelRef(fav);
+          if (!p.model) {
+            issues.push(`Favorite "${fav}" has no model (empty or whitespace-only reference)`);
+            continue;
+          }
+          const provId = p.provider ?? config.provider;
+          const model = p.model;
+          const prov = providers[provId];
+          if (!prov) {
+            warnings.push(`Favorite "${fav}" references unknown provider "${provId}"`);
+            continue;
+          }
+          const provModels = prov.models;
+          if (provModels && provModels.length > 0 && !provModels.includes(model)) {
+            warnings.push(
+              `Favorite "${fav}" \u2014 model "${model}" not in ${provId} model list (${provModels.join(", ")})`
+            );
+          } else {
+            ok.push(`Favorite "${fav}" \u2014 provider ${provId} is configured`);
+          }
+        }
+        for (const entry of chain) {
+          const p = parseModelRef(entry);
+          if (!p.model) {
+            issues.push(`Chain entry "${entry}" has no model (empty or whitespace-only reference)`);
+            continue;
+          }
+          const provId = p.provider ?? config.provider;
+          if (!providers[provId] && provId !== config.provider) {
+            issues.push(`Chain entry "${entry}" references unknown provider "${provId}"`);
+          } else {
+            ok.push(`Chain entry "${entry}" \u2014 provider OK`);
+          }
+        }
+        for (const [pname, pchain] of Object.entries(profiles)) {
+          if (!pchain || pchain.length === 0) {
+            warnings.push(`Profile "${pname}" is empty`);
+            continue;
+          }
+          for (const entry of pchain) {
+            const p = parseModelRef(entry);
+            if (!p.model) {
+              issues.push(
+                `Profile "${pname}" entry "${entry}" has no model (empty or whitespace-only reference)`
+              );
+              continue;
+            }
+            const provId = p.provider ?? config.provider;
+            if (!providers[provId] && provId !== config.provider) {
+              issues.push(
+                `Profile "${pname}" entry "${entry}" references unknown provider "${provId}"`
+              );
+            }
+          }
+        }
+        if (typeof config.maxConcurrent === "number") {
+          if (!Number.isFinite(config.maxConcurrent) || config.maxConcurrent < 0) {
+            issues.push(
+              `maxConcurrent must be a non-negative number (got ${config.maxConcurrent})`
+            );
+          } else if (config.maxConcurrent === 0) {
+            warnings.push("maxConcurrent is 0 \u2014 subagent concurrency effectively disabled");
+          } else {
+            ok.push(`maxConcurrent ${config.maxConcurrent}`);
+          }
+        }
+        if (fleetBudget && typeof fleetBudget === "object") {
+          for (const key of ["maxSpawns", "maxTokens", "maxCostUsd"]) {
+            const v = fleetBudget[key];
+            if (v === void 0) continue;
+            if (typeof v !== "number" || !Number.isFinite(v) || v < 0) {
+              issues.push(
+                `fleet.budget.${key} must be a non-negative number (got ${JSON.stringify(v)})`
+              );
+            } else {
+              ok.push(`fleet.budget.${key} ${v}`);
+            }
+          }
+        }
+        const lastResortCap = config.fallbackMaxLastResortCandidates;
+        if (lastResortCap !== void 0) {
+          if (typeof lastResortCap !== "number" || !Number.isFinite(lastResortCap) || lastResortCap < 0) {
+            issues.push(
+              `fallbackMaxLastResortCandidates must be a non-negative number (got ${String(lastResortCap)})`
+            );
+          } else if (Math.floor(lastResortCap) === 0) {
+            warnings.push(
+              `fallbackMaxLastResortCandidates is ${lastResortCap} \u2014 floors to 0, last-resort auto-discovery append is disabled`
+            );
+          } else {
+            ok.push(`fallbackMaxLastResortCandidates ${Math.floor(lastResortCap)}`);
+          }
+        }
+        for (const [key, entry] of Object.entries(matrix)) {
+          const eProvider = entry.provider ?? config.provider;
+          const eModel = entry.model;
+          if (eModel) {
+            const provData = providers[eProvider];
+            if (!provData && eProvider !== config.provider) {
+              issues.push(`Matrix "${key}" references unknown provider "${eProvider}"`);
+            }
+            const provModels = provData?.models;
+            if (provModels && provModels.length > 0 && !provModels.includes(eModel)) {
+              warnings.push(`Matrix "${key}" \u2014 model "${eModel}" not in ${eProvider} model list`);
+            }
+          }
+          const eProfile = entry.fallbackProfile;
+          if (eProfile && !profiles[eProfile]) {
+            issues.push(`Matrix "${key}" references unknown fallback profile "${eProfile}"`);
+          }
+        }
+        if (!providers[config.provider] && Object.keys(providers).length > 0) {
+          warnings.push(`Leader provider "${config.provider}" has no explicit config entry`);
+        }
+        const summary = `  \u2713 ${ok.length} checks passed
+  \u26A0 ${warnings.length} warnings
+  \u2717 ${issues.length} issues`;
+        const lines = [summary, ""];
+        if (warnings.length > 0) {
+          lines.push("\u2500\u2500 Warnings \u2500\u2500");
+          lines.push(...warnings.map((w) => `  \u26A0 ${w}`));
+          lines.push("");
+        }
+        if (issues.length > 0) {
+          lines.push("\u2500\u2500 Issues \u2500\u2500");
+          lines.push(...issues.map((i) => `  \u2717 ${i}`));
+          lines.push("");
+        }
+        if (warnings.length === 0 && issues.length === 0 && ok.length > 0) {
+          lines.push("  All checks passed \u2014 configuration is healthy.");
+        }
+        addSection("Configuration Doctor", lines.join("\n"));
+      }
+      if (section === "all" || section === "fleet") {
+        const fleet = config.fleet;
+        const budget = fleet?.budget;
+        const lifecycle = fleet?.lifecycle;
+        const fmt = (n, unit = "") => typeof n === "number" && Number.isFinite(n) ? `${n}${unit}` : "(default)";
+        addSection(
+          "Fleet Budgets (configured ceilings)",
+          [
+            `  maxConcurrent: ${typeof config.maxConcurrent === "number" ? config.maxConcurrent : "(default 4)"}`,
+            `  fleet.budget.maxSpawns: ${fmt(budget?.maxSpawns)}  ${typeof budget?.maxSpawns !== "number" ? "\u2192 default 64" : ""}`,
+            `  fleet.budget.maxTokens: ${fmt(budget?.maxTokens)}`,
+            `  fleet.budget.maxCostUsd: ${fmt(budget?.maxCostUsd)}`,
+            `  fleet.lifecycle.idleTimeoutMs: ${fmt(lifecycle?.idleTimeoutMs, "ms")}`,
+            `  fleet.lifecycle.retireOnTaskComplete: ${lifecycle?.retireOnTaskComplete === void 0 ? "(default true)" : String(lifecycle.retireOnTaskComplete)}`,
+            "",
+            "  Live used/remaining spawns are on /fleet status (not static config).",
+            "  Override ceilings: --max-concurrent / WRONGSTACK_MAX_CONCURRENT,",
+            "  --max-spawns / WRONGSTACK_MAX_SPAWNS, or fleet.budget.maxSpawns in profile."
+          ].join("\n")
+        );
+      }
+      if (section === "all" || section === "refiner") {
+        const ref = config.autonomy;
+        addSection(
+          "Goal Refinement",
+          `  refinerProvider: ${ref?.refinerProvider ?? "(same as leader)"}
+  refinerModel: ${ref?.refinerModel ?? "(default for provider)"}
+  refinerFallbackProfile: ${ref?.refinerFallbackProfile ?? "(none)"}`
+        );
+      }
+      return { status: "ok", message: sections.join("\n\n") };
+    }
+  };
+}
+
+// src/tools/fallback-manage-tools.ts
+function createFallbackManageTools(opts) {
+  return [
+    createFavoriteManageTool(opts),
+    createFallbackChainManageTool(opts),
+    createFallbackProfileManageTool(opts),
+    createAgentModelAssignTool(opts),
+    createProviderManageTool(opts),
+    createProviderKeySetTool(opts),
+    createLeaderModelSetTool(opts),
+    createSystemConfigViewTool(opts)
+  ];
+}
+
+// src/tools/mcp-control.ts
+function createMcpControlTool(opts) {
+  const { getConfig, configPath, registry } = opts;
+  const inputSchema = {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["list", "search", "enable", "disable", "restart", "activate", "deactivate"],
+        description: "The management action to perform. activate/deactivate toggle tool registration ephemerally without disconnecting."
+      },
+      /** Filter for `search`. Matches server name or description case-insensitively. */
+      query: {
+        type: "string",
+        description: "Search term for `search` action. Matches server name or description."
+      },
+      /** Target server name for `enable`, `disable`, `restart`, `activate`, `deactivate`. */
+      server: {
+        type: "string",
+        description: 'Server name (e.g. "github", "filesystem", "brave-search").'
+      }
+    },
+    required: ["action"]
+  };
+  return {
+    name: "mcp_control",
+    description: "Manage MCP server lifecycle: list available servers, search by name or capability, enable or disable servers at runtime, restart running servers. Use activate/deactivate to ephemerally toggle tool registration without disconnecting \u2014 ideal for token-saving mode where MCP tools are lazy-loaded on demand. NOTE: `enable`/`restart` start a server process, which for the built-in stdio presets runs `npx -y <package>` \u2014 i.e. it fetches and executes an npm package from the network. Treat it as code execution.",
+    category: "mcp",
+    permission: "confirm",
+    mutating: true,
+    // `enable`/`restart` spawn a server process that, for the stdio presets,
+    // fetches and runs an npm package (`npx -y <pkg>`) — effectively remote
+    // code execution. Marking the tool destructive preserves risk metadata for
+    // UI/audit surfaces; YOLO itself still auto-approves unless an explicit
+    // deny rule blocks the call. Read-only actions (list/search) ride the same
+    // tool but are cheap to confirm/trust once when YOLO is off.
+    riskTier: "destructive",
+    capabilities: [ToolCapabilities.CONFIG_MUTATE],
+    inputSchema,
+    async execute(raw) {
+      const input = raw;
+      return mcpControlDispatch(input, { getConfig, configPath, registry });
+    }
+  };
+}
+async function mcpControlDispatch(input, deps) {
+  const { action, query, server } = input;
+  switch (action) {
+    case "list":
+      return renderList(deps);
+    case "search":
+      return renderSearch(query ?? "", deps);
+    case "enable":
+      return server ? runEnable(server, deps) : "`server` is required for enable.";
+    case "disable":
+      return server ? runDisable(server, deps) : "`server` is required for disable.";
+    case "restart":
+      return server ? runRestart(server, deps) : "`server` is required for restart.";
+    case "activate":
+      return server ? runActivate(server, deps) : "`server` is required for activate.";
+    case "deactivate":
+      return server ? runDeactivate(server, deps) : "`server` is required for deactivate.";
+    default:
+      return `Unknown action "${action}". Use one of: list, search, enable, disable, restart, activate, deactivate.`;
+  }
+}
+async function renderList(deps) {
+  const configured = await getConfiguredMcpServers(deps);
+  const live = deps.registry.describe();
+  if (Object.keys(configured).length === 0) {
+    return [
+      "No MCP servers configured.",
+      '  Use `mcp_control({ action: "search" })` to see available presets,',
+      '  then `mcp_control({ action: "enable", server: "<name>" })` to add one.'
+    ].join("\n");
+  }
+  const lines = [];
+  const liveMap = new Map(live.map((s) => [s.name, s]));
+  for (const [name, cfg] of Object.entries(configured)) {
+    const liveInfo = liveMap.get(name);
+    const toolCount = liveInfo ? ` (${liveInfo.toolCount} tools)` : "";
+    const stateStr = liveInfo ? badge(liveInfo.state) : dim("\u25CB not loaded");
+    const enabled = cfg.enabled === false ? `${dim("disabled")}  ` : `${green("\u25CF enabled")}  `;
+    lines.push(`  ${bold(name)}  ${enabled}${stateStr}${toolCount}`);
+    if (cfg.description) lines.push(`    ${dim(cfg.description)}`);
+  }
+  lines.push("");
+  lines.push(dim('  Use `mcp_control({ action: "search", query: "<keyword>" })` to find servers.'));
+  lines.push(dim('  Use `mcp_control({ action: "enable", server: "<name>" })` to start a server.'));
+  return lines.join("\n");
+}
+async function renderSearch(query, deps) {
+  const configured = await getConfiguredMcpServers(deps);
+  const all = allServers();
+  const q = query.toLowerCase();
+  const configuredNames = new Set(Object.keys(configured));
+  const configuredEntries = Object.entries(configured).filter(
+    ([name, cfg]) => name.toLowerCase().includes(q) || (cfg.description ?? "").toLowerCase().includes(q)
+  );
+  const unconfiguredEntries = Object.entries(all).filter(([name]) => !configuredNames.has(name)).filter(
+    ([name, cfg]) => name.toLowerCase().includes(q) || (cfg.description ?? "").toLowerCase().includes(q)
+  );
+  const lines = [];
+  if (configuredEntries.length > 0) {
+    lines.push(bold('Configured servers matching "') + query + '":');
+    for (const [name, cfg] of configuredEntries) {
+      lines.push(`  ${bold(name)}  ${cfg.description ?? cfg.transport}`);
+    }
+    lines.push("");
+  }
+  if (unconfiguredEntries.length > 0) {
+    lines.push(bold('Available presets matching "') + query + '":');
+    for (const [name, cfg] of unconfiguredEntries) {
+      const warn = cfg.permission === "deny" ? red(" \u26A0 confirm required") : "";
+      lines.push(`  ${bold(name)}  ${cfg.description ?? cfg.transport}${warn}`);
+    }
+    lines.push("");
+  }
+  if (configuredEntries.length === 0 && unconfiguredEntries.length === 0) {
+    return `No servers match "${query}". Try a shorter keyword or \`mcp_control({ action: "list" })\`.`;
+  }
+  const total = configuredEntries.length + unconfiguredEntries.length;
+  lines.push(dim(`  ${total} server${total !== 1 ? "s" : ""} shown. Run \`enable\` on one to activate it.`));
+  return lines.join("\n");
+}
+async function runEnable(name, deps) {
+  if (!name) return '`server` is required for enable. Example: { action: "enable", server: "github" }';
+  const all = allServers();
+  const configured = deps.getConfig().mcpServers ?? {};
+  const cfg = configured[name] ?? all[name];
+  if (!cfg) {
+    const known = Object.keys(all).join(", ");
+    return `Unknown server "${name}". Available presets: ${known}`;
+  }
+  const persistEnabled = () => updateJsonObjectFile(deps.configPath, (full) => {
+    const current = isMcpServerRecord(full.mcpServers) ? full.mcpServers : {};
+    setJsonPath(full, ["mcpServers", name], { ...current[name], ...cfg, enabled: true });
+  });
+  try {
+    const live = deps.registry.describe().find((s) => s.name === name);
+    if (live && live.state === "connected") {
+      await persistEnabled();
+      return `Server "${name}" is already running (${live.toolCount} tools registered).`;
+    }
+    await deps.registry.start({ ...cfg, enabled: true });
+    await persistEnabled();
+    const updated = deps.registry.describe().find((s) => s.name === name);
+    return `Enabled and started "${name}"${updated ? ` (${updated.toolCount} tools registered).` : "."}`;
+  } catch (err) {
+    return `Failed to start "${name}": ${toErrorMessage(err)}. Config was left unchanged (server stays disabled).`;
+  }
+}
+async function runDisable(name, deps) {
+  if (!name) return '`server` is required for disable. Example: { action: "disable", server: "github" }';
+  const configured = deps.getConfig().mcpServers ?? {};
+  if (!configured[name]) {
+    return `Server "${name}" is not in config. Add it with \`mcp_control({ action: "enable", server: "${name}" })\`.`;
+  }
+  await updateJsonObjectFile(deps.configPath, (full) => {
+    const current = isMcpServerRecord(full.mcpServers) ? full.mcpServers : {};
+    const existing = expectDefined(current[name]);
+    setJsonPath(full, ["mcpServers", name], { ...existing, enabled: false });
+  });
+  try {
+    await deps.registry.stop(name);
+    return `${yellow("\u25CB Disabled")} "${name}". It will not be started on next boot.`;
+  } catch {
+    return `${yellow("\u25CB Disabled")} "${name}" (it was not running). Config updated.`;
+  }
+}
+async function runRestart(name, deps) {
+  if (!name) return '`server` is required for restart. Example: { action: "restart", server: "github" }';
+  const configured = deps.getConfig().mcpServers ?? {};
+  if (!configured[name]) {
+    return `Server "${name}" is not configured. Use \`mcp_control({ action: "enable", server: "${name}" })\` first.`;
+  }
+  try {
+    await deps.registry.restart(name);
+    const updated = deps.registry.describe().find((s) => s.name === name);
+    return `${green("\u2713 Restarted")} "${name}"${updated ? ` (${updated.toolCount} tools registered).` : "."}`;
+  } catch (err) {
+    return `${red("\u2717 Restart failed")} for "${name}": ${toErrorMessage(err)}`;
+  }
+}
+async function runActivate(name, deps) {
+  if (!name) return "`server` is required for activate.";
+  if (!deps.registry.activateServer) {
+    return `Registry does not support ephemeral activation. Use \`enable\` to start "${name}" instead.`;
+  }
+  const live = deps.registry.describe().find((s) => s.name === name);
+  if (!live) {
+    return `Server "${name}" is not registered. Use \`mcp_control({ action: "enable", server: "${name}" })\` first.`;
+  }
+  if (live.state !== "connected") {
+    return `Server "${name}" is not connected (state: ${live.state}). Use \`enable\` to start it first.`;
+  }
+  if (deps.registry.isActivated?.(name)) {
+    return `${green("\u25CF")} Server "${name}" tools are already active. Use \`deactivate\` to hide them.`;
+  }
+  deps.registry.activateServer(name);
+  const updated = deps.registry.describe().find((s) => s.name === name);
+  return `${green("\u2713 Activated")} "${name}" \u2014 ${updated?.toolCount ?? 0} tool(s) now registered. Use \`mcp_control({ action: "deactivate", server: "${name}" })\` to hide them when done.`;
+}
+async function runDeactivate(name, deps) {
+  if (!name) return "`server` is required for deactivate.";
+  if (!deps.registry.deactivateServer) {
+    return `Registry does not support ephemeral deactivation. Use \`disable\` to stop "${name}" instead.`;
+  }
+  if (!deps.registry.isActivated?.(name)) {
+    return `Server "${name}" tools are not currently active.`;
+  }
+  const count = deps.registry.deactivateServer(name);
+  return `${yellow("\u25CB Deactivated")} "${name}" \u2014 ${count} tool(s) unregistered. Server stays connected.`;
+}
+async function getConfiguredMcpServers(deps) {
+  const diskConfig = await readJsonObjectFile(deps.configPath);
+  if (isMcpServerRecord(diskConfig.mcpServers)) return diskConfig.mcpServers;
+  return deps.getConfig().mcpServers ?? {};
+}
+function isMcpServerRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function bold(s) {
+  return s;
+}
+function dim(s) {
+  return s;
+}
+function green(s) {
+  return s;
+}
+function yellow(s) {
+  return s;
+}
+function red(s) {
+  return s;
+}
+function badge(state) {
+  switch (state) {
+    case "connected":
+      return "\u25CF connected";
+    case "connecting":
+      return "\u25D0 connecting";
+    case "reconnecting":
+      return "\u25D1 reconnecting";
+    case "disconnected":
+      return "\u25CB disconnected";
+    case "failed":
+      return "\u2717 failed";
+    default:
+      return state;
+  }
+}
+
+// src/tools/mcp-use.ts
+function createMcpUseTool(opts) {
+  const { registry, toolRegistry } = opts;
+  const inputSchema = {
+    type: "object",
+    properties: {
+      server: {
+        type: "string",
+        description: 'MCP server name (e.g. "github", "filesystem", "brave-search"). Use mcp_control list or search first to discover available servers.'
+      },
+      tool: {
+        type: "string",
+        description: "Tool name on the MCP server to call (without the mcp__server__ prefix \u2014 just the bare tool name)."
+      },
+      input: {
+        type: "object",
+        description: "JSON input to pass to the tool. Use the tool's own input schema \u2014 check with mcp_control describe or the server's documentation.",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    required: ["server", "tool", "input"]
+  };
+  return {
+    name: "mcp_use",
+    description: "Call an MCP tool on a lazy-loaded server. Activates the server temporarily, calls the tool, returns the result, and deactivates. Use this instead of the manual activate\u2192use\u2192deactivate cycle. First call mcp_control list/search to find the right server and tool name.",
+    category: "mcp",
+    permission: "confirm",
+    mutating: true,
+    riskTier: "standard",
+    capabilities: [ToolCapabilities.MCP_PROXY],
+    inputSchema,
+    async execute(raw, ctx) {
+      const input = raw;
+      const { server: serverName, tool: toolName, input: toolInput } = input;
+      const servers = registry.describe();
+      const serverInfo = servers.find((s) => s.name === serverName);
+      if (!serverInfo) {
+        throw new Error(
+          `Server "${serverName}" not found. Available: ${servers.map((s) => s.name).join(", ") || "none"}.`
+        );
+      }
+      if (serverInfo.state !== "connected") {
+        throw new Error(
+          `Server "${serverName}" is not connected (state: ${serverInfo.state}). Use \`mcp_control({ action: "enable", server: "${serverName}" })\` first.`
+        );
+      }
+      const alreadyActive = registry.isActivated?.(serverName) === true;
+      const didActivate = !alreadyActive && Boolean(registry.activateServer);
+      if (didActivate) {
+        registry.activateServer?.(serverName);
+      }
+      try {
+        const qualifiedName = mcpQualifiedToolName(serverName, toolName);
+        const mcpTool = toolRegistry.get(qualifiedName);
+        if (!mcpTool) {
+          const allTools = toolRegistry.list().filter((t) => t.name.startsWith(mcpServerToolPrefix(serverName))).map((t) => t.name.replace(mcpServerToolPrefix(serverName), ""));
+          const hint = allTools.length > 0 ? `Available tools on "${serverName}": ${allTools.join(", ")}.` : `No tools found on "${serverName}". The server may not have published any tools.`;
+          throw new Error(`Tool "${toolName}" not found on server "${serverName}". ${hint}`);
+        }
+        const governedExecute = ctx.meta[GOVERNED_TOOL_EXECUTOR_META_KEY];
+        if (typeof governedExecute !== "function") {
+          throw new Error("mcp_use: governed nested execution is unavailable");
+        }
+        const result = await governedExecute(qualifiedName, toolInput ?? {});
+        if (!result.success) throw new Error(result.error ?? "MCP tool execution failed");
+        return result.result;
+      } finally {
+        if (didActivate && registry.deactivateServer) {
+          registry.deactivateServer(serverName);
+        }
+      }
+    }
+  };
+}
+
+// src/tools/one-shot-llm-tool.ts
+var ONE_SHOT_LLM_TOOL_NAME = "llm";
+var MAX_TIMEOUT_MS = 12e4;
+var INPUT_SCHEMA2 = {
+  type: "object",
+  properties: {
+    system: {
+      type: "string",
+      description: "System prompt guiding the LLM behaviour."
+    },
+    userPrompt: {
+      type: "string",
+      description: "Single user turn \u2014 appended as a user-role message."
+    },
+    messages: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          role: {
+            type: "string",
+            enum: ["system", "user", "assistant", "tool"],
+            description: "Message author role."
+          },
+          content: {
+            type: "string",
+            description: "Message text content."
+          }
+        },
+        required: ["role", "content"],
+        additionalProperties: true
+      },
+      description: "Conversation messages for few-shot examples or multi-turn context. Appended before userPrompt when both are set."
+    },
+    model: {
+      type: "string",
+      description: 'Model id (e.g. "deepseek-chat", "gpt-4o-mini"). Defaults to session model.'
+    },
+    providerId: {
+      type: "string",
+      description: 'Provider id (e.g. "anthropic", "openai"). Defaults to session provider.'
+    },
+    role: {
+      type: "string",
+      description: "Roster role for model-matrix routing. Overrides model/providerId."
+    },
+    fallbackModels: {
+      type: "array",
+      items: { type: "string" },
+      description: 'Explicit fallback model chain (e.g. ["anthropic/claude-haiku", "openai/gpt-4o-mini"]). Resolved named profiles from FallbackProfileManager are passed here.'
+    },
+    maxTokens: {
+      type: "number",
+      description: "Maximum output tokens (default 1024)."
+    },
+    responseFormat: {
+      oneOf: [
+        { type: "string", enum: ["text", "json_object"], description: "Simple response format." },
+        {
+          type: "object",
+          properties: {
+            type: { type: "string", enum: ["json_schema"], description: "Structured JSON output." },
+            json_schema: {
+              type: "object",
+              description: "JSON Schema definition for the structured output."
+            }
+          },
+          required: ["type"],
+          additionalProperties: false
+        }
+      ],
+      description: 'Response format: "text" (default), "json_object", or { type: "json_schema", json_schema: {...} }.'
+    },
+    temperature: {
+      type: "number",
+      description: "Sampling temperature."
+    },
+    timeoutMs: {
+      type: "number",
+      description: `Hard timeout in ms (default 30s, clamped to a maximum of ${MAX_TIMEOUT_MS}).`
+    }
+  },
+  additionalProperties: false
+};
+function createOneShotLLMTool(opts) {
+  const orchestrator = new OneShotOrchestrator({
+    buildProvider: opts.buildProvider,
+    getConfig: opts.getConfig,
+    fallbackProfileManager: opts.fallbackProfileManager,
+    modelRouter: opts.modelRouter,
+    statusTracker: opts.statusTracker,
+    logger: opts.logger,
+    wrapProviderCall: opts.wrapProviderCall
+  });
+  return {
+    name: ONE_SHOT_LLM_TOOL_NAME,
+    description: "Make a one-shot LLM call with a system prompt and user input. Supports provider selection, model routing by role, fallback chains, and timeout. Returns the response text, model info, token usage, and whether a fallback was used. Use this for summarization, classification, extraction, and any single-turn LLM task.",
+    usageHint: "Provide `system` for the instruction and `userPrompt` for the input. Either set `model`+`providerId`, or have defaults configured on the tool. Set `fallbackModels` for resilience. Check `error` on the result for failure details.",
+    inputSchema: INPUT_SCHEMA2,
+    // Metadata mirrors council-tool.ts — both are read-only meta tools that
+    // spend tokens but never touch the workspace.
+    category: "meta",
+    permission: "auto",
+    mutating: false,
+    riskTier: "safe",
+    maxOutputBytes: 262144,
+    validate(input) {
+      const hasPrompt = typeof input.userPrompt === "string" && input.userPrompt.trim().length > 0;
+      const hasMessages = Array.isArray(input.messages) && input.messages.length > 0;
+      if (!hasPrompt && !hasMessages) {
+        return [
+          "Provide `userPrompt` (a single user turn) or `messages` (a conversation array) \u2014 without either the llm tool has nothing to send to the model."
+        ];
+      }
+      return [];
+    },
+    async execute(input, _ctx, { signal }) {
+      if (!input.model && !input.providerId && !opts.defaultModel && !opts.defaultProvider) {
+        return {
+          text: "",
+          model: "",
+          provider: "",
+          tokens: { input: 0, output: 0, total: 0 },
+          durationMs: 0,
+          fromFallback: false,
+          error: "Either provide `model` and `providerId` in the call, or configure defaultProvider/defaultModel when creating the tool. The `llm` tool does not infer provider/model from the session by default."
+        };
+      }
+      const effectiveInput = {
+        ...input,
+        signal: input.signal ? AbortSignal.any([input.signal, signal]) : signal,
+        model: input.model ?? opts.defaultModel,
+        providerId: input.providerId ?? opts.defaultProvider,
+        // Clamp runaway timeouts (documented on the schema). Non-positive
+        // values fall back to the orchestrator default rather than making the
+        // call instantly un-completable.
+        ...typeof input.timeoutMs === "number" && input.timeoutMs > 0 ? { timeoutMs: Math.min(input.timeoutMs, MAX_TIMEOUT_MS) } : { timeoutMs: void 0 }
+      };
+      return orchestrator.call(effectiveInput);
+    }
+  };
+}
+
+// src/tools/plugin-manager.ts
+var PLUGIN_MANAGER_TOOL_NAME = "plugin_manager";
+var PLUGIN_VIEW_STATE_SOURCE = {
+  "feature-flag": "feature_flag",
+  "plugin-entry": "config",
+  extension: "extension",
+  default: "default"
+};
+var INPUT_SCHEMA3 = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      enum: ["list", "search", "describe", "enable", "disable", "use"],
+      description: "Operation. list: inventory with optional state filter. search: find plugins by need/query. describe: inspect one plugin, managerControl, callableNow, and full tool schemas. enable/disable: persist boot state (often restartRequired). use: inspect or invoke a tool from a plugin already loaded in this session."
+    },
+    plugin: {
+      type: "string",
+      description: "Plugin name or unambiguous alias. Required for describe, enable, disable, and use."
+    },
+    query: {
+      type: "string",
+      description: "Free-text query over plugin names, aliases, descriptions, and registered tool metadata. Required for search."
+    },
+    state: {
+      type: "string",
+      enum: ["all", "enabled", "disabled"],
+      description: "Optional list/search filter. enabled/disabled means effective boot state, not whether plugin code can be hot-loaded in the current session. Defaults to all."
+    },
+    tool: {
+      type: "string",
+      description: 'Registered plugin tool to invoke when action="use". Omit to receive the available tool schemas first.'
+    },
+    input: {
+      type: "object",
+      description: 'Exact JSON input for the selected plugin tool when action="use". Read the schema returned by describe or use-without-tool first; do not guess fields.',
+      properties: {},
+      additionalProperties: true
+    }
+  },
+  required: ["action"],
+  additionalProperties: false
+};
+var USAGE_HINT = [
+  "Always discover before mutating: never enable a guessed plugin name.",
+  "Workflow: (1) search with a capability/need query, or list with an optional state filter;",
+  "(2) describe the chosen plugin and inspect enabled, managerControl, callableNow, and tools[].inputSchema;",
+  '(3) if disabled, enable only when managerControl="allowed"\u2014never work around "locked"; when restartRequired=true, tell the user the plugin cannot be used until WrongStack restarts;',
+  "(4) call use with only plugin to refresh/inspect callable tool schemas;",
+  "(5) call use again with the exact tool name and schema-valid input.",
+  'Examples: search={"action":"search","query":"release notes"}; describe={"action":"describe","plugin":"release-notes-generator"}; inspect-use={"action":"use","plugin":"release-notes-generator"}; invoke-use={"action":"use","plugin":"release-notes-generator","tool":"generate_release_notes","input":{"to":"HEAD"}}.',
+  "use works only for tools loaded now. If the result is needs_direct_call, call the returned tool directly so its confirm/deny/destructive policy runs.",
+  "disable also normally affects the next boot, not already-loaded code."
+].join(" ");
+function createPluginManagerTool(opts) {
+  return {
+    name: PLUGIN_MANAGER_TOOL_NAME,
+    description: "Manage WrongStack plugins through a guarded discovery-first workflow. Search the host catalog, inspect effective state and live plugin-owned tool schemas, persist allowed enable/disable changes, and invoke tools from plugins already loaded in this session. This does not install arbitrary packages or bypass plugin/tool permissions.",
+    usageHint: USAGE_HINT,
+    selection: {
+      doNotUseWhen: "installing a new npm package, editing plugin-specific options, changing per-plugin LLM routing, or bypassing a managerControl lock/tool permission"
+    },
+    category: "Config",
+    inputSchema: INPUT_SCHEMA3,
+    permission: "auto",
+    mutating: true,
+    riskTier: "standard",
+    subjectKey: "plugin",
+    capabilities: [
+      ToolCapabilities.TOOL_META,
+      ToolCapabilities.TOOL_MUTATE_ANY,
+      ToolCapabilities.CONFIG_MUTATE
+    ],
+    icon: "settings",
+    validate(input) {
+      const value = input;
+      const errors = [];
+      if (value.action === "search" && !value.query?.trim()) {
+        errors.push('query is required when action="search"');
+      }
+      if (["describe", "enable", "disable", "use"].includes(value.action) && !value.plugin?.trim()) {
+        errors.push(`plugin is required when action="${value.action}"`);
+      }
+      if (value.action === "use" && value.tool && value.input === void 0) {
+        errors.push('input is required when action="use" includes a tool');
+      }
+      return errors;
+    },
+    async execute(rawInput, ctx, executeOpts) {
+      const input = rawInput;
+      const views = buildPluginViews(opts);
+      if (input.action === "list" || input.action === "search") {
+        const needle = input.action === "search" ? input.query.trim().toLowerCase() : "";
+        const state = input.state ?? "all";
+        const matches = views.filter((view) => {
+          if (state !== "all" && view.enabled !== (state === "enabled")) return false;
+          if (!needle) return true;
+          const haystack = [
+            view.name,
+            ...view.aliases,
+            view.description,
+            ...view.tools.flatMap((tool2) => [tool2.name, tool2.description])
+          ].join("\n").toLowerCase();
+          return haystack.includes(needle);
+        });
+        return {
+          status: "ok",
+          action: input.action,
+          count: matches.length,
+          plugins: matches.map(compactView)
+        };
+      }
+      const resolved = resolvePlugin(input.plugin, views);
+      if ("error" in resolved) return { status: "error", message: resolved.error };
+      const plugin = resolved.plugin;
+      if (input.action === "describe") {
+        return { status: "ok", action: "describe", plugin };
+      }
+      if (input.action === "enable" || input.action === "disable") {
+        const enabled = input.action === "enable";
+        if (plugin.managerControl === "locked") {
+          return {
+            status: "error",
+            code: "plugin_manager_locked",
+            message: `Plugin "${plugin.name}" is locked against LLM enable/disable changes. Only the user can change it with /plugin or update pluginManager.locked.`
+          };
+        }
+        if (!enabled && !plugin.canDisable) {
+          return {
+            status: "error",
+            message: `Plugin "${plugin.name}" is locked and cannot be disabled.`
+          };
+        }
+        if (plugin.enabled === enabled && plugin.stateSource !== "feature_flag") {
+          return {
+            status: "ok",
+            action: input.action,
+            changed: false,
+            restartRequired: false,
+            message: `Plugin "${plugin.name}" is already ${enabled ? "enabled" : "disabled"}.`
+          };
+        }
+        const result2 = await opts.setEnabled(plugin.name, enabled);
+        return {
+          status: result2.ok ? "ok" : "error",
+          action: input.action,
+          changed: result2.ok,
+          restartRequired: result2.restartRequired ?? result2.ok,
+          message: result2.message
+        };
+      }
+      if (!plugin.enabled) {
+        return {
+          status: "error",
+          message: `Plugin "${plugin.name}" is disabled. Enable it first; newly enabled plugins become callable after restart.`
+        };
+      }
+      if (!input.tool) {
+        return {
+          status: "ok",
+          action: "use",
+          ready: plugin.callableNow,
+          message: plugin.callableNow ? `Choose one of the loaded tools registered by "${plugin.name}".` : `Plugin "${plugin.name}" has no callable tool loaded in this session. It may be hook/command-only or require a restart/configuration.`,
+          plugin
+        };
+      }
+      const selected = plugin.tools.find((tool2) => tool2.name === input.tool);
+      if (!selected) {
+        return {
+          status: "error",
+          message: `Tool "${input.tool}" is not registered by plugin "${plugin.name}" in this session.`,
+          availableTools: plugin.tools.map((tool2) => tool2.name)
+        };
+      }
+      if (!selected.enabled) {
+        return {
+          status: "error",
+          message: `Tool "${selected.name}" is registered but disabled by the tool configuration.`
+        };
+      }
+      const tool = opts.toolRegistry.get(selected.name);
+      if (!tool || !ownerMatches(opts.toolRegistry.ownerOf(selected.name), plugin)) {
+        return {
+          status: "error",
+          message: `Tool "${selected.name}" is no longer available from "${plugin.name}".`
+        };
+      }
+      if (tool.permission !== "auto" || tool.riskTier === "destructive") {
+        return {
+          status: "needs_direct_call",
+          message: `Tool "${tool.name}" requires the normal permission path (${tool.permission}, risk=${tool.riskTier ?? "standard"}). Call it directly so WrongStack can apply its own approval and policy checks.`,
+          directCall: { tool: tool.name, input: input.input ?? {}, inputSchema: tool.inputSchema }
+        };
+      }
+      const dangerousCaps = getDangerousCapabilities(tool);
+      if (dangerousCaps.length > 0) {
+        return {
+          status: "needs_direct_call",
+          message: `Tool "${tool.name}" declares dangerous capabilities (${dangerousCaps.join(", ")}); the permission pipeline must rule on it. Call it directly.`,
+          directCall: { tool: tool.name, input: input.input ?? {}, inputSchema: tool.inputSchema }
+        };
+      }
+      if (ctx.meta["readOnly"] === true && toolMutates(tool)) {
+        return {
+          status: "needs_direct_call",
+          message: `Session is in read-only mode and "${tool.name}" mutates. Call it directly so read-only mode can rule on it.`,
+          directCall: { tool: tool.name, input: input.input ?? {}, inputSchema: tool.inputSchema }
+        };
+      }
+      let nestedInput = input.input ?? {};
+      const hooks = opts.getHookRunner?.();
+      if (hooks) {
+        const pre = await hooks.preToolUse(tool.name, nestedInput, ctx, {
+          capabilities: tool.capabilities,
+          mutating: tool.mutating
+        });
+        if (pre.block) {
+          return {
+            status: "error",
+            message: `A policy hook blocked "${tool.name}"` + (pre.reason ? `: ${pre.reason}` : ".")
+          };
+        }
+        if (pre.input) nestedInput = pre.input;
+      }
+      const validation = validateAgainstSchema(nestedInput, tool.inputSchema);
+      if (!validation.ok) {
+        return {
+          status: "error",
+          message: `Invalid input for plugin tool "${tool.name}".`,
+          errors: validation.errors,
+          inputSchema: tool.inputSchema
+        };
+      }
+      const crossFieldErrors = tool.validate?.(nestedInput) ?? [];
+      if (crossFieldErrors.length > 0) {
+        return {
+          status: "error",
+          message: `Invalid input for plugin tool "${tool.name}".`,
+          errors: crossFieldErrors,
+          inputSchema: tool.inputSchema
+        };
+      }
+      const result = await tool.execute(nestedInput, ctx, executeOpts);
+      return { status: "ok", action: "use", plugin: plugin.name, tool: tool.name, result };
+    }
+  };
+}
+function buildPluginViews(opts) {
+  const config = opts.getConfig();
+  const configured = config.plugins ?? [];
+  const catalog = [...opts.catalog];
+  const knownNames = new Set(catalog.flatMap((entry) => [entry.name, ...entry.aliases ?? []]));
+  for (const item of configured) {
+    const name = pluginConfigName(item);
+    if (!knownNames.has(name)) {
+      catalog.push({
+        name,
+        description: "User-configured plugin (not present in the built-in discovery catalog).",
+        risk: "medium",
+        defaultState: "inactive",
+        canDisable: true
+      });
+      knownNames.add(name);
+    }
+  }
+  return catalog.map((entry) => {
+    const aliases = [...entry.aliases ?? []];
+    const names = /* @__PURE__ */ new Set([entry.name, ...aliases]);
+    const { enabled, source } = resolvePluginEnablement({
+      name: entry.name,
+      aliases,
+      defaultState: entry.defaultState,
+      config,
+      matches: (spec) => names.has(spec)
+    });
+    const stateSource = PLUGIN_VIEW_STATE_SOURCE[source];
+    const tools = pluginTools(opts.toolRegistry, entry.name, aliases);
+    const managerControl = isManagerLocked(config, entry.name, aliases) ? "locked" : "allowed";
+    return {
+      name: entry.name,
+      description: entry.description,
+      risk: entry.risk,
+      enabled,
+      stateSource,
+      canDisable: entry.canDisable,
+      managerControl,
+      aliases,
+      callableNow: enabled && tools.some((tool) => tool.enabled),
+      tools
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+function isManagerLocked(config, name, aliases) {
+  const locked = new Set(
+    (config.pluginManager?.locked ?? []).map((entry) => entry.trim().toLowerCase())
+  );
+  if (locked.has("*")) return true;
+  return [name, ...aliases].some((entry) => locked.has(entry.toLowerCase()));
+}
+function pluginTools(registry, name, aliases) {
+  const plugin = { name, aliases };
+  const active = registry.listWithOwner().filter(({ owner }) => ownerMatches(owner, plugin)).map(({ tool }) => toolView(tool, true));
+  const disabled = registry.listDisabled().filter(({ owner }) => ownerMatches(owner, plugin)).map(({ tool }) => toolView(tool, false));
+  return [...active, ...disabled].sort((a, b) => a.name.localeCompare(b.name));
+}
+function toolView(tool, enabled) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    permission: tool.permission,
+    enabled
+  };
+}
+function ownerMatches(owner, plugin) {
+  if (!owner) return false;
+  const names = /* @__PURE__ */ new Set([plugin.name, ...plugin.aliases]);
+  const segments = owner.split("+");
+  return segments.length > 0 && segments.every((segment) => names.has(segment));
+}
+function resolvePlugin(input, views) {
+  const needle = input.trim().toLowerCase();
+  const exact = views.find(
+    (view) => view.name.toLowerCase() === needle || view.aliases.some((alias) => alias.toLowerCase() === needle)
+  );
+  if (exact) return { plugin: exact };
+  const partial = views.filter(
+    (view) => view.name.toLowerCase().includes(needle) || view.aliases.some((alias) => alias.toLowerCase().includes(needle))
+  );
+  if (partial.length === 1) return { plugin: partial[0] };
+  if (partial.length > 1) {
+    return {
+      error: `Plugin name "${input}" is ambiguous. Matches: ${partial.map((view) => view.name).join(", ")}.`
+    };
+  }
+  return { error: `Plugin "${input}" was not found. Use plugin_manager search first.` };
+}
+function compactView(view) {
+  return { ...view, tools: view.tools.map((tool) => tool.name) };
+}
+function pluginConfigName(item) {
+  return typeof item === "string" ? item : item.name;
+}
+
+export {
+  COUNCIL_TOOL_NAME,
+  MAX_COUNCIL_TOOL_OPTIONS,
+  MAX_COUNCIL_QUESTION_CHARS,
+  MAX_COUNCIL_CONTEXT_CHARS,
+  createCouncilTool,
+  FALLBACK_CHAIN_MANAGE_TOOL_NAME,
+  FAVORITE_MANAGE_TOOL_NAME,
+  FALLBACK_PROFILE_MANAGE_TOOL_NAME,
+  AGENT_MODEL_ASSIGN_TOOL_NAME,
+  PROVIDER_MANAGE_TOOL_NAME,
+  validateProviderBaseUrl,
+  PROVIDER_KEY_SET_TOOL_NAME,
+  LEADER_MODEL_SET_TOOL_NAME,
+  SYSTEM_CONFIG_VIEW_TOOL_NAME,
+  createFallbackManageTools,
+  createMcpControlTool,
+  createMcpUseTool,
+  ONE_SHOT_LLM_TOOL_NAME,
+  createOneShotLLMTool,
+  PLUGIN_MANAGER_TOOL_NAME,
+  createPluginManagerTool
+};
+//# sourceMappingURL=chunk-FIV4IJL7.js.map