@wrongstack/core 0.287.0 → 0.291.0

package/dist/tools/index.js

@@ -412,7 +412,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve2) => setTimeout(resolve2, delays[i]));
+      await new Promise((resolve3) => setTimeout(resolve3, delays[i]));
     }
   }
   throw lastErr;
@@ -437,13 +437,13 @@ async function updateJsonObjectFile(filePath, mutator) {
   await writeJsonObjectFile(filePath, next);
   return next;
 }
-function setJsonPath(root, path3, value) {
-  if (path3.length === 0) {
+function setJsonPath(root, path4, value) {
+  if (path4.length === 0) {
     if (!isJsonObject(value)) throw new Error("Root config value must be an object");
     return value;
   }
-  const parent = ensureJsonParent(root, path3);
-  const leaf = lastPathSegment(path3);
+  const parent = ensureJsonParent(root, path4);
+  const leaf = lastPathSegment(path4);
   if (typeof leaf === "number") {
     if (!Array.isArray(parent)) throw new Error(`Cannot set numeric segment ${leaf} on non-array parent`);
     parent[leaf] = value;
@@ -456,16 +456,16 @@ function setJsonPath(root, path3, value) {
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function lastPathSegment(path3) {
-  const segment = path3[path3.length - 1];
+function lastPathSegment(path4) {
+  const segment = path4[path4.length - 1];
   if (segment === void 0) throw new Error("Invalid empty JSON path");
   return segment;
 }
-function ensureJsonParent(root, path3) {
+function ensureJsonParent(root, path4) {
   let current = root;
-  for (let i = 0; i < path3.length - 1; i += 1) {
-    const segment = path3[i];
-    const nextSegment = path3[i + 1];
+  for (let i = 0; i < path4.length - 1; i += 1) {
+    const segment = path4[i];
+    const nextSegment = path4[i + 1];
     if (segment === void 0) throw new Error("Invalid empty JSON path segment");
     const nextContainer = typeof nextSegment === "number" ? [] : {};
     if (typeof segment === "number") {
@@ -1219,9 +1219,9 @@ function normalizeOptions(options) {
     };
   });
 }
-function requiredInstruction(path3) {
-  const text = readBundledInstructionText(path3);
-  if (!text) throw new Error(`Council instruction file is unavailable: ${path3}`);
+function requiredInstruction(path4) {
+  const text = readBundledInstructionText(path4);
+  if (!text) throw new Error(`Council instruction file is unavailable: ${path4}`);
   return text;
 }
 
@@ -1332,6 +1332,9 @@ var CouncilOrchestrator = class {
   defaultProfile;
   maxConcurrency;
   refusalOptionId;
+  fallbackProfileManager;
+  seatCaller;
+  judgeCaller;
   constructor(opts) {
     this.caller = opts.caller;
     this.personas = opts.personas ?? DEFAULT_COUNCIL_PERSONA_REGISTRY;
@@ -1341,6 +1344,9 @@ var CouncilOrchestrator = class {
       opts.maxConcurrency ?? DEFAULT_COUNCIL_MAX_CONCURRENCY
     );
     this.refusalOptionId = opts.refusalOptionId?.trim() || COUNCIL_REFUSAL_OPTION_ID;
+    this.fallbackProfileManager = opts.fallbackProfileManager;
+    this.seatCaller = opts.seatCaller;
+    this.judgeCaller = opts.judgeCaller;
   }
   async ask(question) {
     const startedAt = Date.now();
@@ -1361,9 +1367,9 @@ var CouncilOrchestrator = class {
     const votes = await mapConcurrent(
       profile.seats,
       Math.min(this.maxConcurrency, profile.seats.length),
-      async (seat) => {
+      async (seat, i) => {
         try {
-          return await this.callSeat(question, profile, seat, signal, usage);
+          return await this.callSeat(question, profile, seat, i, signal, usage);
         } catch (error) {
           return {
             seatId: seat.id,
@@ -1425,7 +1431,7 @@ var CouncilOrchestrator = class {
       errors
     );
   }
-  async callSeat(question, profile, seat, signal, usage) {
+  async callSeat(question, profile, seat, seatIndex, signal, usage) {
     if (signal.aborted) return cancelledVote(seat);
     let persona;
     try {
@@ -1447,7 +1453,8 @@ var CouncilOrchestrator = class {
       maxTokens: profile.voterMaxTokens,
       timeoutMs: profile.perCallTimeoutMs,
       signal,
-      usage
+      usage,
+      seatIndex
     });
     const metadata = callMetadata(result);
     if (result.error) {
@@ -1698,19 +1705,20 @@ var CouncilOrchestrator = class {
     return parseJudge(result.text, question, this.refusalOptionId);
   }
   async safeCall(input) {
+    const effectiveCaller = input.seatIndex !== void 0 && this.seatCaller ? this.seatCaller(input.seatIndex) : this.judgeCaller ?? (this.seatCaller ? this.seatCaller(0) : this.caller);
+    const resolvedTarget = this.resolveCouncilTarget(input.target);
     try {
-      const result = await this.caller.call({
+      const result = await effectiveCaller.call({
         system: input.system,
         userPrompt: input.userPrompt,
         responseFormat: { type: "json_object" },
         maxTokens: input.maxTokens,
         timeoutMs: input.timeoutMs,
         signal: input.signal,
-        ...input.target?.providerId ? { providerId: input.target.providerId } : {},
-        ...input.target?.model ? { model: input.target.model } : {},
-        ...input.target?.role ? { role: input.target.role } : {},
-        ...input.target?.fallbackProfile ? { fallbackProfile: input.target.fallbackProfile } : {},
-        ...input.target?.fallbackModels ? { fallbackModels: [...input.target.fallbackModels] } : {}
+        ...resolvedTarget?.providerId ? { providerId: resolvedTarget.providerId } : {},
+        ...resolvedTarget?.model ? { model: resolvedTarget.model } : {},
+        ...resolvedTarget?.role ? { role: resolvedTarget.role } : {},
+        ...resolvedTarget?.fallbackModels && resolvedTarget.fallbackModels.length > 0 ? { fallbackModels: [...resolvedTarget.fallbackModels] } : {}
       });
       addUsage(input.usage, result);
       return result;
@@ -1719,9 +1727,42 @@ var CouncilOrchestrator = class {
       return emptyCallResult(errorMessage(error));
     }
   }
+  /**
+   * Resolve a CouncilModelTarget: pre-resolve fallbackProfile to fallbackModels
+   * so the downstream caller only sees the resolved chain.
+   */
+  resolveCouncilTarget(target) {
+    if (!target) return void 0;
+    if (!target.fallbackProfile) return target;
+    const mgr = this.fallbackProfileManager;
+    if (!mgr) return target;
+    const chain = mgr.resolve(target.fallbackProfile);
+    if (chain.length === 0) return target;
+    const combined = [
+      ...chain.map((e) => `${e.providerId}/${e.model}`),
+      ...target.fallbackModels ?? []
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = combined.filter((ref) => {
+      if (seen.has(ref)) return false;
+      seen.add(ref);
+      return true;
+    });
+    return {
+      ...target.providerId ? { providerId: target.providerId } : {},
+      ...target.model ? { model: target.model } : {},
+      ...target.role ? { role: target.role } : {},
+      fallbackModels: deduped
+    };
+  }
 };
 function parseVote(text, question, refusalOptionId) {
   const parsed = parseObject(text);
+  if (!parsed.ok && (!question.options || question.options.length === 0)) {
+    const fallback = text.trim();
+    if (fallback) return { ok: true, vote: { stance: fallback } };
+    return { ok: false, error: "Voter returned an empty response." };
+  }
   if (!parsed.ok) return parsed;
   const rationale = optionalString(parsed.value["rationale"]);
   if (question.options && question.options.length > 0) {
@@ -1738,6 +1779,11 @@ function parseVote(text, question, refusalOptionId) {
 }
 function parseJudge(text, question, refusalOptionId) {
   const parsed = parseObject(text);
+  if (!parsed.ok && (!question.options || question.options.length === 0)) {
+    const fallback = text.trim();
+    if (fallback) return { ok: true, value: { answer: fallback } };
+    return { ok: false, error: "Judge returned an empty response." };
+  }
   if (!parsed.ok) return parsed;
   const rationale = optionalString(parsed.value["rationale"]);
   if (question.options && question.options.length > 0) {
@@ -1913,7 +1959,10 @@ var INPUT_SCHEMA = {
   additionalProperties: false
 };
 function createCouncilTool(opts) {
-  const orchestrator = new CouncilOrchestrator(opts);
+  const orchestrator = new CouncilOrchestrator({
+    ...opts,
+    fallbackProfileManager: opts.fallbackProfileManager
+  });
   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.",
@@ -1962,6 +2011,84 @@ function validateCouncilToolInput(input) {
   return errors;
 }
 
+// src/core/model-availability-calendar.ts
+function logicalCalendarTarget(providerId, model) {
+  if (providerId !== "omniroute") return { providerId, model };
+  const slash = model.indexOf("/");
+  return slash > 0 && slash < model.length - 1 ? { providerId: model.slice(0, slash), model: model.slice(slash + 1) } : { providerId, model };
+}
+var WEEKDAYS = {
+  Sun: 0,
+  Mon: 1,
+  Tue: 2,
+  Wed: 3,
+  Thu: 4,
+  Fri: 5,
+  Sat: 6
+};
+function minuteOfDay(value) {
+  const match = /^(\d{2}):(\d{2})$/.exec(value);
+  if (!match) return void 0;
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  if (hour > 23 || minute > 59) return void 0;
+  return hour * 60 + minute;
+}
+function clockAt(date, timezone) {
+  try {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      weekday: "short",
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h23"
+    }).formatToParts(date);
+    const weekday = parts.find((part) => part.type === "weekday")?.value;
+    const hour = Number(parts.find((part) => part.type === "hour")?.value);
+    const minute = Number(parts.find((part) => part.type === "minute")?.value);
+    if (!weekday || WEEKDAYS[weekday] === void 0 || !Number.isFinite(hour + minute))
+      return void 0;
+    return { day: WEEKDAYS[weekday], minute: hour * 60 + minute };
+  } catch {
+    return void 0;
+  }
+}
+function targetMatches(rule, providerId, model) {
+  if (rule.provider && rule.provider !== providerId) return false;
+  if (rule.model && rule.model !== model) return false;
+  return Boolean(rule.provider || rule.model);
+}
+function timeMatches(rule, day, minute) {
+  const start = minuteOfDay(rule.start);
+  const end = minuteOfDay(rule.end);
+  if (start === void 0 || end === void 0) return false;
+  const days = rule.days?.length ? new Set(rule.days) : void 0;
+  if (start === end) return !days || days.has(day);
+  if (start < end) return (!days || days.has(day)) && minute >= start && minute < end;
+  if (minute >= start) return !days || days.has(day);
+  const previousDay = (day + 6) % 7;
+  return minute < end && (!days || days.has(previousDay));
+}
+function evaluateModelCalendar(rules, providerId, model, at = /* @__PURE__ */ new Date()) {
+  ({ providerId, model } = logicalCalendarTarget(providerId, model));
+  const allowRules = [];
+  let allowMatched = false;
+  for (const rule of rules ?? []) {
+    if (rule.enabled === false || !targetMatches(rule, providerId, model)) continue;
+    const clock = clockAt(at, rule.timezone);
+    if (!clock || minuteOfDay(rule.start) === void 0 || minuteOfDay(rule.end) === void 0)
+      continue;
+    if (rule.mode === "allow_only") {
+      allowRules.push(rule);
+      if (timeMatches(rule, clock.day, clock.minute)) allowMatched = true;
+    } else if (timeMatches(rule, clock.day, clock.minute)) {
+      return { allowed: false, rule };
+    }
+  }
+  if (allowRules.length > 0 && !allowMatched) return { allowed: false, rule: allowRules[0] };
+  return { allowed: true };
+}
+
 // src/types/blocks.ts
 function isTextBlock(b) {
   return b.type === "text";
@@ -1970,18 +2097,20 @@ function isTextBlock(b) {
 // src/types/provider.ts
 var CONTEXT_OVERFLOW_RE = /context.length|context.window|max.*tokens?.*exceeded|prompt is too long|too long|exceeds the context|\btokens\b.*exceed|context_length_exceeded/i;
 var CONTENT_FILTER_RE = /content.(filter|policy|moderation)|safety (system|filter)/i;
+var QUOTA_EXHAUSTED_RE = /(?:insufficient|exhausted|depleted|exceeded|no|not enough)[-_\s]*(?:quota|credit|balance)|(?:quota|credit|balance)[-_\s]*(?:exhausted|depleted|exceeded|insufficient)|billing[_\s-]*(?:hard[_\s-]*)?limit|payment required|spending limit|plan limit/i;
 function classifyProviderError(status, body, message) {
   const type = body?.type;
+  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
   if (status === 0) return "network";
   if (status === 408) return "timeout";
   if (status === 599) return "stream_hang";
+  if (status === 402 || QUOTA_EXHAUSTED_RE.test(text)) return "quota_exhausted";
   if (type === "rate_limit_error" || status === 429) return "rate_limit";
   if (type === "overloaded_error" || status === 529) return "overloaded";
   if (status >= 500) return "server";
   if (type === "authentication_error" || type === "permission_error" || status === 401 || status === 403) {
     return "auth";
   }
-  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
   if (type === "content_filter" || CONTENT_FILTER_RE.test(text)) return "content_filter";
   if (status === 413 || status >= 400 && CONTEXT_OVERFLOW_RE.test(text)) {
     return "context_overflow";
@@ -1994,6 +2123,7 @@ function isFallbackWorthy(kind) {
 }
 var FALLBACK_WORTHY_BY_KIND = {
   rate_limit: true,
+  quota_exhausted: true,
   overloaded: true,
   server: true,
   timeout: true,
@@ -2072,6 +2202,7 @@ var KIND_TO_CODE = {
   network: ERROR_CODES.PROVIDER_NETWORK_ERROR,
   timeout: ERROR_CODES.PROVIDER_NETWORK_ERROR,
   rate_limit: ERROR_CODES.PROVIDER_RATE_LIMITED,
+  quota_exhausted: ERROR_CODES.PROVIDER_RATE_LIMITED,
   auth: ERROR_CODES.PROVIDER_AUTH_FAILED,
   overloaded: ERROR_CODES.PROVIDER_OVERLOADED,
   context_overflow: ERROR_CODES.PROVIDER_CONTEXT_OVERFLOW,
@@ -2085,98 +2216,6 @@ function kindToCode(kind) {
   return KIND_TO_CODE[kind];
 }
 
-// src/core/fallback-model.ts
-function visibleProviderModels(config, providerId, providerModels) {
-  const entry = config.providers?.[providerId];
-  return entry?.models !== void 0 ? [...entry.models] : providerModels;
-}
-function parseModelRef(ref) {
-  const trimmed = ref.trim();
-  const slash = trimmed.indexOf("/");
-  if (slash !== -1) {
-    return {
-      provider: trimmed.slice(0, slash) || void 0,
-      model: trimmed.slice(slash + 1).trim()
-    };
-  }
-  const parts = trimmed.split(/\s+/);
-  if (parts.length >= 2) {
-    return { provider: parts[0], model: parts.slice(1).join(" ") };
-  }
-  return { model: trimmed };
-}
-function formatModelRef(ref, defaultProvider) {
-  const provider = ref.provider ?? defaultProvider;
-  return provider ? `${provider}/${ref.model}` : ref.model;
-}
-function normalizeModelRef(ref, defaultProvider) {
-  const parsed = parseModelRef(ref);
-  return formatModelRef(parsed, defaultProvider);
-}
-function fallbackProfileChain(config, profileName) {
-  if (!profileName) return [];
-  const chain = config.fallbackProfiles?.[profileName];
-  return Array.isArray(chain) ? chain.filter((ref) => parseModelRef(ref).model) : [];
-}
-function providerHasKey(entry) {
-  if (!entry) return false;
-  if (typeof entry.apiKey === "string" && entry.apiKey.length > 0) return true;
-  if (Array.isArray(entry.apiKeys) && entry.apiKeys.some((k) => k?.apiKey)) return true;
-  if (Array.isArray(entry.envVars) && entry.envVars.some((v) => !!process.env[v])) return true;
-  return false;
-}
-var SMART_DEFAULT_MAX = 4;
-function smartDefaultFallbackChain(config) {
-  const leaderProvider = config.provider;
-  const leaderModel = config.model;
-  const providers = config.providers ?? {};
-  const favoriteSet = new Set(
-    (config.favoriteModels ?? []).map((ref) => normalizeModelRef(ref, leaderProvider))
-  );
-  const hasFavorites = favoriteSet.size > 0;
-  const favoritesOnly = config.favoriteModelsOnly === true;
-  const seen = /* @__PURE__ */ new Set();
-  const favoriteRefs = [];
-  const sameProvider = [];
-  const crossProvider = [];
-  const ids = Object.keys(providers).sort(
-    (a, b) => a === leaderProvider ? -1 : b === leaderProvider ? 1 : a.localeCompare(b)
-  );
-  for (const id of ids) {
-    const entry = providers[id];
-    if (!providerHasKey(entry)) continue;
-    const models = visibleProviderModels(config, id, entry?.models ?? []);
-    for (const model of models) {
-      if (id === leaderProvider && model === leaderModel) continue;
-      const ref = `${id}/${model}`;
-      if (seen.has(ref)) continue;
-      seen.add(ref);
-      if (favoriteSet.has(ref)) {
-        favoriteRefs.push(ref);
-        continue;
-      }
-      if (favoritesOnly && hasFavorites) continue;
-      (id === leaderProvider ? sameProvider : crossProvider).push(ref);
-    }
-  }
-  return [...favoriteRefs, ...sameProvider, ...crossProvider].slice(0, SMART_DEFAULT_MAX);
-}
-function effectiveFallbackChain(config) {
-  const explicit = config.fallbackModels ?? [];
-  const filteredExplicit = explicit.filter((ref) => {
-    const parsed = parseModelRef(ref);
-    if (!parsed.model) return false;
-    const providerId = parsed.provider ?? config.provider;
-    const entry = config.providers?.[providerId];
-    if (!entry?.models) return true;
-    return entry.models.includes(parsed.model);
-  });
-  if (filteredExplicit.length > 0) return filteredExplicit;
-  if (config.fallbackAuto === false) return [];
-  return smartDefaultFallbackChain(config);
-}
-var DEFAULT_PRIMARY_COOLDOWN_MAX_MS = 10 * 6e4;
-
 // src/execution/one-shot-llm.ts
 var DEFAULT_TIMEOUT_MS = 3e4;
 var DEFAULT_MAX_TOKENS = 1024;
@@ -2223,71 +2262,74 @@ var OneShotOrchestrator = class {
     const request = this.buildRequest(input, target.model);
     const signal = this.resolveSignal(input);
     const chain = this.resolveFallbackChain(input, config, target);
+    const tracker = this.opts.statusTracker;
     let servingProviderId = provider.id;
     let servingModel = target.model;
     let fromFallback = false;
-    const primaryAttempt = await this.tryCall(provider, request, signal);
-    let result = primaryAttempt.response;
-    let lastError = primaryAttempt.error;
-    let fallbackEligible = primaryAttempt.fallbackEligible;
-    if (!result && fallbackEligible && chain.length > 0) {
-      for (const ref of chain) {
-        const parsed = parseModelRef(ref);
-        if (!parsed.model) continue;
-        const fbProviderId = parsed.provider ?? config.provider;
-        if (fbProviderId === provider.id && parsed.model === target.model) continue;
-        servingProviderId = fbProviderId;
-        servingModel = parsed.model;
-        let fbProvider;
-        try {
-          fbProvider = await this.opts.buildProvider(fbProviderId, parsed.model);
-        } catch (err) {
-          lastError = err;
-          continue;
-        }
-        servingProviderId = fbProvider.id;
-        const attempt = await this.tryCall(
-          fbProvider,
-          this.buildRequest(input, parsed.model),
-          signal
-        );
-        if (attempt.response) {
-          result = attempt.response;
-          fromFallback = true;
-          break;
-        }
-        lastError = attempt.error;
-        fallbackEligible = attempt.fallbackEligible;
-        if (!fallbackEligible) break;
+    let lastError;
+    let fallbackEligible = false;
+    if (tracker && !tracker.isAvailable(target.providerId, target.model) || !evaluateModelCalendar(config.modelAvailabilitySchedule, target.providerId, target.model).allowed) {
+      this.opts.logger?.debug(
+        `one-shot: primary "${target.providerId}/${target.model}" is blocked \u2014 trying fallback`
+      );
+    } else {
+      const primaryAttempt = await this.tryCall(
+        provider,
+        request,
+        signal,
+        target.providerId,
+        target.model
+      );
+      const result = primaryAttempt.response;
+      lastError = primaryAttempt.error;
+      fallbackEligible = primaryAttempt.fallbackEligible;
+      if (result) {
+        tracker?.recordSuccess(target.providerId, target.model);
+        servingProviderId = provider.id;
+        servingModel = target.model;
+        return this.buildResult(result, servingProviderId, servingModel, false, startedAt);
+      }
+      if (!fallbackEligible || chain.length === 0) {
+        return this.buildErrorResult(lastError, target.providerId, target.model, false, startedAt);
       }
     }
-    const elapsed = Math.round(performance.now() - startedAt);
-    if (result) {
-      const textBlocks = result.content.filter(isTextBlock);
-      const text = textBlocks.map((b) => b.text).join("\n").trim();
-      return {
-        text: text || "(empty response)",
-        model: result.model ?? servingModel,
-        provider: servingProviderId,
-        tokens: {
-          input: result.usage?.input ?? 0,
-          output: result.usage?.output ?? 0,
-          total: (result.usage?.input ?? 0) + (result.usage?.output ?? 0)
-        },
-        durationMs: elapsed,
-        fromFallback,
-        stopReason: result.stopReason
-      };
+    const usableChain = tracker ? chain.filter((e) => tracker.isAvailable(e.providerId, e.model)) : chain;
+    for (const entry of usableChain) {
+      if (!evaluateModelCalendar(config.modelAvailabilitySchedule, entry.providerId, entry.model).allowed)
+        continue;
+      if (entry.providerId === provider.id && entry.model === target.model) continue;
+      let fbProvider;
+      try {
+        fbProvider = await this.opts.buildProvider(entry.providerId, entry.model);
+      } catch (err) {
+        lastError = err;
+        continue;
+      }
+      servingProviderId = fbProvider.id;
+      servingModel = entry.model;
+      const attempt = await this.tryCall(
+        fbProvider,
+        this.buildRequest(input, entry.model),
+        signal,
+        entry.providerId,
+        entry.model
+      );
+      if (attempt.response) {
+        tracker?.recordSuccess(entry.providerId, entry.model);
+        fromFallback = true;
+        return this.buildResult(attempt.response, servingProviderId, servingModel, true, startedAt);
+      }
+      lastError = attempt.error;
+      fallbackEligible = attempt.fallbackEligible;
+      if (!fallbackEligible) break;
     }
-    return {
-      text: "",
-      model: servingModel,
-      provider: servingProviderId,
-      tokens: { input: 0, output: 0, total: 0 },
-      durationMs: elapsed,
+    return this.buildErrorResult(
+      lastError,
+      servingProviderId,
+      servingModel,
       fromFallback,
-      error: lastError instanceof Error ? lastError.message : String(lastError ?? "Unknown error")
-    };
+      startedAt
+    );
   }
   // ── Private helpers ─────────────────────────────────────────────
   /**
@@ -2343,38 +2385,81 @@ var OneShotOrchestrator = class {
   }
   /**
    * Build the fallback model chain from input + config + current target.
+   * The injected {@link OneShotOrchestratorOptions.fallbackProfileManager}
+   * is the only allowed manager — OneShot never owns a private snapshot
+   * so a live `ConfigStore` change reaches every call without rebuilding
+   * the manager.
    */
   resolveFallbackChain(input, config, target) {
+    const mgr = this.opts.fallbackProfileManager;
     if (input.fallbackModels && input.fallbackModels.length > 0) {
-      return input.fallbackModels;
+      return mgr.resolveRefs(input.fallbackModels, target);
     }
-    if (input.fallbackProfile) {
-      const profile = fallbackProfileChain(config, input.fallbackProfile);
-      if (profile.length > 0) return profile;
+    if (config.fallbackModels && config.fallbackModels.length > 0) {
+      return mgr.resolveRefs(config.fallbackModels, target);
     }
     if (config.fallbackAuto !== false) {
-      return effectiveFallbackChain(config).filter((ref) => {
-        const parsed = parseModelRef(ref);
-        const fbProvider = parsed.provider ?? config.provider;
-        return !(fbProvider === target.providerId && parsed.model === target.model);
+      return mgr.resolveEffective({
+        fallbackAuto: true,
+        exclude: target
       });
     }
-    return [];
+    return Object.freeze([]);
   }
   /** Attempt a provider call while preserving the actual failure for callers. */
-  async tryCall(provider, request, signal) {
+  async tryCall(provider, request, signal, providerId, model) {
     try {
       return {
         response: await provider.complete(request, { signal }),
         fallbackEligible: false
       };
     } catch (err) {
+      if (err instanceof ProviderError && providerId && model) {
+        this.opts.statusTracker?.recordFailure(
+          providerId,
+          model,
+          err.kind,
+          err.status,
+          err.describe(),
+          { retryAfterMs: err.body?.retryAfterMs }
+        );
+      }
       return {
         error: err,
         fallbackEligible: !signal.aborted && (!(err instanceof ProviderError) || isFallbackWorthy(err.kind))
       };
     }
   }
+  /** Build a success result from a provider Response. */
+  buildResult(response, servingProviderId, servingModel, fromFallback, startedAt) {
+    const textBlocks = response.content.filter(isTextBlock);
+    const text = textBlocks.map((b) => b.text).join("\n").trim();
+    return {
+      text: text || "(empty response)",
+      model: response.model ?? servingModel,
+      provider: servingProviderId,
+      tokens: {
+        input: response.usage?.input ?? 0,
+        output: response.usage?.output ?? 0,
+        total: (response.usage?.input ?? 0) + (response.usage?.output ?? 0)
+      },
+      durationMs: Math.round(performance.now() - startedAt),
+      fromFallback,
+      stopReason: response.stopReason
+    };
+  }
+  /** Build a total-failure error result. */
+  buildErrorResult(error, servingProviderId, servingModel, fromFallback, startedAt) {
+    return {
+      text: "",
+      model: servingModel,
+      provider: servingProviderId,
+      tokens: { input: 0, output: 0, total: 0 },
+      durationMs: Math.round(performance.now() - startedAt),
+      fromFallback,
+      error: error instanceof Error ? error.message : String(error ?? "Unknown error")
+    };
+  }
 };
 function asTextBlocks(system) {
   if (!system) return [];
@@ -2427,14 +2512,10 @@ var INPUT_SCHEMA2 = {
       type: "string",
       description: "Roster role for model-matrix routing. Overrides model/providerId."
     },
-    fallbackProfile: {
-      type: "string",
-      description: "Named fallback profile from config.fallbackProfiles."
-    },
     fallbackModels: {
       type: "array",
       items: { type: "string" },
-      description: 'Explicit fallback model chain (e.g. ["anthropic/claude-haiku", "openai/gpt-4o-mini"]).'
+      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",
@@ -2472,13 +2553,14 @@ function createOneShotLLMTool(opts) {
   const orchestrator = new OneShotOrchestrator({
     buildProvider: opts.buildProvider,
     getConfig: opts.getConfig,
+    fallbackProfileManager: opts.fallbackProfileManager,
     modelRouter: opts.modelRouter,
     logger: opts.logger
   });
   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 `fallbackProfile` or `fallbackModels` for resilience. Check `error` on the result for failure details.",
+    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,
     permission: "auto",
     mutating: false,
@@ -2504,13 +2586,3162 @@ function createOneShotLLMTool(opts) {
     }
   };
 }
+
+// src/coordination/agents/types.ts
+var HOUR = 60 * 60 * 1e3;
+var LIGHT_BUDGET = {
+  timeoutMs: 3 * HOUR,
+  maxIterations: 3e3,
+  maxToolCalls: 8e3
+};
+var MEDIUM_BUDGET = {
+  timeoutMs: 5 * HOUR,
+  maxIterations: 5e3,
+  maxToolCalls: 14e3
+};
+var HEAVY_BUDGET = {
+  timeoutMs: 10 * HOUR,
+  maxIterations: 8e3,
+  maxToolCalls: 2e4
+};
+var TOOLS = {
+  /** Pure read/inspect — safe for analysis and review agents. */
+  read: ["read", "grep", "glob", "search", "tree", "mailbox"],
+  /** Read + structured inspection (logs, diffs, json, dependency audit). */
+  inspect: ["read", "grep", "glob", "search", "tree", "json", "diff", "logs", "audit", "mailbox"],
+  /** Read + edit (no shell). For agents that write code/docs but don't run it. */
+  write: ["read", "grep", "glob", "search", "tree", "write", "edit", "replace", "patch", "mailbox"],
+  /** Full build loop: edit + run (lint/format/typecheck/test/bash). */
+  build: [
+    "read",
+    "grep",
+    "glob",
+    "search",
+    "tree",
+    "write",
+    "edit",
+    "replace",
+    "patch",
+    "bash",
+    "exec",
+    "lint",
+    "format",
+    "typecheck",
+    "test",
+    "mailbox"
+  ],
+  /** Version control. */
+  vcs: ["read", "grep", "glob", "git", "diff"],
+  /** Dependency management + CVE audit. */
+  deps: ["read", "grep", "glob", "install", "outdated", "audit", "json", "mailbox"],
+  /** Documentation authoring. */
+  docs: ["read", "grep", "glob", "search", "tree", "write", "edit", "document", "mailbox"],
+  /** Web research. */
+  research: ["read", "grep", "glob", "search", "fetch", "mailbox"]
+};
+
+// src/coordination/agents/agent-prompts.ts
+import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import * as os from "node:os";
+import * as path3 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var promptCache = /* @__PURE__ */ new Map();
+var candidateCache = /* @__PURE__ */ new Map();
+function agentPrompt(id) {
+  const envDir = process.env["WRONGSTACK_AGENT_INSTRUCTIONS_DIR"] ?? "";
+  const cacheKey = `${envDir}\0${id}`;
+  const cached = promptCache.get(cacheKey);
+  if (cached !== void 0) return cached;
+  const fileName = `${id}.md`;
+  let resolved = "";
+  for (const dir of agentPromptDirCandidates(envDir)) {
+    try {
+      resolved = readFileSync2(path3.join(dir, fileName), "utf8").trimEnd();
+      break;
+    } catch {
+    }
+  }
+  promptCache.set(cacheKey, resolved);
+  return resolved;
+}
+function agentPromptDirCandidates(envDir) {
+  const globalRoot = process.env["WRONGSTACK_HOME"] || path3.join(os.homedir(), ".wrongstack");
+  const candKey = `${envDir}\0${globalRoot}`;
+  const cached = candidateCache.get(candKey);
+  if (cached !== void 0) return cached;
+  const here = path3.dirname(fileURLToPath2(import.meta.url));
+  const explicitDir = envDir || void 0;
+  const candidates = [
+    ...explicitDir ? [path3.resolve(explicitDir)] : [],
+    path3.join(globalRoot, "instructions", "agents"),
+    path3.resolve(here, "../../../../instructions/agents"),
+    path3.resolve(here, "../../../instructions/agents"),
+    path3.resolve(here, "../../instructions/agents"),
+    path3.resolve(here, "../instructions/agents"),
+    path3.resolve(here, "instructions/agents")
+  ];
+  const ordered = candidates.sort((a, b) => Number(!isDirectory2(a)) - Number(!isDirectory2(b)));
+  candidateCache.set(candKey, ordered);
+  return ordered;
+}
+function isDirectory2(candidate) {
+  try {
+    return statSync2(candidate).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/coordination/agents/phase1-discovery.ts
+var DISCOVERY_AGENTS = [
+  {
+    config: {
+      id: "explore",
+      name: "Explore",
+      role: "explore",
+      tools: [...TOOLS.read],
+      prompt: agentPrompt("explore")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "discovery",
+      summary: "Maps unfamiliar codebases: entry points, structure, architecture, feature flow (read-only).",
+      keywords: [
+        "explore",
+        "map",
+        "understand",
+        "where is",
+        "how does",
+        "codebase",
+        "architecture",
+        "structure",
+        "overview",
+        "find file",
+        "entry point",
+        "orient"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "search",
+      name: "Search",
+      role: "search",
+      tools: [...TOOLS.read],
+      prompt: agentPrompt("search")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "discovery",
+      summary: "Semantic + lexical code search across repos; finds definitions, references, duplicates, ranks by relevance.",
+      keywords: [
+        "search",
+        "find all",
+        "references",
+        "usages",
+        "call sites",
+        "grep",
+        "locate symbol",
+        "duplicate",
+        "where used",
+        "occurrences",
+        "cross-repo"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "research",
+      name: "Research",
+      role: "research",
+      tools: [...TOOLS.research],
+      prompt: agentPrompt("research")
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "discovery",
+      summary: "Technical research and feasibility: compares libraries/approaches, recommends a path with evidence and tradeoffs.",
+      keywords: [
+        "research",
+        "feasibility",
+        "compare libraries",
+        "which library",
+        "best practice",
+        "tradeoff",
+        "investigate",
+        "evaluate approach",
+        "should we use",
+        "pros and cons"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase2-planning.ts
+var PLAN_TOOLS = [...TOOLS.read, "plan", "todo"];
+var PLANNING_AGENTS = [
+  {
+    config: {
+      id: "analyst",
+      name: "Analyst",
+      role: "analyst",
+      tools: [...PLAN_TOOLS],
+      prompt: agentPrompt("analyst")
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "planning",
+      summary: "Requirement analysis: turns vague requests into testable specs with acceptance criteria and open questions.",
+      keywords: [
+        "requirements",
+        "analyze requirement",
+        "acceptance criteria",
+        "spec",
+        "specification",
+        "clarify",
+        "scope",
+        "user story",
+        "what should it do"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "planner",
+      name: "Planner",
+      role: "planner",
+      tools: [...PLAN_TOOLS],
+      prompt: agentPrompt("planner")
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "planning",
+      summary: "Execution planning: decomposes a goal into ordered, dependency-aware, parallelizable steps with checkpoints.",
+      keywords: [
+        "plan",
+        "execution plan",
+        "break down",
+        "decompose",
+        "steps",
+        "sequence",
+        "roadmap",
+        "task breakdown",
+        "order of work",
+        "milestones"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "architect",
+      name: "Architect",
+      role: "architect",
+      tools: [...PLAN_TOOLS],
+      prompt: agentPrompt("architect")
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "planning",
+      summary: "System architecture: designs module boundaries, interfaces, data flow, and records key decisions.",
+      keywords: [
+        "architecture",
+        "design system",
+        "module boundaries",
+        "interfaces",
+        "data flow",
+        "component design",
+        "system design",
+        "decision record",
+        "adr",
+        "structure the"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "critic",
+      name: "Critic",
+      role: "critic",
+      tools: [...TOOLS.read],
+      prompt: agentPrompt("critic")
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "planning",
+      summary: "Adversarial review of plans/designs: finds gaps, risks, and unstated assumptions with ranked fixes.",
+      keywords: [
+        "critique",
+        "review plan",
+        "review design",
+        "red team",
+        "poke holes",
+        "risks",
+        "what could go wrong",
+        "second opinion",
+        "challenge",
+        "flaws"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "refactor-planner",
+      name: "Refactor Planner",
+      role: "refactor-planner",
+      tools: [...PLAN_TOOLS, "diff"],
+      prompt: agentPrompt("refactor-planner")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "planning",
+      summary: "Refactoring planner: analyzes code structure, maps dependencies, produces risk-scored phased plans with rollback strategy.",
+      keywords: [
+        "refactor",
+        "refactoring",
+        "restructure",
+        "debt",
+        "technical debt",
+        "clean up",
+        "modularize",
+        "decouple",
+        "dependency graph",
+        "code structure"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase3-build.ts
+var BUILD_AGENTS = [
+  {
+    config: {
+      id: "executor",
+      name: "Executor",
+      role: "executor",
+      tools: [...TOOLS.build],
+      prompt: agentPrompt("executor")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Implements well-specified tasks: writes code, runs checks, leaves the tree green.",
+      keywords: [
+        "implement",
+        "build",
+        "write code",
+        "add feature",
+        "create",
+        "code up",
+        "develop",
+        "apply change",
+        "make it work"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "refactor",
+      name: "Refactor",
+      role: "refactor",
+      tools: [...TOOLS.build],
+      prompt: agentPrompt("refactor")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Structural refactoring: extract/split/move/rename/decouple without changing observable behavior.",
+      keywords: [
+        "refactor",
+        "restructure",
+        "extract",
+        "split module",
+        "decouple",
+        "rename",
+        "move code",
+        "break dependency",
+        "reorganize"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "simplifier",
+      name: "Simplifier",
+      role: "simplifier",
+      tools: [...TOOLS.build],
+      prompt: agentPrompt("simplifier")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Reduces complexity: deletes dead code, collapses needless abstractions, shortens and clarifies code.",
+      keywords: [
+        "simplify",
+        "dead code",
+        "remove unused",
+        "reduce complexity",
+        "clean up",
+        "denest",
+        "shorten",
+        "over-engineered",
+        "too complex"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "migration",
+      name: "Migration",
+      role: "migration",
+      tools: [...TOOLS.build, "install", "outdated"],
+      prompt: agentPrompt("migration")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Framework/language/version upgrades: applies codemods across call sites, staged and verified.",
+      keywords: [
+        "migrate",
+        "upgrade",
+        "codemod",
+        "breaking change",
+        "major version",
+        "port to",
+        "convert to",
+        "esm",
+        "modernize"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "vision",
+      name: "Vision",
+      role: "vision",
+      tools: [...TOOLS.write, "fetch"],
+      prompt: agentPrompt("vision")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Screenshot/mockup \u2192 UI code: infers component tree and generates matching, accessible markup.",
+      keywords: [
+        "screenshot",
+        "mockup",
+        "design to code",
+        "image to ui",
+        "figma",
+        "replicate this ui",
+        "from this picture",
+        "vision",
+        "clone ui"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "debugger",
+      name: "Debugger",
+      role: "debugger",
+      tools: [...TOOLS.build, "logs"],
+      prompt: agentPrompt("debugger")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Root-cause bug fixing: reproduces, bisects to the true cause, applies a minimal fix with a regression test.",
+      keywords: [
+        "bug",
+        "fix",
+        "debug",
+        "broken",
+        "error",
+        "crash",
+        "root cause",
+        "not working",
+        "failing",
+        "reproduce",
+        "why does"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "tracer",
+      name: "Tracer",
+      role: "tracer",
+      tools: [...TOOLS.build, "logs"],
+      prompt: agentPrompt("tracer")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "build",
+      summary: "Runtime tracing: instruments and runs code to observe call order, values, and timing, then cleans up.",
+      keywords: [
+        "trace",
+        "runtime",
+        "instrument",
+        "execution path",
+        "what happens at runtime",
+        "call order",
+        "profile execution",
+        "observe behavior",
+        "stack trace"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase4-verify.ts
+var VERIFY_AGENTS = [
+  {
+    config: {
+      id: "verifier",
+      name: "Verifier",
+      role: "verifier",
+      tools: [...TOOLS.inspect, "bash", "exec", "lint", "typecheck", "test", "git"],
+      prompt: agentPrompt("verifier")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Independent verification gate: runs the relevant checks until they pass or returns exact failures that need another implementation pass.",
+      keywords: [
+        "verify",
+        "verification",
+        "quality gate",
+        "prove it works",
+        "run checks",
+        "run tests until pass",
+        "test pass",
+        "green build",
+        "typecheck",
+        "lint",
+        "regression check",
+        "acceptance gate"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "test",
+      name: "Test",
+      role: "test",
+      tools: [...TOOLS.build],
+      prompt: agentPrompt("test")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Unit + integration testing: writes meaningful tests covering golden path and edge cases, runs the suite.",
+      keywords: [
+        "test",
+        "unit test",
+        "integration test",
+        "write tests",
+        "coverage",
+        "test suite",
+        "vitest",
+        "jest",
+        "add tests",
+        "spec"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "e2e",
+      name: "E2E",
+      role: "e2e",
+      tools: [
+        ...TOOLS.build,
+        "fetch",
+        "playwright_navigate",
+        "playwright_screenshot",
+        "playwright_click",
+        "playwright_type",
+        "playwright_evaluate",
+        "playwright_select_option",
+        "playwright_hover",
+        "playwright_fill_form",
+        "playwright_wait_for",
+        "playwright_press_key",
+        "playwright_drag"
+      ],
+      prompt: agentPrompt("e2e")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "End-to-end testing: drives full user journeys across UI/CLI/API boundaries with reproducible failures.",
+      keywords: [
+        "e2e",
+        "end to end",
+        "end-to-end",
+        "user journey",
+        "smoke test",
+        "playwright",
+        "browser",
+        "screenshot",
+        "web ui",
+        "headless",
+        "cypress",
+        "full flow",
+        "browser test",
+        "acceptance test",
+        "navigate",
+        "click",
+        "form fill",
+        "dom",
+        "page load"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "browser",
+      name: "Browser",
+      role: "browser",
+      tools: [
+        ...TOOLS.read,
+        "fetch",
+        "playwright_navigate",
+        "playwright_screenshot",
+        "playwright_click",
+        "playwright_type",
+        "playwright_evaluate",
+        "playwright_select_option",
+        "playwright_hover",
+        "playwright_fill_form",
+        "playwright_wait_for",
+        "playwright_press_key",
+        "playwright_drag"
+      ],
+      prompt: agentPrompt("browser")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Browser automation: opens pages, clicks, types, screenshots, extracts data via Playwright headless Chromium.",
+      keywords: [
+        "browser",
+        "screenshot",
+        "navigate",
+        "web page",
+        "scrape",
+        "crawl",
+        "headless",
+        "chrome",
+        "open url",
+        "capture",
+        "page title",
+        "extract data",
+        "fill form",
+        "click button",
+        "take screenshot"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "performance",
+      name: "Performance",
+      role: "performance",
+      tools: [...TOOLS.build, "logs"],
+      prompt: agentPrompt("performance")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Performance analysis: benchmarks/profiles to find the real bottleneck, optimizes, proves speedup with numbers.",
+      keywords: [
+        "performance",
+        "slow",
+        "optimize",
+        "bottleneck",
+        "profile",
+        "benchmark",
+        "latency",
+        "throughput",
+        "memory",
+        "speed up",
+        "too slow"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "chaos",
+      name: "Chaos",
+      role: "chaos",
+      tools: [...TOOLS.build, "logs"],
+      prompt: agentPrompt("chaos")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Resilience testing via fault injection: breaks network/disk/timing to find ungraceful failures and recovery gaps.",
+      keywords: [
+        "chaos",
+        "resilience",
+        "fault injection",
+        "failure mode",
+        "fail safe",
+        "retry",
+        "circuit breaker",
+        "graceful degradation",
+        "inject failure",
+        "robustness"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "security-scanner",
+      name: "Security Scanner",
+      role: "security-scanner",
+      tools: [...TOOLS.inspect],
+      prompt: agentPrompt("security-scanner")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Security scanner: detects hardcoded secrets, injection vectors, insecure patterns, and supply-chain risks with remediation.",
+      keywords: [
+        "security",
+        "scan",
+        "vulnerability",
+        "secret",
+        "api key",
+        "hardcoded",
+        "injection",
+        "cve",
+        "audit dependencies",
+        "supply chain",
+        "xss",
+        "sqli",
+        "shell injection",
+        "sensitive data",
+        "credential"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "bug-hunter",
+      name: "Bug Hunter",
+      role: "bug-hunter",
+      tools: [...TOOLS.inspect],
+      prompt: agentPrompt("bug-hunter")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Bug hunter: scans source code for bugs, anti-patterns, and code smells, producing a file:line-ranked hit list with fixes.",
+      keywords: [
+        "bug",
+        "hunt",
+        "scan",
+        "code smell",
+        "anti-pattern",
+        "race condition",
+        "memory leak",
+        "null deref",
+        "type safety",
+        "unhandled error",
+        "find bugs",
+        "audit code",
+        "code quality"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "audit-log",
+      name: "Audit Log",
+      role: "audit-log",
+      tools: [...TOOLS.inspect],
+      prompt: agentPrompt("audit-log")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Audit log analyzer: parses session JSONL, detects failure patterns, tool anomalies, and cost trends with structured reports.",
+      keywords: [
+        "audit",
+        "log",
+        "logs",
+        "session",
+        "trace",
+        "analyze logs",
+        "error patterns",
+        "cost analysis",
+        "tool usage",
+        "token usage",
+        "post-mortem",
+        "trend",
+        "anomaly"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase5-review.ts
+var REVIEW_AGENTS = [
+  {
+    config: {
+      id: "reviewer",
+      name: "Reviewer",
+      role: "reviewer",
+      tools: [...TOOLS.inspect, "git"],
+      prompt: agentPrompt("reviewer")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "review",
+      summary: "Independent AI reviewer: audits another agent's output, flags uncertainty, correlated-failure risk, and must-fix defects.",
+      keywords: [
+        "reviewer",
+        "independent review",
+        "ai review",
+        "review agent",
+        "quality review",
+        "second opinion",
+        "check another agent",
+        "cross check",
+        "uncertainty",
+        "correlated error",
+        "verify output",
+        "quality control"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "code-reviewer",
+      name: "Code Reviewer",
+      role: "code-reviewer",
+      tools: [...TOOLS.inspect, "git"],
+      prompt: agentPrompt("code-reviewer")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "review",
+      summary: "Correctness-first code review of diffs/PRs: finds bugs, edge cases, and convention violations with fixes.",
+      keywords: [
+        "review",
+        "code review",
+        "review pr",
+        "review diff",
+        "look over",
+        "feedback on code",
+        "quality",
+        "is this correct",
+        "check my code"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "security-reviewer",
+      name: "Security Reviewer",
+      role: "security-reviewer",
+      tools: [...TOOLS.inspect, "git"],
+      prompt: agentPrompt("security-reviewer")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "review",
+      summary: "Security review: finds injection/authz/secret/crypto issues mapped to OWASP severity with remediation.",
+      keywords: [
+        "security review",
+        "security",
+        "vulnerability",
+        "vulnerabilities",
+        "owasp",
+        "injection",
+        "sql injection",
+        "xss",
+        "ssrf",
+        "authz",
+        "secrets",
+        "security audit",
+        "threat",
+        "unsafe"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "accessibility",
+      name: "Accessibility",
+      role: "accessibility",
+      tools: [...TOOLS.read],
+      prompt: agentPrompt("accessibility")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "review",
+      summary: "WCAG/a11y review of UI: checks semantics, ARIA, keyboard, contrast; maps findings to success criteria.",
+      keywords: [
+        "accessibility",
+        "a11y",
+        "wcag",
+        "aria",
+        "screen reader",
+        "keyboard navigation",
+        "contrast",
+        "disabled users",
+        "accessible"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "compliance",
+      name: "Compliance",
+      role: "compliance",
+      tools: [...TOOLS.inspect],
+      prompt: agentPrompt("compliance")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "review",
+      summary: "License/privacy/regulatory review: audits licenses, PII handling, and controls vs GDPR/SOC2.",
+      keywords: [
+        "compliance",
+        "license",
+        "gdpr",
+        "soc2",
+        "privacy",
+        "pii",
+        "data retention",
+        "regulatory",
+        "audit log",
+        "legal review"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase6-domain.ts
+var DOMAIN_AGENTS = [
+  {
+    config: {
+      id: "database",
+      name: "Database",
+      role: "database",
+      tools: [...TOOLS.build],
+      prompt: agentPrompt("database")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Schema design, query optimization, and safe reversible migrations for SQL databases.",
+      keywords: [
+        "database",
+        "schema",
+        "sql",
+        "migration",
+        "query",
+        "index",
+        "postgres",
+        "mysql",
+        "table",
+        "orm",
+        "slow query"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "api",
+      name: "API",
+      role: "api",
+      tools: [...TOOLS.build, "fetch"],
+      prompt: agentPrompt("api")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "REST + GraphQL API design and implementation: contracts, HTTP/GraphQL semantics, versioning.",
+      keywords: [
+        "api",
+        "rest",
+        "graphql",
+        "endpoint",
+        "resolver",
+        "http",
+        "openapi",
+        "swagger",
+        "route",
+        "contract",
+        "webhook"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "auth",
+      name: "Auth",
+      role: "auth",
+      tools: [...TOOLS.build],
+      prompt: agentPrompt("auth")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Authentication and authorization: identity, sessions/tokens, RBAC/ABAC, OAuth/OIDC, done securely.",
+      keywords: [
+        "auth",
+        "authentication",
+        "authorization",
+        "login",
+        "session",
+        "jwt",
+        "oauth",
+        "oidc",
+        "rbac",
+        "permissions",
+        "token",
+        "sso"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "data",
+      name: "Data",
+      role: "data",
+      tools: [...TOOLS.build],
+      prompt: agentPrompt("data")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Data engineering: ETL/ELT pipelines, data-quality validation, idempotent transforms, reconciliation.",
+      keywords: [
+        "etl",
+        "elt",
+        "pipeline",
+        "data quality",
+        "data engineering",
+        "transform",
+        "ingestion",
+        "batch",
+        "stream",
+        "reconcile",
+        "dataset"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "frontend",
+      name: "Frontend",
+      role: "frontend",
+      tools: [...TOOLS.build, "fetch"],
+      prompt: agentPrompt("frontend")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "UI implementation: components, client state, data fetching, responsive and accessible by default.",
+      keywords: [
+        "frontend",
+        "component",
+        "react",
+        "vue",
+        "svelte",
+        "client state",
+        "ui implementation",
+        "css",
+        "responsive",
+        "hook",
+        "render"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "backend",
+      name: "Backend",
+      role: "backend",
+      tools: [...TOOLS.build],
+      prompt: agentPrompt("backend")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Server-side logic: services, business rules, persistence/queue wiring, concurrency and transactions.",
+      keywords: [
+        "backend",
+        "server",
+        "service",
+        "business logic",
+        "controller",
+        "handler",
+        "queue",
+        "cache",
+        "transaction",
+        "microservice",
+        "server-side"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "designer",
+      name: "Designer",
+      role: "designer",
+      tools: [...TOOLS.docs],
+      prompt: agentPrompt("designer")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "UI/UX design: user flows, layout/wireframes, interaction states, and design-system decisions.",
+      keywords: [
+        "design",
+        "ux",
+        "ui design",
+        "wireframe",
+        "user flow",
+        "layout",
+        "design system",
+        "interaction",
+        "mockup design",
+        "information architecture"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "ios",
+      name: "iOS",
+      role: "ios",
+      tools: [...TOOLS.build, "fetch"],
+      prompt: agentPrompt("ios")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Apple-platform app development in Swift against the latest Xcode/iOS-SDK line: SwiftUI, UIKit, SwiftData, concurrency, accessibility, and App Store submission.",
+      keywords: [
+        "ios",
+        "iphone",
+        "ipad",
+        "ipados",
+        "watchos",
+        "tvos",
+        "visionos",
+        "macos",
+        "swift",
+        "swiftui",
+        "uikit",
+        "xcode",
+        "swiftdata",
+        "app store",
+        "app intents",
+        "swift package manager",
+        "cocoapods",
+        "foundation models"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase7-knowledge.ts
+var KNOWLEDGE_AGENTS = [
+  {
+    config: {
+      id: "document",
+      name: "Document",
+      role: "document",
+      tools: [...TOOLS.docs],
+      prompt: agentPrompt("document")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "knowledge",
+      summary: "Technical documentation: READMEs, API/reference docs, guides, and verified examples grounded in code.",
+      keywords: [
+        "document",
+        "documentation",
+        "readme",
+        "docs",
+        "write up",
+        "guide",
+        "api docs",
+        "explain in writing",
+        "reference",
+        "changelog notes"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "uml",
+      name: "UML",
+      role: "uml",
+      tools: [...TOOLS.read, "write", "edit"],
+      prompt: agentPrompt("uml")
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "knowledge",
+      summary: "Diagram generation from code: class/sequence/component/ER diagrams as Mermaid/PlantUML.",
+      keywords: [
+        "uml",
+        "diagram",
+        "mermaid",
+        "plantuml",
+        "sequence diagram",
+        "class diagram",
+        "er diagram",
+        "visualize",
+        "flowchart",
+        "architecture diagram"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "i18n",
+      name: "I18n",
+      role: "i18n",
+      tools: [...TOOLS.write],
+      prompt: agentPrompt("i18n")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "knowledge",
+      summary: "Internationalization/localization: string extraction, catalog management, plurals/RTL/format handling.",
+      keywords: [
+        "i18n",
+        "internationalization",
+        "localization",
+        "l10n",
+        "translation",
+        "translate ui",
+        "locale",
+        "rtl",
+        "message catalog",
+        "multilingual"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "prompt",
+      name: "Prompt",
+      role: "prompt",
+      tools: [...TOOLS.write],
+      prompt: agentPrompt("prompt")
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "knowledge",
+      summary: "Prompt engineering: designs/refines/evaluates LLM system prompts and agent instructions.",
+      keywords: [
+        "prompt",
+        "prompt engineering",
+        "system prompt",
+        "llm instructions",
+        "few-shot",
+        "refine prompt",
+        "agent instructions",
+        "prompt template"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase8-delivery.ts
+var DELIVERY_AGENTS = [
+  {
+    config: {
+      id: "git",
+      name: "Git",
+      role: "git",
+      tools: [...TOOLS.vcs, "bash"],
+      prompt: agentPrompt("git")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "delivery",
+      summary: "Git automation: focused commits, branch/rebase/conflict handling, PR prep, history investigation.",
+      keywords: [
+        "git",
+        "commit",
+        "branch",
+        "rebase",
+        "merge",
+        "pull request",
+        "pr",
+        "conflict",
+        "blame",
+        "bisect",
+        "cherry-pick",
+        "stash"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "release",
+      name: "Release",
+      role: "release",
+      tools: [...TOOLS.vcs, "bash", "json"],
+      prompt: agentPrompt("release")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "delivery",
+      summary: "Release management: semver bumps, changelogs, and release notes derived from real history.",
+      keywords: [
+        "release",
+        "version",
+        "semver",
+        "changelog",
+        "release notes",
+        "tag",
+        "bump version",
+        "publish",
+        "versioning"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "devops",
+      name: "DevOps",
+      role: "devops",
+      tools: [
+        ...TOOLS.build,
+        "mcp__ssh__ssh_list_servers",
+        "mcp__ssh__ssh_connection_status",
+        "mcp__ssh__ssh_execute",
+        "mcp__ssh__ssh_execute_sudo",
+        "mcp__ssh__ssh_upload",
+        "mcp__ssh__ssh_download",
+        "mcp__ssh__ssh_sync",
+        "mcp__ssh__ssh_deploy",
+        "mcp__ssh__ssh_health_check",
+        "mcp__ssh__ssh_service_status",
+        "mcp__ssh__ssh_process_manager",
+        "mcp__ssh__ssh_tunnel",
+        "mcp__ssh__ssh_backup_create",
+        "mcp__ssh__ssh_backup_list",
+        "mcp__ssh__ssh_backup_restore",
+        "mcp__ssh__ssh_db_list",
+        "mcp__ssh__ssh_db_query",
+        "mcp__ssh__ssh_profile"
+      ],
+      prompt: agentPrompt("devops")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "delivery",
+      summary: "CI/CD, containerization, and deployment config: reproducible builds and safe deploys with rollback.",
+      keywords: [
+        "devops",
+        "ci",
+        "cd",
+        "ci/cd",
+        "pipeline",
+        "docker",
+        "dockerfile",
+        "kubernetes",
+        "k8s",
+        "deploy",
+        "ssh",
+        "remote ssh",
+        "remote server",
+        "sftp",
+        "tunnel",
+        "bastion",
+        "jump host",
+        "github actions",
+        "container"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "observability",
+      name: "Observability",
+      role: "observability",
+      tools: [...TOOLS.build, "logs"],
+      prompt: agentPrompt("observability")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "delivery",
+      summary: "Observability: structured logging, metrics, distributed tracing, and alerts/dashboards.",
+      keywords: [
+        "observability",
+        "logging",
+        "metrics",
+        "tracing",
+        "telemetry",
+        "opentelemetry",
+        "otel",
+        "prometheus",
+        "monitoring",
+        "alert",
+        "dashboard",
+        "instrument"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "dependency",
+      name: "Dependency",
+      role: "dependency",
+      tools: [...TOOLS.deps, "bash"],
+      prompt: agentPrompt("dependency")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "delivery",
+      summary: "Package management + supply-chain safety: CVE audit, safe upgrades, pruning, install-script review.",
+      keywords: [
+        "dependency",
+        "dependencies",
+        "package",
+        "npm",
+        "pnpm",
+        "cve",
+        "vulnerability scan",
+        "upgrade deps",
+        "audit",
+        "supply chain",
+        "outdated",
+        "lockfile"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/phase9-meta.ts
+var META_AGENTS = [
+  {
+    config: {
+      id: "skill-manage",
+      name: "Skill Manager",
+      role: "skill-manage",
+      tools: [...TOOLS.write],
+      prompt: agentPrompt("skill-manage")
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "meta",
+      summary: "Skill curation: audits, refines descriptions/triggers, scaffolds, and retires skills.",
+      keywords: [
+        "skill",
+        "skills",
+        "curate skill",
+        "skill description",
+        "create skill",
+        "skill library",
+        "skill trigger",
+        "manage skills"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "self-improving",
+      name: "Self-Improving",
+      role: "self-improving",
+      tools: [...TOOLS.inspect],
+      prompt: agentPrompt("self-improving")
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "meta",
+      summary: "Learns from execution logs: mines recurring failures/inefficiencies and proposes evidence-based improvements.",
+      keywords: [
+        "self-improving",
+        "learn from",
+        "session logs",
+        "execution analysis",
+        "recurring failure",
+        "improve agents",
+        "post-mortem",
+        "retrospective",
+        "meta-analysis"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "context",
+      name: "Context",
+      role: "context",
+      tools: [...TOOLS.inspect, "remember", "forget"],
+      prompt: agentPrompt("context")
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "meta",
+      summary: "Memory + context-window management: compaction, recall, and curation within a token budget.",
+      keywords: [
+        "context",
+        "context window",
+        "memory",
+        "compact",
+        "summarize history",
+        "recall",
+        "token budget",
+        "prune context",
+        "remember",
+        "dfmt"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "cost",
+      name: "Cost",
+      role: "cost",
+      tools: [...TOOLS.inspect],
+      prompt: agentPrompt("cost")
+    },
+    budget: LIGHT_BUDGET,
+    capability: {
+      phase: "meta",
+      summary: "Token/cloud cost optimization: finds spend waste, recommends model routing and trimming with $ estimates.",
+      keywords: [
+        "cost",
+        "token cost",
+        "optimize cost",
+        "spend",
+        "cheaper",
+        "model routing",
+        "budget",
+        "expensive",
+        "reduce tokens",
+        "pricing",
+        "cloud cost"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "tech-stack",
+      name: "Tech Stack Validator",
+      role: "tech-stack",
+      tools: ["search", "fetch", "read", "grep", "glob", "outdated", "audit", "json", "mailbox"],
+      prompt: agentPrompt("tech-stack")
+    },
+    budget: {
+      timeoutMs: 12e4,
+      maxIterations: 10,
+      maxToolCalls: 40,
+      maxTokens: 6e4,
+      maxCostUsd: 0.25
+    },
+    capability: {
+      phase: "meta",
+      summary: "Single-shot tech stack validator: checks npm for latest versions, rejects dead/obsolete packages, enforces modern alternatives.",
+      keywords: [
+        "tech stack",
+        "version",
+        "package",
+        "library",
+        "framework",
+        "dependency",
+        "install",
+        "upgrade",
+        "latest",
+        "npm",
+        "pnpm add",
+        "outdated",
+        "obsolete",
+        "deprecated",
+        "what version",
+        "which package",
+        "check version",
+        "verify version",
+        "is this current"
+      ]
+    }
+  }
+];
+
+// src/coordination/agents/index.ts
+var ALL_AGENT_DEFINITIONS = [
+  ...DISCOVERY_AGENTS,
+  ...PLANNING_AGENTS,
+  ...BUILD_AGENTS,
+  ...VERIFY_AGENTS,
+  ...REVIEW_AGENTS,
+  ...DOMAIN_AGENTS,
+  ...KNOWLEDGE_AGENTS,
+  ...DELIVERY_AGENTS,
+  ...META_AGENTS
+];
+var AGENTS_BY_PHASE = {
+  discovery: DISCOVERY_AGENTS,
+  planning: PLANNING_AGENTS,
+  build: BUILD_AGENTS,
+  verify: VERIFY_AGENTS,
+  review: REVIEW_AGENTS,
+  domain: DOMAIN_AGENTS,
+  knowledge: KNOWLEDGE_AGENTS,
+  delivery: DELIVERY_AGENTS,
+  meta: META_AGENTS
+};
+var AGENT_CATALOG = (() => {
+  const map = {};
+  for (const def of ALL_AGENT_DEFINITIONS) {
+    const role = def.config.role;
+    if (!role) {
+      throw new Error(`Agent "${def.config.name}" is missing a role`);
+    }
+    if (map[role]) {
+      throw new Error(`Duplicate agent role in catalog: "${role}"`);
+    }
+    map[role] = def;
+  }
+  return map;
+})();
+
+// src/core/fallback-profile-manager.ts
+function hasText(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function providerHasKey(entry) {
+  if (!entry) return false;
+  if (hasText(entry.apiKey)) return true;
+  if (Array.isArray(entry.apiKeys) && entry.apiKeys.some((k) => hasText(k?.apiKey))) return true;
+  if (Array.isArray(entry.envVars) && entry.envVars.some((v) => hasText(process.env[v])))
+    return true;
+  return false;
+}
+function visibleProviderModels(config, providerId, providerModels) {
+  const entry = config.providers?.[providerId];
+  return entry?.models !== void 0 ? [...entry.models] : providerModels;
+}
+function buildProfiles(config) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const [name, chain] of Object.entries(config.fallbackProfiles ?? {})) {
+    if (Array.isArray(chain) && chain.length > 0) {
+      entries.set(name, Object.freeze([...chain]));
+    }
+  }
+  return entries;
+}
+var FallbackProfileManager = class {
+  /** Immutable snapshot of config.fallbackProfiles for the active config. */
+  profiles;
+  /** Active frozen config snapshot for provider lookups. */
+  config;
+  /** Optional shared runtime status tracker. */
+  statusTracker;
+  constructor(config, opts) {
+    this.config = config;
+    this.profiles = buildProfiles(config);
+    this.statusTracker = opts?.statusTracker;
+  }
+  /**
+   * Bind (or replace) the shared runtime status tracker.
+   * Called by the boot path after the tracker is created.
+   */
+  setStatusTracker(tracker) {
+    this.statusTracker = tracker;
+  }
+  // ── Profile existence ──────────────────────────────────────────────────
+  hasProfile(name) {
+    return this.profiles.has(name);
+  }
+  listProfiles() {
+    return Object.freeze([...this.profiles.keys()]);
+  }
+  // ── Resolution ─────────────────────────────────────────────────────────
+  /**
+   * Resolve a named fallback profile to a validated, provider-filtered chain.
+   *
+   * Returns an empty chain when:
+   * - The profile doesn't exist.
+   * - Every entry's provider is missing, has no key, or has no matching model.
+   *
+   * @param name - Profile name from config.fallbackProfiles.
+   * @param defaultProvider - Used when an entry has no explicit provider.
+   * @param exclude - Optional { providerId, model } to skip (avoid self-fallback).
+   */
+  resolve(name, opts = {}) {
+    const defaultProvider = opts.defaultProvider ?? this.config.provider;
+    const chain = this.profiles.get(name);
+    if (!chain) return FREEZER_EMPTY;
+    const excludeKey = opts.exclude ? `${opts.exclude.providerId}/${opts.exclude.model}` : void 0;
+    const resolved = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const ref of chain) {
+      const parsed = parseModelRef(ref);
+      if (!parsed.model) continue;
+      const providerId = parsed.provider ?? defaultProvider;
+      const key = `${providerId}/${parsed.model}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      if (excludeKey && key === excludeKey) continue;
+      const health = this.checkProvider(providerId);
+      if (!health.usable) continue;
+      if (this.statusTracker && !this.statusTracker.isAvailable(providerId, parsed.model)) continue;
+      if (!evaluateModelCalendar(this.config.modelAvailabilitySchedule, providerId, parsed.model).allowed)
+        continue;
+      const allowedModels = this.config.providers?.[providerId]?.models;
+      if (allowedModels && !allowedModels.includes(parsed.model)) continue;
+      resolved.push({
+        providerId,
+        model: parsed.model,
+        providerSwitched: providerId !== (opts.exclude?.providerId ?? this.config.provider)
+      });
+    }
+    return Object.freeze(resolved);
+  }
+  /**
+   * Resolve the effective fallback chain for a session: explicit fallbackModels
+   * first, then named profile, then smart default (unless disabled).
+   *
+   * Mirrors the previous `effectiveFallbackChain()` logic but centralized.
+   */
+  resolveEffective(opts = {}) {
+    if (opts.fallbackModels && opts.fallbackModels.length > 0) {
+      const resolved = this.resolveRefs(opts.fallbackModels, opts.exclude);
+      if (resolved.length > 0) return resolved;
+    }
+    if (opts.fallbackProfile) {
+      const resolved = this.resolve(opts.fallbackProfile, { exclude: opts.exclude });
+      if (resolved.length > 0) return resolved;
+    }
+    if (opts.fallbackAuto !== false) {
+      return this.smartDefault(opts.exclude);
+    }
+    return FREEZER_EMPTY;
+  }
+  // ── Provider availability (read-only) ──────────────────────────────────
+  checkProvider(providerId) {
+    const entry = this.config.providers?.[providerId];
+    const isPrimary = providerId === this.config.provider;
+    const hasKey = providerHasKey(entry) || isPrimary && hasText(this.config.apiKey);
+    const hasEndpoint = hasText(entry?.baseUrl) || isPrimary && hasText(this.config.baseUrl);
+    const hasModels = Array.isArray(entry?.models) && entry.models.length > 0 || isPrimary && hasText(this.config.model);
+    return Object.freeze({
+      providerId,
+      hasKey,
+      hasEndpoint,
+      hasModels,
+      usable: hasKey || hasEndpoint
+    });
+  }
+  // ── Rebuild on config change ───────────────────────────────────────────
+  /**
+   * Atomically replace the active immutable snapshot while preserving this
+   * service identity for every injected consumer.
+   */
+  reload(newConfig) {
+    this.config = newConfig;
+    this.profiles = buildProfiles(newConfig);
+  }
+  // ── Internal helpers ───────────────────────────────────────────────────
+  /**
+   * Resolve an array of model ref strings (from explicit fallbackModels config).
+   * Public so consumers like one-shot-llm can use it directly.
+   */
+  resolveRefs(refs, exclude) {
+    const excludeKey = exclude ? `${exclude.providerId}/${exclude.model}` : void 0;
+    const resolved = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const ref of refs) {
+      const parsed = parseModelRef(ref);
+      if (!parsed.model) continue;
+      const providerId = parsed.provider ?? this.config.provider;
+      const key = `${providerId}/${parsed.model}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      if (excludeKey && key === excludeKey) continue;
+      if (this.statusTracker && !this.statusTracker.isAvailable(providerId, parsed.model)) continue;
+      if (!evaluateModelCalendar(this.config.modelAvailabilitySchedule, providerId, parsed.model).allowed)
+        continue;
+      resolved.push({
+        providerId,
+        model: parsed.model,
+        providerSwitched: providerId !== (exclude?.providerId ?? this.config.provider)
+      });
+    }
+    return Object.freeze(resolved);
+  }
+  /**
+   * Derive a smart default chain from configured providers when nothing
+   * explicit is set. Same-provider alternatives first, then cross-provider.
+   * Limited to 4 entries to avoid burning through models on a transient blip.
+   */
+  smartDefault(exclude) {
+    const leaderProvider = this.config.provider;
+    const leaderModel = this.config.model;
+    const providers = this.config.providers ?? {};
+    const favoriteSet = new Set(
+      (this.config.favoriteModels ?? []).map((ref) => {
+        const p = parseModelRef(ref);
+        return `${p.provider ?? leaderProvider}/${p.model}`;
+      })
+    );
+    const hasFavorites = favoriteSet.size > 0;
+    const favoritesOnly = this.config.favoriteModelsOnly === true;
+    const seen = /* @__PURE__ */ new Set();
+    const favorites = [];
+    const sameProvider = [];
+    const crossProvider = [];
+    const excludeKey = exclude ? `${exclude.providerId}/${exclude.model}` : void 0;
+    const ids = Object.keys(providers).sort(
+      (a, b) => a === leaderProvider ? -1 : b === leaderProvider ? 1 : a.localeCompare(b)
+    );
+    for (const id of ids) {
+      const entry = providers[id];
+      if (!this.checkProvider(id).usable) continue;
+      const models = visibleProviderModels(this.config, id, entry?.models ?? []);
+      for (const model of models) {
+        if (id === leaderProvider && model === leaderModel) continue;
+        const ref = `${id}/${model}`;
+        if (seen.has(ref)) continue;
+        seen.add(ref);
+        if (excludeKey && ref === excludeKey) continue;
+        if (this.statusTracker && !this.statusTracker.isAvailable(id, model)) continue;
+        if (!evaluateModelCalendar(this.config.modelAvailabilitySchedule, id, model).allowed)
+          continue;
+        if (favoriteSet.has(ref)) {
+          favorites.push(ref);
+          continue;
+        }
+        if (favoritesOnly && hasFavorites) continue;
+        (id === leaderProvider ? sameProvider : crossProvider).push(ref);
+      }
+    }
+    const MAX = 4;
+    const all = [...favorites, ...sameProvider, ...crossProvider].slice(0, MAX);
+    return Object.freeze(
+      all.map((ref) => {
+        const p = parseModelRef(ref);
+        return {
+          providerId: p.provider ?? leaderProvider,
+          model: p.model,
+          providerSwitched: (p.provider ?? leaderProvider) !== (exclude?.providerId ?? leaderProvider)
+        };
+      })
+    );
+  }
+};
+var FREEZER_EMPTY = Object.freeze([]);
+
+// src/core/fallback-model.ts
+function parseModelRef(ref) {
+  const trimmed = ref.trim();
+  const slash = trimmed.indexOf("/");
+  if (slash !== -1) {
+    return {
+      provider: trimmed.slice(0, slash) || void 0,
+      model: trimmed.slice(slash + 1).trim()
+    };
+  }
+  const parts = trimmed.split(/\s+/);
+  if (parts.length >= 2) {
+    return { provider: parts[0], model: parts.slice(1).join(" ") };
+  }
+  return { model: trimmed };
+}
+function formatModelRef(ref, defaultProvider) {
+  const provider = ref.provider ?? defaultProvider;
+  return provider ? `${provider}/${ref.model}` : ref.model;
+}
+function normalizeModelRef(ref, defaultProvider) {
+  const parsed = parseModelRef(ref);
+  return formatModelRef(parsed, defaultProvider);
+}
+function fallbackProfileChain(config, profileName) {
+  if (!profileName) return [];
+  const mgr = new FallbackProfileManager(config);
+  return mgr.resolve(profileName).map((e) => `${e.providerId}/${e.model}`);
+}
+var DEFAULT_PRIMARY_COOLDOWN_MAX_MS = 10 * 6e4;
+
+// src/coordination/model-matrix.ts
+var MATRIX_PHASE_KEYS = Object.keys(AGENTS_BY_PHASE);
+var ROLE_TO_PHASE = (() => {
+  const map = {};
+  for (const [phase, defs] of Object.entries(AGENTS_BY_PHASE)) {
+    for (const def of defs) {
+      const role = def.config.role;
+      if (role) map[role] = phase;
+    }
+  }
+  return map;
+})();
+function phaseForRole(role) {
+  return role ? ROLE_TO_PHASE[role] : void 0;
+}
+function resolveModelMatrixResolution(matrix, role) {
+  if (!matrix) return void 0;
+  if (role && matrix[role]) return { entry: matrix[role], source: "role", key: role };
+  const phase = phaseForRole(role);
+  if (phase && matrix[phase]) return { entry: matrix[phase], source: "phase", key: phase };
+  if (matrix["*"]) return { entry: matrix["*"], source: "default", key: "*" };
+  return void 0;
+}
+function resolveModelMatrix(matrix, role) {
+  return resolveModelMatrixResolution(matrix, role)?.entry;
+}
+function resolveModelTargetFromEntry(config, entry) {
+  if (!entry) return void 0;
+  if (entry.model) {
+    return {
+      provider: entry.provider,
+      model: entry.model,
+      modelRuntime: entry.modelRuntime,
+      fallbackProfile: entry.fallbackProfile,
+      fallbackModels: fallbackProfileChain(config, entry.fallbackProfile)
+    };
+  }
+  const chain = fallbackProfileChain(config, entry.fallbackProfile);
+  const first = chain[0];
+  if (!first) {
+    return entry.modelRuntime ? { modelRuntime: entry.modelRuntime } : void 0;
+  }
+  const parsed = parseModelRef(first);
+  return {
+    provider: parsed.provider,
+    model: parsed.model,
+    modelRuntime: entry.modelRuntime,
+    fallbackProfile: entry.fallbackProfile,
+    fallbackModels: chain.slice(1)
+  };
+}
+function roleNeedsIndependentReviewModel(role) {
+  if (!role) return false;
+  return role === "reviewer" || phaseForRole(role) === "review";
+}
+function resolveSubagentModelTarget(config, role, opts = {}) {
+  const resolution = resolveModelMatrixResolution(config.modelMatrix, role);
+  const matrixTarget = resolveModelTargetFromEntry(config, resolution?.entry);
+  const implementationTarget = opts.implementationTarget ?? resolveImplementationModelTarget(config);
+  if (!roleNeedsIndependentReviewModel(role)) {
+    if (!matrixTarget) return void 0;
+    return {
+      ...matrixTarget,
+      source: "matrix",
+      matrixSource: resolution?.source
+    };
+  }
+  const matrixRef = materializeTarget(config, matrixTarget);
+  if (resolution?.source === "role" || resolution?.source === "phase") {
+    return matrixTarget ? { ...matrixTarget, source: "matrix", matrixSource: resolution.source } : void 0;
+  }
+  if (matrixRef && !sameModelReference(matrixRef, implementationTarget)) {
+    return {
+      ...matrixTarget ?? {},
+      source: "matrix",
+      matrixSource: resolution?.source
+    };
+  }
+  const diverse = chooseDiverseModelTarget(config, implementationTarget);
+  if (diverse) {
+    return {
+      provider: diverse.provider,
+      model: diverse.model,
+      modelRuntime: matrixTarget?.modelRuntime,
+      fallbackModels: matrixTarget?.fallbackModels,
+      fallbackProfile: matrixTarget?.fallbackProfile,
+      source: "diversity",
+      matrixSource: resolution?.source,
+      diversified: true
+    };
+  }
+  if (!matrixTarget) return void 0;
+  return {
+    ...matrixTarget,
+    source: "matrix",
+    matrixSource: resolution?.source
+  };
+}
+function resolveImplementationModelTarget(config) {
+  const target = resolveModelTargetFromEntry(
+    config,
+    resolveModelMatrix(config.modelMatrix, "executor")
+  );
+  return materializeTarget(config, target) ?? {
+    provider: config.provider,
+    model: config.model
+  };
+}
+function sameModelReference(a, b) {
+  if (!a?.model || !b?.model) return false;
+  const providerA = a.provider ?? "";
+  const providerB = b.provider ?? "";
+  return providerA === providerB && a.model === b.model;
+}
+function materializeTarget(config, target) {
+  if (!target?.model) return void 0;
+  return {
+    provider: target.provider ?? config.provider,
+    model: target.model
+  };
+}
+function chooseDiverseModelTarget(config, avoid) {
+  const candidates = collectConfiguredModelTargets(config).filter(
+    (candidate) => !sameModelReference(candidate, avoid)
+  );
+  candidates.sort((a, b) => modelDiversityScore(b, avoid) - modelDiversityScore(a, avoid));
+  return candidates[0];
+}
+function collectConfiguredModelTargets(config) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const add = (provider, model) => {
+    if (!provider || !model) return;
+    const key = `${provider}\0${model}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push({ provider, model });
+  };
+  add(config.provider, config.model);
+  for (const [providerId, provider] of Object.entries(config.providers ?? {})) {
+    if (!isProviderAvailable(providerId, provider, config.provider)) continue;
+    for (const model of provider.models ?? []) add(providerId, model);
+    for (const model of Object.keys(provider.customModels ?? {})) add(providerId, model);
+  }
+  for (const model of Object.keys(config.models ?? {})) add(config.provider, model);
+  return out;
+}
+function isProviderAvailable(providerId, provider, leaderProvider) {
+  if (providerId === leaderProvider) return true;
+  if (typeof provider.apiKey === "string" && provider.apiKey.length > 0) return true;
+  if (Array.isArray(provider.apiKeys) && provider.apiKeys.some((key) => key?.apiKey)) return true;
+  if (typeof provider.baseUrl === "string" && provider.baseUrl.length > 0) return true;
+  return false;
+}
+function modelDiversityScore(candidate, avoid) {
+  let score = 0;
+  if (candidate.provider !== avoid.provider) score += 100;
+  if (candidate.model !== avoid.model) score += 20;
+  if (/opus|gpt-5|o3|o4|gemini.*pro|deepseek-r1/i.test(candidate.model)) score += 10;
+  if (/mini|haiku|flash/i.test(candidate.model)) score -= 5;
+  return score;
+}
+function matrixKeyKind(key) {
+  if (key === "*") return "default";
+  if (key in AGENT_CATALOG) return "role";
+  if (MATRIX_PHASE_KEYS.includes(key)) return "phase";
+  return "unknown";
+}
+function isValidMatrixKey(key) {
+  return matrixKeyKind(key) !== "unknown";
+}
+
+// src/tools/fallback-manage-tools.ts
+var FAVORITE_MANAGE_TOOL_NAME = "favorite_manage";
+var FALLBACK_CHAIN_MANAGE_TOOL_NAME = "fallback_chain_manage";
+var FALLBACK_PROFILE_MANAGE_TOOL_NAME = "fallback_profile_manage";
+var AGENT_MODEL_ASSIGN_TOOL_NAME = "agent_model_assign";
+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 ?? [];
+}
+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".` };
+    }
+  };
+}
+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}".` };
+    }
+  };
+}
+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}".` };
+    }
+  };
+}
+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)."
+    }
+  },
+  // Flattened from a top-level oneOf — Anthropic-family endpoints reject
+  // top-level combinators (omniroute 400: "input_schema does not support
+  // oneOf, allOf, or anyOf at the top level"). Combination rules are
+  // enforced in the handler instead.
+  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." };
+    }
+  };
+}
+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
+};
+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,
+    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.` };
+        }
+        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".` };
+        }
+        const entry = { ...providers[input.provider] };
+        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;
+        providers[input.provider] = entry;
+        await opts.updateConfig((cfg) => {
+          cfg.providers = providers;
+        });
+        const updated = Object.keys({ ...entry }).filter((k) => k !== "apiKey").join(", ");
+        return { status: "ok", message: `\u2713 Updated ${input.provider}: ${updated}` };
+      }
+      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}".` };
+    }
+  };
+}
+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."
+    }
+  },
+  // Flattened from a top-level oneOf — Anthropic-family endpoints reject
+  // top-level combinators (omniroute 400). Combination rules are enforced
+  // in the handler instead.
+  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: "auto",
+    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 storeKey(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 storeKey(providers, input, envValue, opts);
+      }
+      if (input.key) {
+        return storeKey(providers, input, input.key, opts);
+      }
+      return { status: "error", message: "Unexpected \u2014 no key source available." };
+    }
+  };
+}
+async function storeKey(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;
+  entry.apiKey = void 0;
+  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.`
+  };
+}
+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.' };
+        }
+        await opts.updateConfig((cfg) => {
+          cfg.provider = input.provider;
+          cfg.model = input.model;
+        });
+        return { status: "ok", message: `\u2713 Leader \u2192 ${input.provider}/${input.model}` };
+      }
+      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 = parseRefInternal(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);
+        await opts.updateConfig((cfg) => {
+          cfg.provider = provider;
+          cfg.model = model;
+          cfg.fallbackModels = rest;
+        });
+        return {
+          status: "ok",
+          message: `\u2713 Leader \u2192 ${provider}/${model} (profile: ${input.profile})` + (rest.length > 0 ? `
+  Fallback chain: ${rest.join(" \u2192 ")}` : "")
+        };
+      }
+      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}".` };
+    }
+  };
+}
+function parseRefInternal(ref) {
+  const trimmed = ref.trim();
+  const slash = trimmed.indexOf("/");
+  if (slash !== -1) {
+    const p = trimmed.slice(0, slash);
+    const m = trimmed.slice(slash + 1).trim();
+    if (p) return { provider: p, model: m };
+    return { model: m };
+  }
+  const parts = trimmed.split(/\s+/);
+  if (parts.length >= 2) {
+    return { provider: parts[0], model: parts.slice(1).join(" ") };
+  }
+  return { model: trimmed };
+}
+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", "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), 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(
+          "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 ?? {};
+        for (const fav of favorites) {
+          const p = parseRefInternal(fav);
+          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 = parseRefInternal(entry);
+          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 = parseRefInternal(entry);
+            const provId = p.provider ?? config.provider;
+            if (!providers[provId] && provId !== config.provider) {
+              issues.push(`Profile "${pname}" entry "${entry}" references unknown provider "${provId}"`);
+            }
+          }
+        }
+        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 === "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") };
+    }
+  };
+}
+function createFallbackManageTools(opts) {
+  return [
+    createFavoriteManageTool(opts),
+    createFallbackChainManageTool(opts),
+    createFallbackProfileManageTool(opts),
+    createAgentModelAssignTool(opts),
+    createProviderManageTool(opts),
+    createProviderKeySetTool(opts),
+    createLeaderModelSetTool(opts),
+    createSystemConfigViewTool(opts)
+  ];
+}
 export {
+  AGENT_MODEL_ASSIGN_TOOL_NAME,
   COUNCIL_TOOL_NAME,
+  FALLBACK_CHAIN_MANAGE_TOOL_NAME,
+  FALLBACK_PROFILE_MANAGE_TOOL_NAME,
+  FAVORITE_MANAGE_TOOL_NAME,
+  LEADER_MODEL_SET_TOOL_NAME,
   MAX_COUNCIL_CONTEXT_CHARS,
   MAX_COUNCIL_QUESTION_CHARS,
   MAX_COUNCIL_TOOL_OPTIONS,
   ONE_SHOT_LLM_TOOL_NAME,
+  PROVIDER_KEY_SET_TOOL_NAME,
+  PROVIDER_MANAGE_TOOL_NAME,
+  SYSTEM_CONFIG_VIEW_TOOL_NAME,
   createCouncilTool,
+  createFallbackManageTools,
   createMcpControlTool,
   createOneShotLLMTool
 };