@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-QJ6OEH4K.js

@@ -0,0 +1,3683 @@
+import {
+  normalizeCodexHomePath,
+  readTomlValues
+} from "./chunk-BD3PGW6A.js";
+import {
+  LongContextPricingSchema,
+  ModelInfoSchema,
+  RouteBackendModesSchema,
+  SpeedTierPricingSchema,
+  mergeModelEntry
+} from "./chunk-QXBKTJT6.js";
+import {
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.js";
+import {
+  findProjectRoot,
+  getConfigPaths,
+  resolveProvidersConfigPath
+} from "./chunk-35J4NE6S.js";
+import {
+  ProviderExecutionError
+} from "./chunk-RRC5BL7B.js";
+import {
+  assertContainedPath
+} from "./chunk-RCP2Y6DQ.js";
+import {
+  getEnvVarEntry
+} from "./chunk-O26L6F7F.js";
+import {
+  findBuildPackageRoot
+} from "./chunk-RJ6RSNT6.js";
+import {
+  getDataDir,
+  getUserConfigFile
+} from "./chunk-56WPYDJH.js";
+import {
+  validateConfigPath
+} from "./chunk-STW7OFOA.js";
+import {
+  BUILD_REFRESH_ORIGIN_ENV,
+  debugLog,
+  emitWarning,
+  getExecutionContext
+} from "./chunk-7VRJHTGZ.js";
+import {
+  getErrorCode,
+  isObject
+} from "./chunk-CPSVQR2I.js";
+
+// src/core/config/provider-registry.ts
+import { createHash as createHash5 } from "crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync8 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4, resolve as resolve5, sep } from "path";
+import yaml from "js-yaml";
+import { z as z3 } from "zod";
+
+// src/core/providers/generated/catalog-digest.ts
+var PROVIDER_CATALOG_SHA256 = "3e1596f8b8c9836de23c8cba97e9f2cf947b7416f2f0cb4c2946df34719e3a08";
+var PROVIDER_SOURCE_YAML_SHA256 = "ff6b202852cae9195a1e0d82f71ff246f188efe294484c977f083101e34ad2bd";
+
+// src/core/providers/refresh/storage.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync5, realpathSync, statSync } from "fs";
+import path4 from "path";
+
+// src/core/providers/codex/connection.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { homedir } from "os";
+import path2 from "path";
+
+// src/core/providers/shared/connection-coordinates.ts
+function endpointCoordinate(value) {
+  if (typeof value !== "string") return void 0;
+  try {
+    const url = new URL(value);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return value.includes("://") ? void 0 : value;
+  }
+}
+
+// src/core/providers/codex/bedrock.ts
+import { existsSync, readFileSync } from "fs";
+import * as path from "path";
+var BEDROCK_OPENAI_NAMESPACE = "openai.";
+var BEDROCK_CODEX_MODEL_PROVIDER = "amazon-bedrock";
+var BEDROCK_RUNTIME_CODEX_MODEL_PROVIDER = "amazon-bedrock-runtime";
+var CODEX_CONFIG_FILE = "config.toml";
+function codexProfileConfigFile(profile) {
+  return `${profile}.config.toml`;
+}
+var TOP_LEVEL_MODEL_PROVIDER = /^\s*(?:model_provider|"model_provider"|'model_provider')\s*=\s*(?:"""([\s\S]*?)"""|'''([\s\S]*?)'''|"([^"]*)"|'([^']*)')\s*(?:#.*)?$/;
+var TOML_TABLE_HEADER = /^\s*\[/;
+function codexHomeCandidates(env) {
+  const explicitHome = env.CODEX_HOME?.trim();
+  if (explicitHome) {
+    return [normalizeCodexHomePath(explicitHome)];
+  }
+  const homes = [];
+  const home = env.HOME?.trim();
+  if (home) {
+    homes.push(path.join(home, ".codex"));
+  }
+  return homes;
+}
+function readCodexConfigModelProvider(configPath) {
+  if (!existsSync(configPath)) {
+    return void 0;
+  }
+  try {
+    for (const line of readFileSync(configPath, "utf8").split(/\r?\n/)) {
+      if (TOML_TABLE_HEADER.test(line)) {
+        return void 0;
+      }
+      const match = TOP_LEVEL_MODEL_PROVIDER.exec(line);
+      if (match) {
+        const value = (match[1] ?? match[2] ?? match[3] ?? match[4] ?? "").trim();
+        return value === "" ? void 0 : value;
+      }
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function backendFromModelProvider(value) {
+  const normalized = value.trim().toLowerCase();
+  if (isCodexBedrockProviderId(normalized) || normalized === "bedrock") {
+    return "bedrock";
+  }
+  if (normalized === "openai") {
+    return "openai";
+  }
+  return void 0;
+}
+function isCodexBedrockProviderId(value) {
+  const normalized = value?.trim().toLowerCase();
+  return normalized === BEDROCK_CODEX_MODEL_PROVIDER || normalized === BEDROCK_RUNTIME_CODEX_MODEL_PROVIDER;
+}
+function isBedrockRuntimeCodexProvider(value) {
+  return value?.trim().toLowerCase() === BEDROCK_RUNTIME_CODEX_MODEL_PROVIDER;
+}
+function resolveBackendFromCodexConfig(env, profile) {
+  const selected = profile?.trim();
+  const useProfile = Boolean(selected) && selected !== "default";
+  for (const home of codexHomeCandidates(env)) {
+    const candidates = [];
+    if (useProfile && selected) {
+      candidates.push({
+        path: path.join(home, codexProfileConfigFile(selected)),
+        source: "profile-config"
+      });
+    }
+    candidates.push({ path: path.join(home, CODEX_CONFIG_FILE), source: "base-config" });
+    for (const candidate of candidates) {
+      const provider = readCodexConfigModelProvider(candidate.path);
+      if (provider === void 0) {
+        continue;
+      }
+      return {
+        backend: backendFromModelProvider(provider),
+        source: candidate.source,
+        configPath: candidate.path,
+        modelProvider: provider.trim().toLowerCase()
+      };
+    }
+  }
+  return void 0;
+}
+function resolveCodexBackendDetailed(env = process.env, _workingDir, profile, callerModelProvider) {
+  const callerProvider = callerModelProvider?.trim().toLowerCase() || void 0;
+  const callerBackend = callerProvider ? backendFromModelProvider(callerProvider) : void 0;
+  const observed = callerProvider ? { backend: callerBackend, source: "caller-override", modelProvider: callerProvider } : resolveBackendFromCodexConfig(env, profile);
+  const explicit = env.BUILD_CODEX_BACKEND?.trim().toLowerCase();
+  if (explicit === "bedrock" || explicit === "openai") {
+    return {
+      backend: explicit,
+      source: "build-env",
+      ...observed?.modelProvider ? { modelProvider: observed.modelProvider } : {},
+      ...callerProvider && callerBackend !== explicit ? { conflictingCallerProvider: true } : {}
+    };
+  }
+  return observed ?? { backend: void 0, source: "none" };
+}
+function resolveCodexBackend(env = process.env, workingDir, profile, callerModelProvider) {
+  return resolveCodexBackendDetailed(env, workingDir, profile, callerModelProvider).backend;
+}
+function describeCodexBackendConflict(resolution) {
+  if (resolution.source !== "build-env" || resolution.backend !== "openai" || !isCodexBedrockProviderId(resolution.modelProvider)) {
+    return void 0;
+  }
+  return `[Codex] Conflicting backend selection: BUILD_CODEX_BACKEND is "openai" but the Codex config selects model_provider "${resolution.modelProvider}". Set only one.`;
+}
+var BEDROCK_GEOGRAPHY_PREFIXES = ["global.", "us.", "eu.", "jp.", "apac."];
+function isBedrockOpenAiModelId(model) {
+  return model.trim().startsWith(BEDROCK_OPENAI_NAMESPACE);
+}
+function toBedrockCodexModelId(model) {
+  if (!model) {
+    return void 0;
+  }
+  const trimmed = model.trim();
+  if (trimmed === "") {
+    return void 0;
+  }
+  if (isBedrockOpenAiModelId(trimmed)) {
+    return trimmed;
+  }
+  if (BEDROCK_GEOGRAPHY_PREFIXES.some((prefix) => trimmed.startsWith(prefix))) {
+    return void 0;
+  }
+  return `${BEDROCK_OPENAI_NAMESPACE}${trimmed}`;
+}
+function createMissingRuntimeProfileError(model, lookup) {
+  const cause = lookup?.outcome === "unavailable" ? `Build could not read the provider registry (${lookup.error}), so no inference profile could be looked up for Codex model "${model}".` : `No Bedrock inference profile is registered for Codex model "${model}".`;
+  const declared = lookup?.outcome === "absent" && lookup.declaredModels && lookup.declaredModels.length > 0 ? `  1. Pin a model with a registered profile: ${lookup.declaredModels.join(", ")}.` : "  1. Pin a model with a registered bedrock-runtime global route.";
+  return new ProviderExecutionError(
+    [
+      `Error: ${cause}`,
+      `The ${BEDROCK_RUNTIME_CODEX_MODEL_PROVIDER} provider accepts OpenAI models only through inference profiles; no model was substituted.`,
+      "",
+      "To fix:",
+      declared,
+      "  2. Or declare a verified bedrock-runtime global route for this model in your user provider registry (~/.build/config/providers.yaml by default).",
+      "  3. Or use the auto model so Codex runs its configured default."
+    ].join("\n"),
+    {
+      retryable: false,
+      reason: "missing_bedrock_model_mapping",
+      providerName: "codex"
+    }
+  );
+}
+function resolveBedrockCodexWireModel(model, modelProvider, lookup) {
+  const derived = toBedrockCodexModelId(model);
+  if (derived === void 0 || isBedrockOpenAiModelId(model)) {
+    return derived ?? model;
+  }
+  if (isBedrockRuntimeCodexProvider(modelProvider)) {
+    if (lookup?.outcome === "declared" && lookup.backend === "bedrock-runtime") {
+      return lookup.profile;
+    }
+    throw createMissingRuntimeProfileError(model.trim(), lookup);
+  }
+  return lookup?.outcome === "declared" && lookup.backend === "bedrock-mantle" ? lookup.profile : derived;
+}
+
+// src/core/providers/codex/connection.ts
+function readCodexConnection(env, profile) {
+  const home = env.CODEX_HOME?.trim() ? normalizeCodexHomePath(env.CODEX_HOME) : path2.join(env.HOME?.trim() || homedir(), ".codex");
+  const values = /* @__PURE__ */ new Map();
+  for (const file of [
+    path2.join(home, "config.toml"),
+    ...profile && profile !== "default" ? [path2.join(home, `${profile}.config.toml`)] : []
+  ]) {
+    try {
+      for (const [key, value] of readTomlValues(readFileSync2(file, "utf8"))) values.set(key, value);
+    } catch {
+    }
+  }
+  const resolution = resolveCodexBackendDetailed(env, void 0, profile);
+  const conflict = describeCodexBackendConflict(resolution);
+  const provider = resolution.modelProvider ?? values.get("model_provider");
+  const settings = [...values].filter(
+    ([key]) => key === "model_provider" || key === "model_catalog_json" || key === "models_catalog_json" || key === "model_context_window" || typeof provider === "string" && key.startsWith(`model_providers.${provider}.`) && /\.(?:base_url|wire_api|model_catalog_url|models_url|models_catalog_url|region|project|requires_openai_auth)$/.test(
+      key
+    )
+  );
+  return {
+    home,
+    profile: profile ?? "default",
+    backend: resolution.backend,
+    modelProvider: provider,
+    settings,
+    values,
+    conflict,
+    assertedProvider: resolution.source === "build-env" && resolution.backend === "bedrock" && !isCodexBedrockProviderId(resolution.modelProvider) ? BEDROCK_CODEX_MODEL_PROVIDER : void 0
+  };
+}
+function codexConnectionCoordinates(env, profile) {
+  const { values: _values, ...connection } = readCodexConnection(env, profile);
+  return {
+    ...connection,
+    settings: connection.settings.map(([key, value]) => [
+      key,
+      /(?:url)$/.test(key) ? endpointCoordinate(value) : value
+    ])
+  };
+}
+
+// src/core/providers/opencode/connection.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import path3 from "path";
+import { parse } from "jsonc-parser";
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function configCoordinates(value) {
+  const config = record(value);
+  return {
+    enabled_providers: config.enabled_providers,
+    disabled_providers: config.disabled_providers,
+    providers: Object.entries(record(config.provider)).sort(([a], [b]) => a.localeCompare(b)).map(([id, raw]) => {
+      const provider = record(raw);
+      const options = record(provider.options);
+      return {
+        id,
+        npm: typeof provider.npm === "string" ? provider.npm : void 0,
+        api: endpointCoordinate(provider.api),
+        options: Object.fromEntries(
+          ["baseURL", "region", "profile", "project", "location", "endpoint"].filter((key) => typeof options[key] === "string").map((key) => [
+            key,
+            key === "baseURL" || key === "endpoint" ? endpointCoordinate(options[key]) : options[key]
+          ])
+        ),
+        models: Object.entries(record(provider.models)).sort(([a], [b]) => a.localeCompare(b)).map(([selector, model]) => ({
+          selector,
+          id: typeof record(model).id === "string" ? record(model).id : void 0,
+          api: endpointCoordinate(record(model).api)
+        }))
+      };
+    })
+  };
+}
+function opencodeConnectionCoordinates(projectRoot, env) {
+  const configHome = env.BUILD_OPENCODE_XDG_CONFIG_HOME?.trim() || env.XDG_CONFIG_HOME?.trim() || path3.join(env.HOME?.trim() || homedir2(), ".config");
+  const files = [
+    path3.join(configHome, "opencode", "opencode.json"),
+    path3.join(configHome, "opencode", "opencode.jsonc"),
+    path3.join(configHome, "opencode", "config.json")
+  ];
+  for (let current = path3.resolve(projectRoot); ; ) {
+    files.push(path3.join(current, "opencode.json"), path3.join(current, "opencode.jsonc"));
+    const parent = path3.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  if (env.OPENCODE_CONFIG) files.push(path3.resolve(projectRoot, env.OPENCODE_CONFIG));
+  const configs = [];
+  for (const file of files) {
+    try {
+      configs.push([file, configCoordinates(parse(readFileSync3(file, "utf8")))]);
+    } catch {
+    }
+  }
+  if (env.OPENCODE_CONFIG_CONTENT)
+    configs.push(["inline", configCoordinates(parse(env.OPENCODE_CONFIG_CONTENT))]);
+  return {
+    configHome,
+    configs,
+    awsProfile: env.AWS_PROFILE,
+    region: env.AWS_REGION ?? env.AWS_DEFAULT_REGION,
+    project: env.GOOGLE_CLOUD_PROJECT,
+    location: env.CLOUD_ML_REGION
+  };
+}
+function opencodeInventoryContext(projectRoot, env) {
+  return createHash("sha256").update(
+    JSON.stringify({
+      projectRoot: path3.resolve(projectRoot),
+      ...opencodeConnectionCoordinates(projectRoot, env)
+    })
+  ).digest("hex");
+}
+
+// src/core/providers/refresh/overlay.ts
+import { existsSync as existsSync2, readFileSync as readFileSync4 } from "fs";
+import * as fs from "fs/promises";
+import { z } from "zod";
+var REFRESH_OVERLAY_SCHEMA_VERSION = 1;
+var UsdPer1MSchema = z.union([
+  z.number().nonnegative(),
+  z.string().regex(/^\d+(?:\.\d+)?$/, "Must be non-negative USD")
+]);
+var OverlayModelAvailableEntrySchema = z.object({
+  id: z.string().trim().min(1),
+  display_name: z.string().min(1),
+  full_name: z.string().optional(),
+  capabilities: z.array(z.string()),
+  context_window: z.number().int().positive().optional(),
+  max_output_tokens: z.number().int().positive().optional(),
+  reasoning_effort_levels: z.array(z.string()).optional(),
+  default_reasoning_effort: z.string().optional(),
+  thinking: z.object({
+    supported: z.boolean().optional(),
+    adaptive: z.boolean().optional(),
+    budget_tokens_supported: z.boolean().optional(),
+    min_budget_tokens: z.number().int().optional(),
+    default_budget_tokens: z.number().int().optional(),
+    max_budget_tokens: z.number().int().optional()
+  }).strict().optional(),
+  canonical_id: z.string().optional(),
+  lineage: z.string().optional(),
+  release_date: z.string().optional(),
+  lifecycle: z.record(z.string(), z.unknown()).optional(),
+  metadata_sources: z.record(z.string(), z.enum(["official", "community", "native"])).optional(),
+  harness: z.object({
+    context_window: z.number().int().positive().optional(),
+    max_context_window: z.number().int().positive().optional(),
+    max_output_tokens: z.number().int().positive().optional()
+  }).strict().optional(),
+  notes: z.string().optional(),
+  discovery_source: z.enum(["API", "native", "community"]).optional(),
+  deprecation: z.record(z.string(), z.unknown()).optional()
+}).strict();
+var OverlayPricingRowSchema = z.object({
+  input_per_1m_tokens: UsdPer1MSchema.optional(),
+  output_per_1m_tokens: UsdPer1MSchema.optional(),
+  cache_read_per_1m_tokens: UsdPer1MSchema.optional(),
+  cache_write_per_1m_tokens: UsdPer1MSchema.optional(),
+  long_context_pricing: LongContextPricingSchema.optional(),
+  speed_tiers: z.record(z.string(), SpeedTierPricingSchema).optional(),
+  context_window: z.number().int().positive().optional(),
+  features: z.record(z.string(), z.boolean()).optional(),
+  // Runtime pricing fields travel with the rates they describe: an overlay-only
+  // row has no authored row to inherit them from.
+  billing_source: z.string().optional(),
+  pricing_source: z.string().optional(),
+  pricing_confidence: z.enum(["high", "medium", "low"]).optional(),
+  notes: z.string().optional(),
+  last_updated: z.string().optional()
+}).strict();
+var REFRESH_SOURCES = [
+  "API",
+  "community",
+  "doc-poll",
+  "pricing-only",
+  "discovery",
+  "static"
+];
+var OverlaySliceProvenanceSchema = z.object({
+  source: z.enum(REFRESH_SOURCES),
+  fetchedAt: z.string().min(1),
+  freshnessMs: z.number().int().nonnegative().optional()
+}).strict();
+var OverlayProviderPayloadSchema = z.object({
+  models: z.object({
+    available: z.array(OverlayModelAvailableEntrySchema),
+    /** Treat available as the complete provider inventory, not an additive patch. */
+    replaceInventory: z.literal(true).optional(),
+    /**
+     * Ids the provider CLI itself reported on its last observed inventory
+     * (context payloads only). Offered models are limited to this set; rows
+     * from public feeds or earlier refreshes stay resolvable but unlisted.
+     */
+    observedIds: z.array(z.string().trim().min(1)).optional()
+  }).strict().optional(),
+  pricing: z.object({
+    models: z.record(z.string(), OverlayPricingRowSchema)
+  }).strict().optional(),
+  /** Provider-level freshness / provenance. */
+  provenance: OverlaySliceProvenanceSchema.optional(),
+  /** Per-slice freshness / provenance (models vs pricing). */
+  slices: z.object({
+    models: OverlaySliceProvenanceSchema.optional(),
+    pricing: OverlaySliceProvenanceSchema.optional()
+  }).strict().optional()
+}).strict();
+var RefreshOverlayDocumentSchema = z.object({
+  schemaVersion: z.literal(REFRESH_OVERLAY_SCHEMA_VERSION),
+  baseCatalogDigest: z.string().min(1),
+  providers: z.record(z.string(), OverlayProviderPayloadSchema),
+  /** Native inventories are never a provider-wide public catalog. */
+  contexts: z.record(z.string(), z.record(z.string(), OverlayProviderPayloadSchema)).optional()
+}).strict();
+var REFRESH_OVERLAY_RERUN_GUIDANCE = "Refresh overlay ignored because the release catalog digest changed. Run: build provider refresh";
+var REFRESH_OVERLAY_SOURCE_DRIFT_GUIDANCE = "Refresh overlay ignored because .build-project/config/providers.yaml changed after the provider catalog was generated. Run: node scripts/generate-provider-json.js, then build provider refresh";
+function noticeFromRefreshOverlayDisposition(disposition) {
+  if (disposition.status === "degraded") {
+    return {
+      status: "degraded",
+      reason: disposition.reason,
+      message: disposition.warning,
+      guidance: disposition.reason === "source_base_drift" ? REFRESH_OVERLAY_SOURCE_DRIFT_GUIDANCE : REFRESH_OVERLAY_RERUN_GUIDANCE
+    };
+  }
+  if (disposition.status === "rejected") {
+    return {
+      status: "rejected",
+      reason: disposition.reason,
+      message: disposition.error,
+      guidance: "Refresh overlay is invalid and was ignored. Run: build provider refresh"
+    };
+  }
+  return void 0;
+}
+function getRefreshOverlayOperatorNotice(overlayPath, expectedBaseCatalogDigest, sourceBaseDrift) {
+  if (!existsSync2(overlayPath)) return void 0;
+  try {
+    const disposition = resolveRefreshOverlayDisposition(readFileSync4(overlayPath, "utf8"), {
+      expectedBaseCatalogDigest,
+      sourceBaseDrift
+    });
+    return noticeFromRefreshOverlayDisposition(disposition);
+  } catch {
+    return void 0;
+  }
+}
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortKeysDeep);
+  }
+  if (value && typeof value === "object") {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+      sorted[key] = sortKeysDeep(value[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function emptyRefreshOverlay(baseCatalogDigest) {
+  return {
+    schemaVersion: REFRESH_OVERLAY_SCHEMA_VERSION,
+    baseCatalogDigest,
+    providers: {}
+  };
+}
+function serializeRefreshOverlay(overlay) {
+  const parsed = RefreshOverlayDocumentSchema.safeParse(overlay);
+  if (!parsed.success) {
+    throw new Error(
+      `Cannot serialize invalid refresh overlay: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`
+    );
+  }
+  return `${JSON.stringify(sortKeysDeep(parsed.data), null, 2)}
+`;
+}
+function parseRefreshOverlayValue(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return { ok: false, error: "Refresh overlay must be a JSON object" };
+  }
+  const parsed = RefreshOverlayDocumentSchema.safeParse(value);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      error: `Invalid refresh overlay schema: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ")}`
+    };
+  }
+  return { ok: true, overlay: parsed.data };
+}
+function parseRefreshOverlay(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (error) {
+    return {
+      ok: false,
+      error: `Refresh overlay is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  return parseRefreshOverlayValue(value);
+}
+function resolveRefreshOverlayDisposition(input, options) {
+  const parsed = typeof input === "string" ? parseRefreshOverlay(input) : parseRefreshOverlayValue(input);
+  if (!parsed.ok) {
+    return { status: "rejected", reason: "invalid_schema", error: parsed.error };
+  }
+  if (options.sourceBaseDrift) {
+    const drift = options.sourceBaseDrift;
+    return {
+      status: "degraded",
+      reason: "source_base_drift",
+      warning: `Refresh overlay source base drift: ${drift.path} sha256=${drift.actualDigest} does not match the compiled source digest ${drift.expectedDigest}; overlay ignored until the provider generator runs`,
+      overlay: parsed.overlay
+    };
+  }
+  if (options.expectedBaseCatalogDigest !== parsed.overlay.baseCatalogDigest) {
+    return {
+      status: "degraded",
+      reason: "base_digest_mismatch",
+      warning: `Refresh overlay base catalog digest mismatch: overlay=${parsed.overlay.baseCatalogDigest} expected=${options.expectedBaseCatalogDigest}; overlay ignored`,
+      overlay: parsed.overlay
+    };
+  }
+  return { status: "ready", overlay: parsed.overlay };
+}
+async function loadRefreshOverlayFile(overlayPath, options) {
+  try {
+    const stat = await fs.lstat(overlayPath);
+    if (stat.isSymbolicLink()) {
+      return {
+        status: "rejected",
+        reason: "invalid_schema",
+        error: `Provider refresh refuses a symlinked overlay: ${overlayPath}`
+      };
+    }
+    if (!stat.isFile()) {
+      return {
+        status: "rejected",
+        reason: "invalid_schema",
+        error: `Provider refresh overlay target is not a regular file: ${overlayPath}`
+      };
+    }
+    const raw = await fs.readFile(overlayPath, "utf8");
+    return resolveRefreshOverlayDisposition(raw, options);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { status: "absent" };
+    }
+    throw error;
+  }
+}
+
+// src/core/providers/refresh/storage.ts
+function hash(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+var PROVIDER_CHILD_ONLY_ENV = ["XDG_DATA_HOME", "CURSOR_CONFIG_DIR"];
+function readRefreshOrigin(raw) {
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function withRefreshOrigin(overrides) {
+  if (!PROVIDER_CHILD_ONLY_ENV.some((key) => key in overrides)) return overrides;
+  const inherited = process.env[BUILD_REFRESH_ORIGIN_ENV.name];
+  const origin = inherited ?? JSON.stringify(
+    Object.fromEntries(PROVIDER_CHILD_ONLY_ENV.map((key) => [key, process.env[key] ?? null]))
+  );
+  return { ...overrides, [BUILD_REFRESH_ORIGIN_ENV.name]: origin };
+}
+function refreshEnvironment() {
+  const env = { ...process.env, ...getExecutionContext().envOverrides };
+  const origin = readRefreshOrigin(env[BUILD_REFRESH_ORIGIN_ENV.name]);
+  for (const key of PROVIDER_CHILD_ONLY_ENV) {
+    const value = origin ? origin[key] : process.env[key];
+    if (typeof value === "string") env[key] = value;
+    else delete env[key];
+  }
+  return env;
+}
+function refreshInventoryContext(projectRoot, env = refreshEnvironment()) {
+  const root = existsSync3(projectRoot) ? realpathSync(projectRoot) : path4.resolve(projectRoot);
+  const label = env.BUILD_MODEL_REFRESH_CONTEXT?.trim();
+  const coordinates = [
+    label || `unknown:${root}`,
+    env.AWS_PROFILE ?? "",
+    env.AWS_REGION ?? env.AWS_DEFAULT_REGION ?? "",
+    env.GOOGLE_CLOUD_PROJECT ?? "",
+    env.CLOUD_ML_REGION ?? "",
+    env.CODEX_HOME ?? "",
+    env.CLAUDE_CONFIG_DIR ?? "",
+    codexConnectionCoordinates(env),
+    opencodeConnectionCoordinates(root, env),
+    // Appended only when set, so keys for users without these homes are unchanged.
+    ...env.GROK_HOME?.trim() ? [`grok-home:${env.GROK_HOME.trim()}`] : [],
+    ...env.CURSOR_CONFIG_DIR?.trim() ? [`cursor-config:${env.CURSOR_CONFIG_DIR.trim()}`] : []
+  ];
+  return hash(JSON.stringify(coordinates));
+}
+function resolveSharedRefreshPaths(digest2 = PROVIDER_CATALOG_SHA256, env = refreshEnvironment()) {
+  const dataRoot = assertContainedPath(getDataDir(env), ".", "Provider data root");
+  const storageRoot = path4.join(dataRoot, "provider-refresh", hash(digest2));
+  return {
+    dataRoot,
+    storageRoot,
+    overlayPath: path4.join(storageRoot, "refresh-overlay.json"),
+    lockFile: path4.join(storageRoot, "refresh.lock"),
+    auditLogFile: path4.join(storageRoot, "refresh.jsonl")
+  };
+}
+function selectRefreshContext(overlay, contextId) {
+  const providers = { ...overlay.providers };
+  for (const [provider, payload] of Object.entries(overlay.contexts?.[contextId] ?? {})) {
+    const publicPayload = providers[provider];
+    const models = new Map((publicPayload?.models?.available ?? []).map((row) => [row.id, row]));
+    for (const row of payload.models?.available ?? [])
+      models.set(row.id, mergeContextModel(models.get(row.id), row));
+    providers[provider] = {
+      ...publicPayload,
+      ...payload,
+      ...publicPayload?.models || payload.models ? {
+        models: {
+          available: [...models.values()],
+          ...payload.models?.observedIds ? { observedIds: payload.models.observedIds } : {}
+        }
+      } : {},
+      slices: { ...publicPayload?.slices, ...payload.slices },
+      ...publicPayload?.pricing || payload.pricing ? { pricing: { models: { ...publicPayload?.pricing?.models, ...payload.pricing?.models } } } : {}
+    };
+  }
+  return { ...overlay, providers };
+}
+function mergeContextModel(publicRow, contextRow) {
+  if (!publicRow) return contextRow;
+  const sources = {};
+  const record2 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+  const merge = (published, observed, field, inheritedPublic, inheritedNative) => {
+    const publicSource = publicRow.metadata_sources?.[field] ?? inheritedPublic;
+    const contextSource = contextRow.metadata_sources?.[field] ?? inheritedNative;
+    if ((record2(published) || published === void 0) && (record2(observed) || observed === void 0) && (record2(published) || record2(observed))) {
+      const left = record2(published) ? published : {};
+      const right = record2(observed) ? observed : {};
+      return Object.fromEntries(
+        [.../* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)])].filter((key) => field !== "" || key !== "metadata_sources").map((key) => [
+          key,
+          merge(
+            left[key],
+            right[key],
+            field ? `${field}.${key}` : key,
+            publicSource,
+            contextSource
+          )
+        ])
+      );
+    }
+    const useContext = observed !== void 0 && (published === void 0 || contextSource === "native" || field === "discovery_source");
+    const source = useContext ? contextSource : publicSource;
+    if (source) sources[field] = source;
+    return useContext ? observed : published;
+  };
+  const merged = merge(publicRow, contextRow, "");
+  if (Object.keys(sources).length) merged.metadata_sources = sources;
+  return merged;
+}
+function carriedModels(payloads) {
+  return Object.fromEntries(
+    Object.entries(payloads).flatMap(([provider, payload]) => {
+      if (!payload.models) return [];
+      const { replaceInventory: _replace, ...models } = payload.models;
+      return [[provider, { models }]];
+    })
+  );
+}
+function carriedForwardOverlay(overlayPath, digest2) {
+  const refreshRoot = path4.dirname(path4.dirname(overlayPath));
+  const current = path4.basename(path4.dirname(overlayPath));
+  let entries;
+  try {
+    entries = readdirSync(refreshRoot);
+  } catch {
+    return void 0;
+  }
+  const previous = entries.filter((entry) => entry !== current).flatMap((entry) => {
+    const overlayPath2 = path4.join(refreshRoot, entry, "refresh-overlay.json");
+    try {
+      const stat = statSync(overlayPath2);
+      return stat.isFile() ? [{ overlayPath: overlayPath2, mtimeMs: stat.mtimeMs }] : [];
+    } catch {
+      return [];
+    }
+  }).sort((left, right) => right.mtimeMs - left.mtimeMs)[0];
+  if (!previous) return void 0;
+  let parsed;
+  try {
+    parsed = parseRefreshOverlay(readFileSync5(previous.overlayPath, "utf8"));
+  } catch {
+    return void 0;
+  }
+  if (!parsed.ok) return void 0;
+  const contexts = Object.fromEntries(
+    Object.entries(parsed.overlay.contexts ?? {}).map(([id, payloads]) => [
+      id,
+      carriedModels(payloads)
+    ])
+  );
+  return {
+    schemaVersion: parsed.overlay.schemaVersion,
+    baseCatalogDigest: digest2,
+    providers: carriedModels(parsed.overlay.providers),
+    ...Object.keys(contexts).length > 0 ? { contexts } : {}
+  };
+}
+function readEffectiveRefreshOverlay(projectRoot, options, env = refreshEnvironment()) {
+  const shared = resolveSharedRefreshPaths(options.expectedBaseCatalogDigest, env);
+  const isShared = existsSync3(shared.overlayPath);
+  const overlayPath = isShared ? shared.overlayPath : path4.join(projectRoot, ".build-project", "cache", "model-update", "refresh-overlay.json");
+  let disposition = { status: "absent" };
+  const carried = existsSync3(overlayPath) ? void 0 : carriedForwardOverlay(shared.overlayPath, options.expectedBaseCatalogDigest);
+  if (carried) {
+    disposition = resolveRefreshOverlayDisposition(carried, options);
+    if (disposition.status === "ready") {
+      disposition = {
+        status: "ready",
+        overlay: selectRefreshContext(
+          disposition.overlay,
+          refreshInventoryContext(projectRoot, env)
+        )
+      };
+    }
+    return { path: shared.overlayPath, scope: "global", disposition, carried: true };
+  }
+  if (existsSync3(overlayPath)) {
+    try {
+      disposition = resolveRefreshOverlayDisposition(readFileSync5(overlayPath, "utf8"), options);
+      if (isShared && disposition.status === "ready") {
+        disposition = {
+          status: "ready",
+          overlay: selectRefreshContext(
+            disposition.overlay,
+            refreshInventoryContext(projectRoot, env)
+          )
+        };
+      }
+    } catch (error) {
+      disposition = {
+        status: "rejected",
+        reason: "invalid_schema",
+        error: `Cannot read refresh overlay: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  return { path: overlayPath, scope: isShared ? "global" : "legacy", disposition };
+}
+
+// src/core/config/cache-fingerprint.ts
+import { createHash as createHash3 } from "crypto";
+import { statSync as statSync2 } from "fs";
+import { resolve } from "path";
+function digest(value) {
+  return createHash3("sha256").update(value).digest("hex");
+}
+function fingerprintEnvironment(env, include = (name) => name.startsWith("BUILD_")) {
+  const entries = Object.entries(env).filter(([name, value]) => include(name) && value !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([name, value]) => [name, digest(value ?? "")]);
+  return digest(JSON.stringify(entries));
+}
+function fingerprintFile(filePath) {
+  const normalized = resolve(filePath);
+  try {
+    const stat = statSync2(normalized);
+    return JSON.stringify({
+      path: normalized,
+      exists: true,
+      dev: stat.dev,
+      ino: stat.ino,
+      size: stat.size,
+      mtimeMs: stat.mtimeMs,
+      ctimeMs: stat.ctimeMs
+    });
+  } catch (error) {
+    const code = error.code;
+    return JSON.stringify({ path: normalized, exists: false, code: code ?? "UNKNOWN" });
+  }
+}
+function fingerprintFiles(filePaths) {
+  return digest(JSON.stringify([...new Set(filePaths)].sort().map(fingerprintFile)));
+}
+function combineCacheFingerprints(...parts) {
+  return digest(JSON.stringify(parts.filter((part) => part !== void 0)));
+}
+
+// src/core/config/config-errors.ts
+var InvalidExplicitConfigError = class extends Error {
+  constructor(message, sourceError) {
+    super(message);
+    this.sourceError = sourceError;
+    this.name = "InvalidExplicitConfigError";
+  }
+  sourceError;
+  code = "BUILD_INVALID_EXPLICIT_CONFIG";
+};
+var InvalidConfigContentError = class extends InvalidExplicitConfigError {
+};
+function isInvalidExplicitConfigError(error) {
+  return error instanceof InvalidExplicitConfigError || error instanceof Error && error.code === "BUILD_INVALID_EXPLICIT_CONFIG";
+}
+function isConfigValidityError(error) {
+  if (isInvalidExplicitConfigError(error)) return true;
+  return error instanceof Error && error.code === "BUILD_CONFIG_READ_INVALID";
+}
+function rethrowConfigValidityError(error) {
+  if (isConfigValidityError(error)) throw error;
+}
+
+// src/core/config/embedded-provider-catalog.ts
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
+import { resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var PACKAGED_CATALOG_BASENAME = "catalog.json";
+function getEmbeddedProviderConfigPaths() {
+  const packageRoot = findBuildPackageRoot(__filename);
+  if (!packageRoot) return [];
+  return [
+    // A source checkout authors the canonical YAML directly. Prefer it over the
+    // ignored generated asset so a stale prebuild output cannot shadow or break
+    // local authoring. The YAML path is not published in the npm package.
+    resolve2(packageRoot, ".build-project/config/providers.yaml"),
+    // Installed runtimes therefore require the packaged, digest-checked asset.
+    resolve2(packageRoot, ".build-project/providers/catalog.json")
+  ];
+}
+function isPackagedCatalogPath(embeddedPath) {
+  return embeddedPath.endsWith(PACKAGED_CATALOG_BASENAME);
+}
+function resolveSourceBaseDrift(embeddedPath, bytes) {
+  if (isPackagedCatalogPath(embeddedPath)) return void 0;
+  const actualDigest = createHash4("sha256").update(bytes).digest("hex");
+  if (actualDigest === PROVIDER_SOURCE_YAML_SHA256) return void 0;
+  return { path: embeddedPath, expectedDigest: PROVIDER_SOURCE_YAML_SHA256, actualDigest };
+}
+function detectSourceBaseDrift() {
+  for (const embeddedPath of getEmbeddedProviderConfigPaths()) {
+    if (!existsSync4(embeddedPath)) continue;
+    try {
+      return resolveSourceBaseDrift(embeddedPath, readFileSync6(embeddedPath));
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+
+// src/core/config/model-selector-normalization.ts
+function normalizeModelSelectorForComparison(value) {
+  return value.trim().toLowerCase().replace(/\[[^\]]*\]\s*$/, "").trim();
+}
+
+// src/core/config/offered-models.ts
+var PSEUDO_MODEL_IDS = /* @__PURE__ */ new Set(["auto"]);
+function isOfferedModel(models, modelId) {
+  if (!models.observed_ids) return true;
+  return models.observed_ids.includes(modelId) || PSEUDO_MODEL_IDS.has(modelId) || (models.family_aliases ?? []).includes(modelId);
+}
+function offeredModelRows(models) {
+  return models.available.filter((row) => isOfferedModel(models, row.id));
+}
+function offeredModelIds(models) {
+  return offeredModelRows(models).map((row) => row.id);
+}
+var warnedUnobservedModels = /* @__PURE__ */ new Set();
+function warnIfModelUnobserved(providerId, models, modelId) {
+  if (isOfferedModel(models, modelId)) return;
+  const key = `${providerId}:${modelId}`;
+  if (warnedUnobservedModels.has(key)) return;
+  warnedUnobservedModels.add(key);
+  emitWarning(
+    "CFG-001",
+    { taskId: "provider-registry", subsystem: "config", executionPhase: "setup" },
+    {
+      severity: "WARN" /* WARN */,
+      message: `Model '${modelId}' is not in the ${providerId} CLI's observed model list; running it as requested.`,
+      metadata: { providerId, modelId, operation: "resolveModel" }
+    }
+  );
+}
+
+// src/core/config/project-trust.ts
+import { realpathSync as realpathSync2 } from "fs";
+import { isAbsolute, resolve as resolve3 } from "path";
+var PROJECT_EXECUTION_TRUST_ENV = "BUILD_TRUST_PROJECT_PROVIDER_TEMPLATES";
+function isTrustedProjectRoot(projectRoot) {
+  const projectTrustValue = String(process.env[PROJECT_EXECUTION_TRUST_ENV] ?? "").trim();
+  if (!projectTrustValue || !isAbsolute(projectTrustValue)) return false;
+  try {
+    return realpathSync2(resolve3(projectTrustValue)) === realpathSync2(projectRoot);
+  } catch {
+    return false;
+  }
+}
+function formatProjectTrustInstruction(projectRoot) {
+  let canonical = projectRoot;
+  try {
+    canonical = realpathSync2(projectRoot);
+  } catch {
+  }
+  return `  export ${PROJECT_EXECUTION_TRUST_ENV}=${JSON.stringify(canonical)}`;
+}
+
+// src/core/config/provider-enable-switches.ts
+import { readFileSync as readFileSync7 } from "fs";
+import { join as join2 } from "path";
+import { parse as parseJsonc } from "jsonc-parser";
+var DISABLED_VALUES = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
+var ENABLED_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+var disabledBy = /* @__PURE__ */ new WeakMap();
+function envFlagName(providerId) {
+  return `BUILD_${providerId.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_ENABLED`;
+}
+function layerConfigFiles(projectRoot) {
+  return [join2(projectRoot, ".build-project", "config", "build.config.jsonc"), getUserConfigFile()];
+}
+function runtimeEnv() {
+  return { ...process.env, ...getExecutionContext().envOverrides };
+}
+function enableSwitchCacheKey(projectRoot) {
+  return fingerprintFiles(layerConfigFiles(projectRoot).flatMap(configCandidates));
+}
+function configCandidates(configFile) {
+  const base = configFile.replace(/\.jsonc$/i, "");
+  return [`${base}.jsonc`, `${base}.json`];
+}
+function readLayerProviders(configFile) {
+  for (const candidate of configCandidates(configFile)) {
+    let source;
+    try {
+      source = readFileSync7(candidate, "utf8");
+    } catch (error) {
+      if (getErrorCode(error) === "ENOENT") continue;
+      return void 0;
+    }
+    const errors = [];
+    const parsed = parseJsonc(source, errors, {
+      allowTrailingComma: true,
+      allowEmptyContent: false,
+      disallowComments: false
+    });
+    if (errors.length > 0) return void 0;
+    const providers = isObject(parsed) && isObject(parsed.providers) ? parsed.providers : {};
+    return { path: candidate, providers };
+  }
+  return void 0;
+}
+function applyProviderEnableSwitches(registry, projectRoot, env = runtimeEnv()) {
+  const layers = layerConfigFiles(projectRoot).map(readLayerProviders);
+  const reasons = /* @__PURE__ */ new Map();
+  for (const [providerId, config] of Object.entries(registry.providers)) {
+    if (!config.enabled) continue;
+    const envName = envFlagName(providerId);
+    const envValue = getEnvVarEntry(envName) ? env[envName]?.trim().toLowerCase() : void 0;
+    if (envValue && DISABLED_VALUES.has(envValue)) {
+      reasons.set(providerId, `${envName}=${env[envName]}`);
+      continue;
+    }
+    if (envValue && ENABLED_VALUES.has(envValue)) continue;
+    for (const layer of layers) {
+      const entry = layer?.providers[providerId];
+      const enabled = isObject(entry) ? entry.enabled : void 0;
+      if (typeof enabled !== "boolean") continue;
+      if (enabled === false) {
+        reasons.set(providerId, `providers.${providerId}.enabled: false in ${layer?.path}`);
+      }
+      break;
+    }
+  }
+  if (reasons.size === 0) return registry;
+  const providers = { ...registry.providers };
+  for (const providerId of reasons.keys()) {
+    providers[providerId] = { ...providers[providerId], enabled: false };
+  }
+  const result = { ...registry, providers };
+  disabledBy.set(result, reasons);
+  return result;
+}
+function providerDisableSwitch(registry, providerId) {
+  return disabledBy.get(registry)?.get(providerId);
+}
+function disabledBySuffix(registry, providerId) {
+  const source = providerDisableSwitch(registry, providerId);
+  return source ? ` (disabled by ${source})` : "";
+}
+
+// src/core/config/provider-pricing-schema.ts
+import { z as z2 } from "zod";
+var DateLikeStringSchema = z2.union([z2.string(), z2.date()]).transform((value) => value instanceof Date ? value.toISOString() : value);
+var PriceNumberSchema = z2.union([z2.number(), z2.string()]).transform((value) => typeof value === "string" ? Number(value) : value).pipe(z2.number().min(0)).optional();
+var ModelPricingSchema = z2.object({
+  input_per_1m_tokens: PriceNumberSchema,
+  output_per_1m_tokens: PriceNumberSchema,
+  cache_read_per_1m_tokens: PriceNumberSchema,
+  cache_write_per_1m_tokens: PriceNumberSchema,
+  /** Rate for cache writes held for the longer duration (Anthropic's 1-hour write). */
+  cache_write_1h_per_1m_tokens: PriceNumberSchema,
+  input_per_1k_tokens: PriceNumberSchema,
+  output_per_1k_tokens: PriceNumberSchema,
+  base_rate_per_1k_tokens: PriceNumberSchema,
+  premium_multiplier: PriceNumberSchema,
+  context_window: z2.number().int().optional(),
+  long_context_pricing: LongContextPricingSchema.optional(),
+  /** Per speed-tier rate sets keyed by tier name (e.g. `fast`). */
+  speed_tiers: z2.record(z2.string(), SpeedTierPricingSchema).optional(),
+  features: z2.record(z2.string(), z2.boolean()).optional(),
+  // Telemetry-only placeholder: pricing is intentionally absent and
+  // missing-pricing telemetry errors log at debug instead of warn.
+  non_metered: z2.boolean().optional(),
+  /** How the row is billed (e.g. `api_list_price`, `included_plan`); decides metered vs provider billing. */
+  billing_source: z2.string().optional(),
+  /** Maker reference the rates come from (e.g. `anthropic_docs`) or the refresh source label. */
+  pricing_source: z2.string().optional(),
+  pricing_confidence: z2.enum(["high", "medium", "low"]).optional(),
+  /** Why the model has no price and must never be priced from another model's rates. */
+  unpriced_reason: z2.string().optional(),
+  notes: z2.string().optional(),
+  last_updated: DateLikeStringSchema.optional(),
+  _meta: z2.record(z2.string(), z2.unknown()).optional()
+}).strict();
+var ToolPricingSchema = z2.object({
+  cost_per_request: z2.number().min(0).optional(),
+  cost_per_read_1m_tokens: z2.number().min(0).optional(),
+  cost_per_write_1m_tokens: z2.number().min(0).optional(),
+  unit: z2.string().optional(),
+  notes: z2.string().optional(),
+  available_in: z2.array(z2.string()).optional()
+}).strict();
+var SubscriptionPricingSchema = z2.object({
+  monthly_cost: z2.number().min(0).optional(),
+  included_credits: z2.number().min(0).optional(),
+  overage_rate_per_credit: z2.number().min(0).optional(),
+  individual_monthly: z2.number().min(0).optional(),
+  business_monthly_per_user: z2.number().min(0).optional(),
+  enterprise_monthly_per_user: z2.number().min(0).optional()
+}).strict();
+var InfrastructurePricingSchema = z2.object({
+  cloud_execution_per_minute: z2.number().min(0).optional(),
+  premium_execution_per_minute: z2.number().min(0).optional(),
+  proxy_routing_per_request: z2.number().min(0).optional(),
+  notes: z2.string().optional()
+}).strict();
+var PricingPassthroughSchema = z2.object({
+  provider: z2.string().trim().min(1),
+  strip_prefixes: z2.array(z2.string()).optional()
+}).strict();
+var ProviderPricingSchema = z2.object({
+  billing_mode: z2.enum(["metered", "subscription", "hybrid"]),
+  currency: z2.string(),
+  last_updated: DateLikeStringSchema.optional(),
+  notes: z2.string().optional(),
+  exchange_rate_note: z2.string().optional(),
+  models: z2.record(z2.string(), ModelPricingSchema).optional(),
+  tools: z2.record(z2.string(), ToolPricingSchema).optional(),
+  subscription: SubscriptionPricingSchema.optional(),
+  infrastructure: InfrastructurePricingSchema.optional(),
+  passthrough: PricingPassthroughSchema.optional(),
+  features: z2.record(z2.string(), z2.unknown()).optional(),
+  _meta: z2.record(z2.string(), z2.unknown()).optional()
+}).strict();
+
+// src/core/config/provider-registry-reload-invalidators.ts
+var reloadInvalidators = /* @__PURE__ */ new Set();
+function registerProviderRegistryReloadInvalidator(invalidator) {
+  reloadInvalidators.add(invalidator);
+  return () => {
+    reloadInvalidators.delete(invalidator);
+  };
+}
+function runProviderRegistryReloadInvalidators() {
+  for (const invalidator of reloadInvalidators) {
+    invalidator();
+  }
+}
+
+// src/core/config/refresh-overlay-apply.ts
+function baseModelIds(baseRaw, providerId) {
+  const providers = baseRaw?.providers;
+  const provider = providers?.[providerId];
+  const available = provider?.models?.available;
+  return new Set(
+    (Array.isArray(available) ? available : []).flatMap(
+      (entry) => typeof entry?.id === "string" ? [entry.id] : []
+    )
+  );
+}
+function additions(baseRaw, payloads) {
+  return Object.fromEntries(
+    Object.entries(payloads).flatMap(([providerId, payload]) => {
+      const shipped = baseModelIds(baseRaw, providerId);
+      const available = (payload.models?.available ?? []).filter((row) => !shipped.has(row.id));
+      return available.length > 0 ? [[providerId, { models: { available } }]] : [];
+    })
+  );
+}
+function catalogAdditions(baseRaw, overlay) {
+  const contexts = Object.fromEntries(
+    Object.entries(overlay.contexts ?? {}).map(([id, payloads]) => [
+      id,
+      additions(baseRaw, payloads)
+    ])
+  );
+  return {
+    schemaVersion: overlay.schemaVersion,
+    baseCatalogDigest: overlay.baseCatalogDigest,
+    providers: additions(baseRaw, overlay.providers),
+    ...overlay.contexts ? { contexts } : {}
+  };
+}
+function applyRefreshOverlay(baseRaw, refreshOverlay, options = {}) {
+  if (!baseRaw || typeof baseRaw !== "object" || Array.isArray(baseRaw)) return baseRaw;
+  const overlay = options.carried ? catalogAdditions(baseRaw, refreshOverlay) : refreshOverlay;
+  const base = structuredClone(baseRaw);
+  const providers = base.providers;
+  if (!providers || typeof providers !== "object" || Array.isArray(providers)) return baseRaw;
+  for (const [providerId, payload] of Object.entries(overlay.providers)) {
+    const provider = providers[providerId];
+    if (!provider || typeof provider !== "object" || Array.isArray(provider)) continue;
+    const providerObject = provider;
+    if (payload.models) {
+      const models = providerObject.models;
+      if (models && typeof models === "object" && !Array.isArray(models)) {
+        const modelObject = models;
+        const current = Array.isArray(modelObject.available) ? modelObject.available : [];
+        const overlayById = new Map(payload.models.available.map((entry) => [entry.id, entry]));
+        const merged = current.map((entry) => {
+          if (!entry || typeof entry !== "object" || Array.isArray(entry)) return entry;
+          const id = entry.id;
+          const updated = typeof id === "string" ? overlayById.get(id) : void 0;
+          if (!updated) return entry;
+          overlayById.delete(id);
+          return { ...entry, ...updated };
+        });
+        modelObject.available = [...merged, ...overlayById.values()];
+        if (payload.models.observedIds) modelObject.observed_ids = payload.models.observedIds;
+      }
+    }
+    if (payload.pricing) {
+      const pricing = providerObject.pricing;
+      if (pricing && typeof pricing === "object" && !Array.isArray(pricing)) {
+        const pricingObject = pricing;
+        const currentModels = pricingObject.models && typeof pricingObject.models === "object" && !Array.isArray(pricingObject.models) ? pricingObject.models : {};
+        pricingObject.models = Object.fromEntries(
+          Object.entries({ ...currentModels, ...payload.pricing.models }).map(([id, row]) => [
+            id,
+            currentModels[id] && typeof currentModels[id] === "object" ? { ...currentModels[id], ...row } : row
+          ])
+        );
+      }
+    }
+  }
+  return base;
+}
+
+// src/core/config/registry-overlay-settings.ts
+import { join as join3, resolve as resolve4 } from "path";
+var warnedOverlayPaths = /* @__PURE__ */ new Set();
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function providersOf(raw) {
+  return asRecord(asRecord(raw)?.providers) ?? {};
+}
+function sameValue(a, b, effort = false) {
+  const normalize = (value) => {
+    if (typeof value !== "string") return value;
+    const trimmed = value.trim();
+    return effort ? normalizeReasoningEffortInput(trimmed) ?? trimmed : trimmed;
+  };
+  return JSON.stringify(normalize(a)) === JSON.stringify(normalize(b));
+}
+function roleReplacementKey(providerId, role) {
+  if (role === "judge_primary") return "judge.model";
+  if (role === "fast" || role === "cost") return `defaults.providers.${providerId}.fastModel`;
+  return `defaults.providers.${providerId}.model`;
+}
+function listOverlaySettingOverrides(overlayRaw, embeddedRaw) {
+  const embeddedProviders = providersOf(embeddedRaw);
+  const overrides = [];
+  for (const [providerId, overlayValue] of Object.entries(providersOf(overlayRaw))) {
+    const canonical = asRecord(embeddedProviders[providerId]);
+    const overlay = asRecord(overlayValue);
+    if (!canonical || !overlay) continue;
+    const add = (field, replacementKey, ignored = false) => overrides.push({ providerId, field, replacementKey, ignored });
+    const models = asRecord(overlay.models);
+    const canonicalModels = asRecord(canonical.models) ?? {};
+    if (models) {
+      if (models.default !== void 0 && !sameValue(models.default, canonicalModels.default)) {
+        add("models.default", `defaults.providers.${providerId}.model`);
+      }
+      const efforts = [
+        ["default_reasoning_effort", `defaults.providers.${providerId}.reasoningEffort`],
+        ["judge_reasoning_effort", "judge.reasoningEffort"]
+      ];
+      for (const [field, replacementKey] of efforts) {
+        if (models[field] !== void 0 && !sameValue(models[field], canonicalModels[field], true)) {
+          add(`models.${field}`, replacementKey);
+        }
+      }
+      const canonicalRoles = asRecord(canonicalModels.roles) ?? {};
+      for (const [role, value] of Object.entries(asRecord(models.roles) ?? {})) {
+        if (!sameValue(value, canonicalRoles[role])) {
+          add(`models.roles.${role}`, roleReplacementKey(providerId, role));
+        }
+      }
+      const canonicalMappings = asRecord(canonicalModels.mappings) ?? {};
+      for (const [name, value] of Object.entries(asRecord(models.mappings) ?? {})) {
+        if (!sameValue(value, canonicalMappings[name])) {
+          add(`models.mappings.${name}`, `providers.${providerId}.aliases.models.${name}`);
+        }
+      }
+    }
+    for (const [taskType, settings] of Object.entries(asRecord(overlay.task_settings) ?? {})) {
+      if (asRecord(settings)?.reasoning_effort !== void 0) {
+        add(
+          `task_settings.${taskType}.reasoning_effort`,
+          `defaults.providers.${providerId}.reasoningEffort`,
+          true
+        );
+      }
+    }
+  }
+  return overrides;
+}
+function formatOverlaySettingsWarning(path5, overrides) {
+  const shown = overrides.map(
+    (entry) => `${entry.providerId} ${entry.field} (use ${entry.replacementKey}${entry.ignored ? "; ignored now" : ""})`
+  ).join(", ");
+  return `${path5} sets model or effort settings that belong in build.config.jsonc: ${shown}. They still apply this release unless marked ignored; a later release stops reading them from providers.yaml.`;
+}
+function isBuildSourceCheckout(projectRoot) {
+  const root = findBuildPackageRoot(join3(projectRoot, "package.json"));
+  return root !== void 0 && resolve4(root) === resolve4(projectRoot);
+}
+function warnOverlaySettingsOnce(input) {
+  const dedupeKey = resolve4(input.path);
+  if (warnedOverlayPaths.has(dedupeKey)) return;
+  const overrides = listOverlaySettingOverrides(input.raw, input.embeddedRaw);
+  if (overrides.length === 0) return;
+  if (input.projectRoot !== void 0 && isBuildSourceCheckout(input.projectRoot)) return;
+  warnedOverlayPaths.add(dedupeKey);
+  const applied = new Set(
+    listOverlaySettingOverrides(input.appliedRaw ?? input.raw, input.embeddedRaw).map(
+      (entry) => `${entry.providerId}\0${entry.field}`
+    )
+  );
+  const reported = overrides.map(
+    (entry) => applied.has(`${entry.providerId}\0${entry.field}`) ? entry : { ...entry, ignored: true }
+  );
+  emitWarning(
+    "CFG-001",
+    { taskId: "provider-registry", subsystem: "config", executionPhase: "setup" },
+    {
+      severity: "WARN" /* WARN */,
+      message: formatOverlaySettingsWarning(input.path, reported),
+      metadata: {
+        operation: "providersYamlOverlaySettings",
+        path: input.path,
+        overrides: reported
+      }
+    }
+  );
+}
+
+// src/core/config/registry-project-selection.ts
+var PROJECT_SELECTION_MODEL_FIELDS = [
+  "default",
+  "default_reasoning_effort",
+  "judge_reasoning_effort",
+  "roles",
+  "mappings"
+];
+var PROJECT_SELECTION_PROVIDER_FIELDS = ["enabled", "order"];
+function pickSelectionModels(modelsValue) {
+  if (!isObject(modelsValue)) return void 0;
+  const models = {};
+  for (const field of PROJECT_SELECTION_MODEL_FIELDS) {
+    if (modelsValue[field] !== void 0) models[field] = modelsValue[field];
+  }
+  return models;
+}
+function pickProjectSelectionPolicy(projectedRaw, embeddedRaw) {
+  const embeddedProviders = isObject(embeddedRaw) ? embeddedRaw.providers : void 0;
+  const projectedProviders = isObject(projectedRaw) ? projectedRaw.providers : void 0;
+  const picked = {};
+  if (!isObject(embeddedProviders) || !isObject(projectedProviders)) return { providers: picked };
+  for (const [providerId, value] of Object.entries(projectedProviders)) {
+    if (!(providerId in embeddedProviders) || !isObject(value)) continue;
+    const provider = {};
+    for (const field of PROJECT_SELECTION_PROVIDER_FIELDS) {
+      if (value[field] !== void 0) provider[field] = value[field];
+    }
+    const models = pickSelectionModels(value.models);
+    if (models) provider.models = models;
+    picked[providerId] = provider;
+  }
+  return { providers: picked };
+}
+
+// src/core/config/user-model-entries.ts
+var MAX_REPORTED_ISSUES = 3;
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mergeUserModelEntries(userRaw, baseRaw, options) {
+  const ignored = [];
+  if (!isRecord(userRaw) || !isRecord(baseRaw)) return { overlay: userRaw, ignored };
+  const overlay = structuredClone(userRaw);
+  const userProviders = overlay.providers;
+  if (!isRecord(userProviders)) return { overlay, ignored };
+  const baseProviders = isRecord(baseRaw.providers) ? baseRaw.providers : {};
+  for (const [providerId, provider] of Object.entries(userProviders)) {
+    if (!isRecord(provider) || !isRecord(provider.models)) continue;
+    const userAvailable = provider.models.available;
+    if (!Array.isArray(userAvailable)) continue;
+    const baseProvider = baseProviders[providerId];
+    let baseAvailable = [];
+    if (isRecord(baseProvider)) {
+      if (!isRecord(baseProvider.models)) continue;
+      const declared = baseProvider.models.available;
+      if (!Array.isArray(declared)) continue;
+      baseAvailable = declared;
+    }
+    const availableById = /* @__PURE__ */ new Map();
+    for (const entry of baseAvailable) {
+      const key = isRecord(entry) && typeof entry.id === "string" ? entry.id : /* @__PURE__ */ Symbol("entry");
+      availableById.set(key, entry);
+    }
+    userAvailable.forEach((entry, index) => {
+      const id = isRecord(entry) && typeof entry.id === "string" ? entry.id : void 0;
+      if (!isRecord(entry) || id === void 0 || id.trim() === "") {
+        ignored.push({
+          providerId,
+          ...id?.trim() ? { modelId: id } : {},
+          index,
+          issues: ["the entry has no id"],
+          previousKept: false,
+          sourcePath: options.sourcePath
+        });
+        return;
+      }
+      const previous = availableById.get(id);
+      const candidate = isRecord(previous) ? mergeModelEntry(previous, entry) : entry;
+      const issues = options.validateEntry(candidate);
+      if (issues.length > 0) {
+        ignored.push({
+          providerId,
+          modelId: id,
+          index,
+          issues,
+          previousKept: previous !== void 0,
+          sourcePath: options.sourcePath
+        });
+        return;
+      }
+      availableById.set(id, candidate);
+    });
+    provider.models.available = [...availableById.values()];
+  }
+  return { overlay, ignored };
+}
+function describeIgnoredUserModelEntry(entry) {
+  const subject = entry.modelId !== void 0 ? `model entry "${entry.modelId}"` : `model entry ${entry.index + 1}`;
+  const shown = entry.issues.slice(0, MAX_REPORTED_ISSUES).join("; ");
+  const more = entry.issues.length > MAX_REPORTED_ISSUES ? ` (and ${entry.issues.length - MAX_REPORTED_ISSUES} more)` : "";
+  const outcome = entry.previousKept ? "The previous entry for this model is kept." : "The entry was left out of the model inventory.";
+  return `Ignored invalid ${subject} for provider "${entry.providerId}" in ${entry.sourcePath}: ${shown}${more}. ${outcome}`;
+}
+
+// src/core/config/provider-registry.ts
+function getUserProviderRegistryPaths(cwd = process.cwd()) {
+  let home = "";
+  try {
+    home = homedir3() ?? "";
+  } catch {
+    home = "";
+  }
+  if (!home) home = (process.env.HOME ?? process.env.USERPROFILE ?? "").trim();
+  const canonicalUserDir = getConfigPaths(cwd).userConfigDir;
+  const defaultUserDir = home ? join4(home, ".build", "config") : "";
+  return [
+    join4(canonicalUserDir, "providers.yaml"),
+    // ~/.config/build is the pre-default (XDG) registry location, kept as a
+    // compatibility fallback for the default layout only. An explicit
+    // BUILD_CONFIG_DIR/XDG root is authoritative and must not be contaminated
+    // by state from another user-config tree.
+    ...home && resolve5(canonicalUserDir) === resolve5(defaultUserDir) ? [join4(home, ".config", "build", "providers.yaml")] : []
+  ];
+}
+function getConfiguredProviderRegistryPaths(cwd = process.cwd()) {
+  const projectRoot = findProjectRoot(cwd) ?? cwd;
+  return [
+    ...getUserProviderRegistryPaths(projectRoot),
+    resolveProvidersConfigPath({ cwd: projectRoot }),
+    resolve5(projectRoot, ".build-project", "config", "provider-registry.yaml.v1.backup")
+  ];
+}
+function getProviderRegistryInputPaths(cwd = process.cwd()) {
+  const projectRoot = findProjectRoot(cwd) ?? cwd;
+  return [
+    ...getEmbeddedProviderConfigPaths(),
+    resolveSharedRefreshPaths().overlayPath,
+    resolve5(projectRoot, ".build-project", "cache", "model-update", "refresh-overlay.json"),
+    ...getConfiguredProviderRegistryPaths(projectRoot)
+  ];
+}
+var REMOVED_BUILTIN_PROVIDER_IDS = /* @__PURE__ */ new Set(["glm"]);
+var PROJECT_POLICY_PROVIDER_FIELDS = [
+  "enabled",
+  "order",
+  "concurrency_hint",
+  "concurrency",
+  "timeout_ms",
+  "health_check_timeout_ms",
+  "memory",
+  "env",
+  "retry",
+  "circuit_breaker",
+  "rate_limits",
+  "workspace_edits",
+  "generation",
+  "task_settings",
+  "options"
+];
+var PROJECT_TRUSTED_EXTENSION_FIELDS = [
+  "transport",
+  "api",
+  "auth",
+  "cli",
+  "exec",
+  "engine",
+  "route_id",
+  "route",
+  "allow_unsafe_binary",
+  "requires",
+  "requires_if"
+];
+var EXECUTION_SENSITIVE_PROVIDER_FIELDS = ["cli", "exec", "engine"];
+var CURSOR_ID_SYNTAX_ADMISSION_PATTERN = "^[a-z0-9][a-z0-9._-]{0,63}$";
+function normalizeProviderConfigId(providerId) {
+  const normalized = providerId.trim().toLowerCase();
+  if (normalized === "cursor-cli") return "cursor";
+  if (normalized === "copilot-cli") return "copilot";
+  if (normalized === "anti-gravity" || normalized === "antigravity-cli" || normalized === "agy") {
+    return "antigravity";
+  }
+  return normalized;
+}
+function dropRemovedBuiltinProviders(raw) {
+  if (!raw || typeof raw !== "object") return raw;
+  const providers = raw.providers;
+  if (!providers || typeof providers !== "object") return raw;
+  for (const providerId of REMOVED_BUILTIN_PROVIDER_IDS) {
+    delete providers[providerId];
+  }
+  return raw;
+}
+function ensureCursorIdSyntaxAdmissionPattern(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const providers = raw.providers;
+  if (!providers || typeof providers !== "object" || Array.isArray(providers)) return raw;
+  const cursor = providers.cursor;
+  if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) return raw;
+  const models = cursor.models;
+  if (!models || typeof models !== "object" || Array.isArray(models)) return raw;
+  const patterns = models.allowed_patterns;
+  if (!Array.isArray(patterns)) return raw;
+  if (!patterns.every((pattern) => typeof pattern === "string")) return raw;
+  if (patterns.includes(CURSOR_ID_SYNTAX_ADMISSION_PATTERN)) return raw;
+  models.allowed_patterns = [
+    ...patterns,
+    CURSOR_ID_SYNTAX_ADMISSION_PATTERN
+  ];
+  return raw;
+}
+function projectProjectRegistryPolicy(projectRaw, embeddedRaw, options) {
+  if (!projectRaw || typeof projectRaw !== "object" || Array.isArray(projectRaw)) {
+    return projectRaw;
+  }
+  const embeddedProvidersValue = embeddedRaw && typeof embeddedRaw === "object" && !Array.isArray(embeddedRaw) ? embeddedRaw.providers : null;
+  if (!embeddedProvidersValue || typeof embeddedProvidersValue !== "object" || Array.isArray(embeddedProvidersValue)) {
+    return projectRaw;
+  }
+  const projectProvidersValue = projectRaw.providers;
+  if (!projectProvidersValue || typeof projectProvidersValue !== "object" || Array.isArray(projectProvidersValue)) {
+    return projectRaw;
+  }
+  const embeddedProviders = embeddedProvidersValue;
+  const projectedProviders = {};
+  for (const [providerId, providerValue] of Object.entries(
+    projectProvidersValue
+  )) {
+    if (!(providerId in embeddedProviders)) {
+      projectedProviders[providerId] = providerValue;
+      continue;
+    }
+    if (!providerValue || typeof providerValue !== "object" || Array.isArray(providerValue)) {
+      projectedProviders[providerId] = providerValue;
+      continue;
+    }
+    const sourceProvider = providerValue;
+    const provider = {};
+    for (const field of PROJECT_POLICY_PROVIDER_FIELDS) {
+      if (sourceProvider[field] !== void 0) provider[field] = sourceProvider[field];
+    }
+    if (options.trusted) {
+      for (const field of PROJECT_TRUSTED_EXTENSION_FIELDS) {
+        if (sourceProvider[field] !== void 0) provider[field] = sourceProvider[field];
+      }
+    } else if (sourceProvider.api && typeof sourceProvider.api === "object" && !Array.isArray(sourceProvider.api)) {
+      const sourceApi = sourceProvider.api;
+      const api = {};
+      for (const field of [
+        "stream",
+        "max_tokens",
+        "max_tool_iterations",
+        "per_tool_timeout_ms"
+      ]) {
+        if (sourceApi[field] !== void 0) api[field] = sourceApi[field];
+      }
+      if (Object.keys(api).length > 0) provider.api = api;
+    }
+    const models = pickSelectionModels(sourceProvider.models);
+    if (models) provider.models = models;
+    projectedProviders[providerId] = provider;
+  }
+  return {
+    providers: projectedProviders
+  };
+}
+var RetryConfigSchema = z3.object({
+  max_attempts: z3.number().int().min(1).max(10),
+  initial_delay_ms: z3.number().int().min(0),
+  max_delay_ms: z3.number().int().min(0),
+  backoff_multiplier: z3.number().min(1)
+}).strict();
+var CircuitBreakerConfigSchema = z3.object({
+  failure_threshold: z3.number().int().min(1),
+  cooldown_ms: z3.number().int().min(0),
+  half_open_max_attempts: z3.number().int().min(1).optional()
+}).strict();
+var RateLimitEntrySchema = z3.object({
+  rpm: z3.number().int().min(1),
+  // Requests per minute
+  bucket_size: z3.number().int().min(1),
+  // Token bucket burst capacity
+  refill_rate: z3.number().min(0)
+  // Tokens per second
+}).strict();
+var RateLimitsConfigSchema = z3.object({
+  rpm: z3.number().int().min(1).optional(),
+  // Default RPM (convenience alias)
+  bucket_size: z3.number().int().min(1).optional(),
+  // Default bucket size
+  refill_rate: z3.number().min(0).optional(),
+  // Default refill rate
+  default: RateLimitEntrySchema.optional(),
+  // Explicit default config
+  models: z3.record(z3.string(), RateLimitEntrySchema).optional()
+  // Per-model overrides
+}).strict();
+var MemoryConfigSchema = z3.object({
+  warn_threshold: z3.number().min(0).max(1),
+  critical_threshold: z3.number().min(0).max(1),
+  emergency_threshold: z3.number().min(0).max(1),
+  max_processes: z3.number().int().min(1)
+}).strict();
+var PollingConfigSchema = z3.object({
+  initial_interval_ms: z3.number().int().min(0),
+  max_interval_ms: z3.number().int().min(0),
+  backoff_multiplier: z3.number().min(1),
+  timeout_ms: z3.number().int().min(0).optional(),
+  show_progress: z3.boolean()
+}).strict();
+var CLIConfigSchema = z3.object({
+  command: z3.string(),
+  binary: z3.string(),
+  install_command: z3.string().default(""),
+  // Installation metadata for setup automation
+  // - manual: show instructions only (no command execution)
+  // - curl: requires explicit opt-in via BUILD_ALLOW_CURL_BASH=1
+  install_method: z3.enum(["npm", "brew", "pipx", "curl", "manual"]).optional().default("manual"),
+  min_node_version: z3.string().optional(),
+  risk_level: z3.enum(["safe", "needs-confirmation"]).optional().default("safe"),
+  install_note: z3.string().optional()
+}).strict();
+var AuthConfigSchema = z3.object({
+  type: z3.enum(["cli_login", "api_key", "oauth", "cli_wrapper"]),
+  env_vars: z3.array(z3.string()),
+  skip_env_var: z3.string().optional(),
+  note: z3.string().optional()
+}).strict();
+var TemplatedAuthConfigSchema = AuthConfigSchema.default({
+  type: "cli_login",
+  env_vars: [],
+  skip_env_var: "BUILD_SKIP_AUTH"
+});
+var ProviderReleaseStatusSchema = z3.enum([
+  "primary_validated",
+  "supported_validated",
+  "supported_beta",
+  "experimental"
+]);
+var JsonScalarSchema = z3.union([z3.string(), z3.number(), z3.boolean(), z3.null()]);
+var ProbeExpectationSchema = z3.union([
+  JsonScalarSchema,
+  z3.object({
+    present: z3.boolean().optional(),
+    truthy: z3.boolean().optional(),
+    equals: JsonScalarSchema.optional()
+  }).strict()
+]);
+var CommandProbeSchema = z3.object({
+  command_argv: z3.array(z3.string()).min(1),
+  parse_as: z3.enum(["json", "exit_code"]).optional().default("json"),
+  json_path: z3.string().optional(),
+  expect: ProbeExpectationSchema.optional(),
+  timeout_ms: z3.number().int().min(1).optional()
+}).strict();
+var ModelsDiscoverySchema = z3.object({
+  command_argv: z3.array(z3.string()).min(1),
+  json_path: z3.string().optional().default("$"),
+  id_path: z3.string().optional().default("id"),
+  ttl_hours: z3.number().positive().optional().default(24),
+  timeout_ms: z3.number().int().min(1).optional()
+}).strict();
+var ModelAccessClassSchema = z3.enum(["first_party_pool", "premium_pool"]);
+var RegistryReasoningEffortSchema = z3.preprocess(
+  (value) => normalizeReasoningEffortInput(value) ?? value,
+  z3.enum(["low", "medium", "high", "xhigh", "max"])
+);
+var ModelAccessConfigSchema = z3.object({
+  default: ModelAccessClassSchema,
+  overrides: z3.record(z3.string().trim().min(1), ModelAccessClassSchema).default({})
+}).strict();
+var ModelsConfigSchema = z3.object({
+  default: z3.string().trim().min(1),
+  /** Retired: shipped providers.yaml sets none; user or repo copies still apply it. */
+  default_reasoning_effort: RegistryReasoningEffortSchema.optional(),
+  /** Effort for the judge_primary role; judges without it get no Build effort. */
+  judge_reasoning_effort: RegistryReasoningEffortSchema.optional(),
+  roles: z3.record(z3.string().trim().min(1), z3.string().trim().min(1)).optional().default({}),
+  allowed_patterns: z3.array(z3.string()),
+  mappings: z3.record(z3.string().trim().min(1), z3.string().trim().min(1)),
+  // Zod v4: explicit key and value schemas
+  /** Selectors the provider's own CLI resolves; see model-family-aliases.ts. */
+  family_aliases: z3.array(z3.string().trim().min(1)).optional().default([]),
+  /** Per backend, what a model with no route sends; see model-routes.ts. */
+  route_backends: RouteBackendModesSchema.optional(),
+  available: z3.array(ModelInfoSchema),
+  /** Ids the CLI reported on its last observed inventory; set only by a refresh overlay. */
+  observed_ids: z3.array(z3.string()).optional(),
+  /**
+   * Admission policy for the exact-model invoke bridge.
+   *
+   * A provider whose `allowed_patterns` deliberately admit bounded future model-id
+   * SYNTAX (so a newly released id works before the catalog is refreshed) accepts ids
+   * that are well-formed but not in `available`. That is correct for ordinary
+   * execution and wrong for an exact pin, where a typo should be rejected before
+   * spawn rather than handed to the CLI.
+   *
+   * Set this on such a provider to make the exact bridge additionally require the
+   * resolved id to be present in the effective inventory. Providers that do not admit
+   * syntax-only ids leave it false and keep their declared resolution contract.
+   *
+   * This is model-resolution admission policy, NOT a runtime CLI quirk, so it belongs
+   * here rather than behind `getProviderRuntimeQuirks()`.
+   */
+  exact_invoke_requires_inventory: z3.boolean().optional().default(false),
+  access: ModelAccessConfigSchema.optional(),
+  discovery: ModelsDiscoverySchema.optional()
+}).strict().superRefine((models, ctx) => {
+  if (!models.access) return;
+  const availableIds = new Set(models.available.map((model) => model.id));
+  for (const modelId of Object.keys(models.access.overrides)) {
+    if (!availableIds.has(modelId)) {
+      ctx.addIssue({
+        code: z3.ZodIssueCode.custom,
+        message: `models.access override references unavailable model: ${modelId}`,
+        path: ["access", "overrides", modelId]
+      });
+    }
+  }
+});
+function declaresFamilyAlias(aliases, model) {
+  if (!model || !aliases || aliases.length === 0) return false;
+  const candidate = normalizeModelSelectorForComparison(model);
+  if (candidate.length === 0) return false;
+  return aliases.some((alias) => normalizeModelSelectorForComparison(alias) === candidate);
+}
+var TemplatedModelsConfigSchema = z3.object({
+  default: z3.string().trim().min(1),
+  /** Retired; see `ModelsConfigSchema.default_reasoning_effort`. */
+  default_reasoning_effort: RegistryReasoningEffortSchema.optional(),
+  /** See `ModelsConfigSchema.judge_reasoning_effort`. */
+  judge_reasoning_effort: RegistryReasoningEffortSchema.optional(),
+  roles: z3.record(z3.string().trim().min(1), z3.string().trim().min(1)).optional().default({}),
+  allowed_patterns: z3.array(z3.string()).default([".*"]),
+  mappings: z3.record(z3.string().trim().min(1), z3.string().trim().min(1)).default({}),
+  /**
+   * See `ModelsConfigSchema.family_aliases`. Declared here too so the field is
+   * readable off the `ProviderConfig` union without narrowing to a branch first.
+   */
+  family_aliases: z3.array(z3.string().trim().min(1)).optional().default([]),
+  /** See `ModelsConfigSchema.route_backends`. */
+  route_backends: RouteBackendModesSchema.optional(),
+  available: z3.array(ModelInfoSchema).default([]),
+  /** See `ModelsConfigSchema.observed_ids`. */
+  observed_ids: z3.array(z3.string()).optional(),
+  /**
+   * See `ModelsConfigSchema.exact_invoke_requires_inventory`. Declared here too so the
+   * flag is readable off the `ProviderConfig` union without narrowing to the native
+   * branch first. It matters at least as much for templated providers, whose
+   * `allowed_patterns` default to `['.*']` and therefore admit any syntax.
+   */
+  exact_invoke_requires_inventory: z3.boolean().optional().default(false),
+  access: ModelAccessConfigSchema.optional(),
+  discovery: ModelsDiscoverySchema.optional()
+}).strict().superRefine((models, ctx) => {
+  if (!models.access) return;
+  const availableIds = new Set(models.available.map((model) => model.id));
+  for (const modelId of Object.keys(models.access.overrides)) {
+    if (!availableIds.has(modelId)) {
+      ctx.addIssue({
+        code: z3.ZodIssueCode.custom,
+        message: `models.access override references unavailable model: ${modelId}`,
+        path: ["access", "overrides", modelId]
+      });
+    }
+  }
+});
+var CapabilitiesConfigSchema = z3.object({
+  streaming: z3.boolean(),
+  tool_use: z3.boolean(),
+  vision: z3.boolean(),
+  function_calling: z3.boolean(),
+  // Provider has some historically tracked subagent-capable behavior.
+  sub_agents: z3.boolean().optional().default(false),
+  // Build can invoke provider-native subagents for `run --subagents`.
+  provider_native_subagents: z3.boolean().optional().default(false),
+  // Provider-level execution capabilities (narrow matrix — model-level traits are out of scope)
+  // requires_pty: provider CLI needs a PTY for headless runs
+  requires_pty: z3.boolean().optional(),
+  // owns_rate_limit_token: provider enforces its own rate limit / handles 429 internally
+  owns_rate_limit_token: z3.boolean().optional(),
+  // supports_api_judge: provider has a non-CLI API channel usable by the judge/synthesis path
+  supports_api_judge: z3.boolean().optional(),
+  // supports_ask_consult: provider has a tested read-only one-shot consultation path
+  supports_ask_consult: z3.boolean().optional(),
+  // supports_decomposition_tools_profile: adapter implements decomposition-search-only
+  supports_decomposition_tools_profile: z3.boolean().optional(),
+  // requires_sandbox_interlock: provider must verify outer sandbox before spawning
+  requires_sandbox_interlock: z3.boolean().optional(),
+  // native_model_fallback: provider CLI supports a native fallback-model flag
+  // (e.g. Claude's --fallback-model). Gates role-candidate `fallbackModelRole`.
+  native_model_fallback: z3.boolean().optional(),
+  // supports_bounded_edit_allowlist: permissionMode 'dontAsk' plus allowedTools is a
+  // bounded edit allowlist for edit turns (denies unlisted tools instead of failing mid-run).
+  supports_bounded_edit_allowlist: z3.boolean().optional(),
+  // supports_inherited_boundary_read_only: the provider's native read-only posture holds
+  // inside an outer host sandbox Build cannot nest into: it needs no Seatbelt of its own
+  // and exposes no shell tool (or only a read-only shell), so read-only needs no kernel profile.
+  supports_inherited_boundary_read_only: z3.boolean().optional()
+}).strict();
+var TemplatedCapabilitiesConfigSchema = z3.object({
+  streaming: z3.boolean().default(false),
+  tool_use: z3.boolean().default(false),
+  vision: z3.boolean().default(false),
+  function_calling: z3.boolean().default(false),
+  // Provider has some historically tracked subagent-capable behavior.
+  sub_agents: z3.boolean().default(false),
+  // Build can invoke provider-native subagents for `run --subagents`.
+  provider_native_subagents: z3.boolean().default(false),
+  // Provider-level execution capabilities (narrow matrix — model-level traits are out of scope)
+  requires_pty: z3.boolean().optional(),
+  owns_rate_limit_token: z3.boolean().optional(),
+  supports_api_judge: z3.boolean().optional(),
+  supports_ask_consult: z3.boolean().optional(),
+  supports_decomposition_tools_profile: z3.boolean().optional(),
+  requires_sandbox_interlock: z3.boolean().optional(),
+  native_model_fallback: z3.boolean().optional(),
+  supports_bounded_edit_allowlist: z3.boolean().optional(),
+  supports_inherited_boundary_read_only: z3.boolean().optional()
+}).strict().default({
+  streaming: false,
+  tool_use: false,
+  vision: false,
+  function_calling: false,
+  sub_agents: false,
+  provider_native_subagents: false
+});
+var BotIdentityConfigSchema = z3.object({
+  display_name: z3.string(),
+  usernames: z3.array(z3.string())
+}).strict();
+var EnvConfigSchema = z3.record(z3.string(), z3.string());
+var RefreshStrategyConfigSchema = z3.discriminatedUnion("kind", [
+  z3.object({
+    kind: z3.literal("direct"),
+    // Deterministic models API to poll; absent = doc-poll only (e.g. xAI).
+    models_api: z3.enum(["anthropic", "openai", "google"]).optional(),
+    doc_poll: z3.boolean(),
+    cli_inventory: z3.enum(["cursor", "grok", "codex"]).optional()
+  }).strict(),
+  z3.object({ kind: z3.literal("aggregator") }).strict(),
+  z3.object({
+    kind: z3.literal("static"),
+    reason: z3.string().trim().min(1).optional(),
+    cli_inventory: z3.enum(["cursor", "grok", "codex"]).optional()
+  }).strict()
+]);
+var DefaultPricingSchema = z3.object({
+  billing_mode: z3.string(),
+  currency: z3.string(),
+  unit: z3.string()
+}).strict();
+var ConcurrencyConfigSchema = z3.object({
+  max: z3.number().int().min(1),
+  hybrid_batching: z3.boolean().optional().default(false),
+  rationale: z3.string().trim().min(1)
+}).strict();
+var RouteConfigSchema = z3.object({
+  // Environment variables to inject (e.g., API keys, endpoints)
+  env: z3.record(z3.string(), z3.string()).optional(),
+  // Auth commands to run before execution.
+  //
+  // SECURITY: Prefer argv form (auth_check_argv/auth_command_argv). String form is
+  // treated as guidance-only and is not executed by Build.
+  auth_check: z3.string().optional(),
+  auth_command: z3.string().optional(),
+  auth_clear: z3.string().optional(),
+  auth_check_argv: z3.array(z3.string()).optional(),
+  auth_command_argv: z3.array(z3.string()).optional(),
+  auth_clear_argv: z3.array(z3.string()).optional(),
+  auth_probe: CommandProbeSchema.optional(),
+  // Model ID transform function name (if custom logic needed)
+  model_transform: z3.string().optional()
+}).strict();
+var WorkspaceEditsConfigSchema = z3.object({
+  // Detection mode: 'passthrough' (git-only), 'structured' (JSONL), or 'text-only' (analysis mode)
+  mode: z3.enum(["passthrough", "structured", "text-only"]),
+  // Whether to inject JSONL format instructions into prompts
+  inject_jsonl: z3.boolean().optional(),
+  // Whether to enforce FILE: specification in prompts
+  enforce_file_targets: z3.boolean().optional()
+}).strict();
+var GenerationConfigSchema = z3.object({
+  // Temperature controls output randomness (0.0 = deterministic, 1.0+ = creative)
+  // For code generation, 0.2-0.4 is recommended for more deterministic output
+  temperature: z3.number().min(0).max(2).optional(),
+  // Nucleus sampling threshold (0.0-1.0)
+  top_p: z3.number().min(0).max(1).optional(),
+  // Top-k sampling (limits token choices)
+  top_k: z3.number().int().min(1).optional(),
+  // Maximum output tokens
+  max_output_tokens: z3.number().int().min(1).optional()
+}).strict();
+var TaskSettingsSchema = z3.record(
+  z3.string(),
+  z3.object({
+    temperature: z3.number().min(0).max(2).optional(),
+    top_p: z3.number().min(0).max(1).optional(),
+    top_k: z3.number().int().min(1).optional(),
+    /** Retired and ignored: Build never picks effort from the task type. */
+    reasoning_effort: z3.preprocess((value) => {
+      if (value === void 0 || value === null) return void 0;
+      const normalized = normalizeReasoningEffortInput(value);
+      return normalized ?? value;
+    }, z3.enum(["low", "medium", "high", "xhigh", "max"]).optional()),
+    thinking_budget: z3.number().int().min(1).optional()
+  }).strict()
+).optional();
+var RequirementSchema = z3.union([
+  z3.object({ provider: z3.string() }).strict(),
+  z3.object({ plugin: z3.string() }).strict(),
+  z3.object({ binary: z3.string() }).strict()
+]);
+var ProviderOptionSchema = z3.object({
+  // Option type
+  type: z3.enum(["enum", "string", "bool"]),
+  // Allowed values (for enum type)
+  allowed: z3.array(z3.string()).optional(),
+  // Default value
+  default: z3.union([z3.string(), z3.boolean()]),
+  // Description (shown in wizard)
+  description: z3.string()
+}).strict();
+var ProviderOptionsSchema = z3.record(z3.string(), ProviderOptionSchema);
+var ConditionalRequiresSchema = z3.record(z3.string(), z3.array(RequirementSchema));
+var ProviderRequiresSchema = z3.object({
+  // Always-required dependencies
+  requires: z3.array(RequirementSchema).optional(),
+  // Conditionally-required dependencies based on option values
+  requires_if: ConditionalRequiresSchema.optional()
+}).strict();
+var ApiConfigSchema = z3.object({
+  /** API base URL (host only, e.g., "https://api.anthropic.com"). */
+  base_url: z3.url(),
+  /** Environment variable name containing the API key. */
+  api_key_env_var: z3.string(),
+  /** Whether to use streaming responses (default: true). */
+  stream: z3.boolean().optional().default(true),
+  /** Additional HTTP headers to send with requests. */
+  headers: z3.record(z3.string(), z3.string()).optional(),
+  /** Max output tokens per API call. */
+  max_tokens: z3.number().int().positive().optional(),
+  /** Max tool-use iterations in the agentic loop (default: 50). */
+  max_tool_iterations: z3.number().int().min(1).max(200).optional().default(50),
+  /** Timeout per individual tool execution in ms (default: 30000). */
+  per_tool_timeout_ms: z3.number().int().min(1e3).optional().default(3e4)
+}).strict().optional();
+var TemplatedCLIExecutionSchema = z3.object({
+  // Base command arguments (before prompt)
+  args: z3.array(z3.string()),
+  // Command-line flags (e.g., {"--quiet": true, "--cwd": "{{workspace}}"})
+  flags: z3.record(z3.string(), z3.union([z3.boolean(), z3.string()])).optional(),
+  // Prompt placement: 'positional' (in args array) or 'stdin'
+  prompt_placement: z3.enum(["positional", "stdin"]),
+  // Whether to add "--" before the prompt when using positional prompt placement.
+  // Defaults to true (safer); set false for CLIs that don't support "--".
+  double_dash_before_prompt: z3.boolean().optional(),
+  // Whether stdin is supported as fallback
+  stdin_fallback: z3.boolean().optional(),
+  // Template variables available for interpolation
+  // (e.g., {{prompt}}, {{model.routing_id}}, {{workspace}})
+  template_vars: z3.array(z3.string()).optional()
+}).strict();
+var NativeProviderConfigSchema = z3.object({
+  // Basic metadata
+  id: z3.string(),
+  name: z3.string(),
+  display_name: z3.string(),
+  description: z3.string(),
+  vendor: z3.string(),
+  enabled: z3.boolean(),
+  experimental: z3.boolean(),
+  release_status: ProviderReleaseStatusSchema.optional(),
+  order: z3.number().int(),
+  // Provider type and transport
+  type: z3.enum(["cli", "api", "cloud_cli", "cli_wrapper"]),
+  transport: z3.enum(["cli", "api", "hybrid"]),
+  channels: z3.array(z3.string()),
+  // CLI configuration
+  cli: CLIConfigSchema,
+  // API transport configuration (optional, for direct API inference)
+  api: ApiConfigSchema,
+  // Authentication
+  auth: AuthConfigSchema,
+  // Models
+  models: ModelsConfigSchema,
+  // Capabilities
+  capabilities: CapabilitiesConfigSchema,
+  // Performance
+  concurrency_hint: z3.enum(["low", "medium", "high"]),
+  concurrency: ConcurrencyConfigSchema.optional(),
+  // Timeouts
+  timeout_ms: z3.number().int().min(1),
+  health_check_timeout_ms: z3.number().int().min(1).optional(),
+  // Legacy memory metadata (accepted but not consumed; Memory Guardian owns its profiles)
+  memory: MemoryConfigSchema.optional(),
+  // Legacy polling metadata (accepted but not consumed)
+  polling: PollingConfigSchema.optional(),
+  // Legacy bot identity metadata (accepted but not consumed)
+  bot_identity: BotIdentityConfigSchema.optional(),
+  // Environment variables
+  env: EnvConfigSchema,
+  // Legacy retry and circuit breaker metadata (accepted but not consumed; the provider
+  // retry wrapper and circuit breaker registry own their runtime defaults)
+  retry: RetryConfigSchema.optional(),
+  circuit_breaker: CircuitBreakerConfigSchema.optional(),
+  // Rate limits (optional overrides, new in v2.1)
+  rate_limits: RateLimitsConfigSchema.optional(),
+  // Pricing (optional, new in v2.0)
+  pricing: ProviderPricingSchema.optional(),
+  // Refresh strategy for `build provider refresh` (optional; providers
+  // without a declaration are treated as static by the refresh dispatcher).
+  refresh_strategy: RefreshStrategyConfigSchema.optional(),
+  // Engine type. 'templated_cli' is DEPRECATED: the templated CLI engine was
+  // removed (2026-06) and providers declaring it are no longer registered —
+  // the registry emits a TMPL-001 warning instead. The value stays in the
+  // schema only so legacy user overlays still validate and reach that
+  // warning rather than failing on an unknown enum value.
+  engine: z3.enum(["native", "templated_cli"]).optional().default("native"),
+  // Templated CLI execution config (deprecated with engine=templated_cli)
+  exec: TemplatedCLIExecutionSchema.optional(),
+  // Route configuration (for model ID transforms and env injection)
+  route_id: z3.string().optional(),
+  // Reference to a named route; unrelated to a model row's `routes`
+  route: RouteConfigSchema.optional(),
+  // Inline route override
+  // Workspace edit detection strategy
+  workspace_edits: WorkspaceEditsConfigSchema.optional(),
+  // Generation parameters (temperature, topP, etc.)
+  generation: GenerationConfigSchema.optional(),
+  // Task-type-aware generation settings (overrides generation defaults)
+  task_settings: TaskSettingsSchema,
+  // Binary allowlist for security (only used if engine=templated_cli)
+  allow_unsafe_binary: z3.boolean().optional().default(false),
+  // Explicit opt-in for non-allowlisted binaries
+  // Provider options (generic, any provider)
+  options: ProviderOptionsSchema.optional(),
+  // Dependency management (generic, any provider)
+  requires: z3.array(RequirementSchema).optional(),
+  requires_if: ConditionalRequiresSchema.optional()
+}).strict();
+var TemplatedProviderConfigSchema = z3.object({
+  // Basic metadata
+  id: z3.string(),
+  name: z3.string(),
+  display_name: z3.string().optional().default(""),
+  description: z3.string().optional().default(""),
+  vendor: z3.string().optional().default("custom"),
+  enabled: z3.boolean().optional().default(true),
+  experimental: z3.boolean().optional().default(false),
+  release_status: ProviderReleaseStatusSchema.optional(),
+  order: z3.number().int().optional().default(99),
+  // Provider type and transport
+  type: z3.enum(["cli", "api", "cloud_cli", "cli_wrapper"]).optional().default("cli_wrapper"),
+  transport: z3.enum(["cli", "api", "hybrid"]).optional().default("cli"),
+  channels: z3.array(z3.string()).optional().default(["cli"]),
+  // CLI configuration
+  cli: CLIConfigSchema,
+  // API transport configuration (optional, for direct API inference)
+  api: ApiConfigSchema,
+  // Authentication
+  auth: TemplatedAuthConfigSchema,
+  // Models
+  models: TemplatedModelsConfigSchema,
+  // Capabilities
+  capabilities: TemplatedCapabilitiesConfigSchema,
+  // Performance
+  concurrency_hint: z3.enum(["low", "medium", "high"]).optional().default("low"),
+  concurrency: ConcurrencyConfigSchema.optional(),
+  // Timeouts
+  timeout_ms: z3.number().int().min(1).optional().default(6e5),
+  health_check_timeout_ms: z3.number().int().min(1).optional(),
+  // Legacy memory metadata (accepted but not consumed; Memory Guardian owns its profiles)
+  memory: MemoryConfigSchema.optional(),
+  // Legacy polling metadata (accepted but not consumed)
+  polling: PollingConfigSchema.optional(),
+  // Legacy bot identity metadata (accepted but not consumed)
+  bot_identity: BotIdentityConfigSchema.optional(),
+  // Environment variables
+  env: EnvConfigSchema.default({}),
+  // Legacy retry and circuit breaker metadata (accepted but not consumed; the provider
+  // retry wrapper and circuit breaker registry own their runtime defaults)
+  retry: RetryConfigSchema.optional(),
+  circuit_breaker: CircuitBreakerConfigSchema.optional(),
+  // Rate limits (optional overrides)
+  rate_limits: RateLimitsConfigSchema.optional(),
+  // Pricing (optional)
+  pricing: ProviderPricingSchema.optional(),
+  // Engine selection (templated)
+  engine: z3.literal("templated_cli"),
+  // Templated CLI execution config (required)
+  exec: TemplatedCLIExecutionSchema,
+  // Route configuration (optional)
+  route_id: z3.string().optional(),
+  route: RouteConfigSchema.optional(),
+  // Workspace edit detection strategy (optional)
+  workspace_edits: WorkspaceEditsConfigSchema.optional(),
+  // Generation parameters (temperature, topP, etc.)
+  generation: GenerationConfigSchema.optional(),
+  // Task-type-aware generation settings (overrides generation defaults)
+  task_settings: TaskSettingsSchema,
+  // Binary allowlist override
+  allow_unsafe_binary: z3.boolean().optional().default(false),
+  // Provider options (generic, any provider)
+  options: ProviderOptionsSchema.optional(),
+  // Dependency management (generic, any provider)
+  requires: z3.array(RequirementSchema).optional(),
+  requires_if: ConditionalRequiresSchema.optional()
+}).strict().transform((provider) => ({
+  ...provider,
+  display_name: provider.display_name?.trim() ? provider.display_name : provider.name,
+  description: provider.description ?? ""
+}));
+var ProviderConfigSchema = z3.union([
+  TemplatedProviderConfigSchema,
+  NativeProviderConfigSchema
+]);
+var DefaultsConfigSchema = z3.object({
+  timeout_ms: z3.number().int().min(1),
+  // Legacy retry, circuit breaker and memory metadata (accepted but not consumed)
+  retry: RetryConfigSchema.optional(),
+  circuit_breaker: CircuitBreakerConfigSchema.optional(),
+  rate_limits: RateLimitsConfigSchema.optional(),
+  memory: MemoryConfigSchema.optional(),
+  polling: PollingConfigSchema.optional(),
+  pricing: DefaultPricingSchema.optional()
+}).strict();
+var MetadataConfigSchema = z3.object({
+  schema_version: z3.string(),
+  generated_at: DateLikeStringSchema,
+  description: z3.string(),
+  documentation: z3.string(),
+  migration_notes: z3.string().optional(),
+  last_updated: DateLikeStringSchema.optional()
+}).strict();
+var ProviderRegistryConfigSchema = z3.object({
+  version: z3.string(),
+  defaults: DefaultsConfigSchema,
+  guidance_profiles: z3.record(z3.string(), z3.unknown()).optional(),
+  judge: z3.record(z3.string(), z3.unknown()).optional(),
+  providers: z3.record(z3.string(), ProviderConfigSchema),
+  metadata: MetadataConfigSchema
+}).strict();
+var UNKNOWN_JUDGE_CAPABILITIES = {
+  canJudge: false,
+  canArbitrate: false
+};
+var PROVIDER_FAMILY_METADATA = {
+  claude: {
+    family: "anthropic",
+    judge: {
+      canJudge: true,
+      canArbitrate: true
+    }
+  },
+  codex: {
+    family: "openai",
+    judge: {
+      canJudge: true,
+      canArbitrate: true
+    }
+  },
+  cursor: {
+    family: "cursor",
+    judge: {
+      canJudge: true,
+      canArbitrate: false
+    }
+  },
+  grok: {
+    family: "xai",
+    judge: {
+      canJudge: true,
+      canArbitrate: true
+    }
+  },
+  opencode: {
+    family: "opencode",
+    judge: {
+      canJudge: true,
+      canArbitrate: false
+    }
+  },
+  antigravity: {
+    family: "antigravity",
+    judge: {
+      canJudge: true,
+      canArbitrate: false
+    }
+  },
+  copilot: {
+    family: "github",
+    judge: {
+      canJudge: true,
+      canArbitrate: true
+    }
+  },
+  kiro: {
+    family: "aws",
+    judge: {
+      canJudge: true,
+      canArbitrate: false
+    }
+  },
+  gemini: {
+    family: "google",
+    judge: {
+      canJudge: true,
+      canArbitrate: true
+    }
+  },
+  pi: {
+    family: "earendil",
+    judge: {
+      canJudge: true,
+      canArbitrate: false
+    }
+  }
+};
+function lookupProviderFamilyMetadata(providerId) {
+  return PROVIDER_FAMILY_METADATA[normalizeProviderConfigId(providerId)];
+}
+function getProviderFamily(providerId, registryOverride) {
+  const listed = lookupProviderFamilyMetadata(providerId);
+  if (listed) return listed.family;
+  try {
+    const vendor = ProviderRegistry.getProviderConfig(providerId, registryOverride).vendor;
+    const trimmed = vendor.trim();
+    if (trimmed) return trimmed;
+  } catch {
+  }
+  return normalizeProviderConfigId(providerId);
+}
+function getJudgeCapabilities(providerId) {
+  return lookupProviderFamilyMetadata(providerId)?.judge ?? UNKNOWN_JUDGE_CAPABILITIES;
+}
+function listModelEntryIssues(entry) {
+  const result = ModelInfoSchema.safeParse(entry);
+  if (result.success) return [];
+  return result.error.issues.map(
+    (issue) => `${issue.path.length > 0 ? issue.path.join(".") : "entry"}: ${issue.message}`
+  );
+}
+function cloneProviderRegistryValue(value) {
+  return structuredClone(value);
+}
+function verifySchemaDefinitions() {
+  const schemas = {
+    RetryConfigSchema,
+    CircuitBreakerConfigSchema,
+    MemoryConfigSchema,
+    PollingConfigSchema,
+    CLIConfigSchema,
+    AuthConfigSchema,
+    ModelInfoSchema,
+    ModelsConfigSchema,
+    CapabilitiesConfigSchema,
+    BotIdentityConfigSchema,
+    EnvConfigSchema,
+    ModelPricingSchema,
+    ToolPricingSchema,
+    SubscriptionPricingSchema,
+    InfrastructurePricingSchema,
+    ProviderPricingSchema,
+    DefaultPricingSchema,
+    RequirementSchema,
+    ProviderOptionSchema,
+    ProviderOptionsSchema,
+    ConditionalRequiresSchema,
+    ProviderRequiresSchema,
+    ProviderConfigSchema,
+    DefaultsConfigSchema,
+    MetadataConfigSchema,
+    ProviderRegistryConfigSchema
+  };
+  for (const [name, schema] of Object.entries(schemas)) {
+    if (!schema || !("_zod" in schema)) {
+      throw new Error(
+        `Schema ${name} is undefined or invalid. This indicates a schema definition error. Check that all nested schemas in ${name} are properly defined. Common issue: Zod v4 requires z.record(keySchema, valueSchema) with explicit parameters.`
+      );
+    }
+  }
+}
+verifySchemaDefinitions();
+var ProviderRegistry = class _ProviderRegistry {
+  static instance = null;
+  static configPath = null;
+  static configSources = [];
+  static ignoredUserModelEntries = [];
+  static cacheKey = null;
+  static cacheMode = null;
+  static cacheProjectRoot = null;
+  constructor() {
+  }
+  static replaceCachedRegistry(config, configPath, cacheKey, cacheMode, projectRoot, configSources = [configPath], ignoredUserModelEntries = []) {
+    const replacedExistingCache = _ProviderRegistry.instance !== null && (_ProviderRegistry.configPath !== configPath || _ProviderRegistry.cacheKey !== cacheKey || _ProviderRegistry.cacheMode !== cacheMode);
+    _ProviderRegistry.instance = config;
+    _ProviderRegistry.configPath = configPath;
+    _ProviderRegistry.configSources = [...configSources];
+    _ProviderRegistry.ignoredUserModelEntries = [...ignoredUserModelEntries];
+    _ProviderRegistry.cacheKey = cacheKey;
+    _ProviderRegistry.cacheMode = cacheMode;
+    _ProviderRegistry.cacheProjectRoot = projectRoot;
+    if (replacedExistingCache) {
+      runProviderRegistryReloadInvalidators();
+    }
+    return config;
+  }
+  /**
+   * Load the unified provider registry from YAML
+   *
+   * @param configPath - Path to providers.yaml (defaults to .build-project/config/providers.yaml)
+   * @returns Validated and merged configuration
+   */
+  static load(configPath, cwd = process.cwd(), rootOptions = {}) {
+    const projectRoot = findProjectRoot(cwd, rootOptions) ?? cwd;
+    configPath = configPath ? resolve5(projectRoot, configPath) : void 0;
+    const envCacheKey = _ProviderRegistry.buildEnvOverrideCacheKey();
+    const requestedCacheKey = _ProviderRegistry.buildCacheKey(configPath, envCacheKey, projectRoot);
+    if (_ProviderRegistry.instance && (_ProviderRegistry.cacheKey === requestedCacheKey || !configPath && _ProviderRegistry.cacheMode === "explicit" && _ProviderRegistry.configPath !== null && _ProviderRegistry.canReuseExplicitCacheForImplicit(
+      _ProviderRegistry.configPath,
+      projectRoot
+    ) && _ProviderRegistry.cacheKey === _ProviderRegistry.buildCacheKey(_ProviderRegistry.configPath, envCacheKey, projectRoot))) {
+      return _ProviderRegistry.instance;
+    }
+    const embeddedConfigPaths = getEmbeddedProviderConfigPaths();
+    const isTrustedProjectForProviderOverrides = () => isTrustedProjectRoot(projectRoot);
+    const projectTrustInstruction = formatProjectTrustInstruction(projectRoot);
+    const loadYamlRawIfExists = (filePath) => {
+      if (!existsSync5(filePath)) return null;
+      try {
+        const rawYaml = readFileSync8(filePath, "utf-8");
+        return yaml.load(rawYaml);
+      } catch (error) {
+        throw new Error(
+          `Failed to load YAML at ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    };
+    const loadEmbeddedRaw = () => {
+      for (const embeddedConfigPath of embeddedConfigPaths) {
+        if (!existsSync5(embeddedConfigPath)) continue;
+        try {
+          const bytes = readFileSync8(embeddedConfigPath);
+          let sourceBaseDrift;
+          if (isPackagedCatalogPath(embeddedConfigPath)) {
+            const digest2 = createHash5("sha256").update(bytes).digest("hex");
+            if (digest2 !== PROVIDER_CATALOG_SHA256) {
+              throw new Error(
+                `Provider catalog digest mismatch: expected ${PROVIDER_CATALOG_SHA256}, received ${digest2}`
+              );
+            }
+          } else {
+            sourceBaseDrift = resolveSourceBaseDrift(embeddedConfigPath, bytes);
+            if (sourceBaseDrift) {
+              debugLog(
+                `Provider source YAML ${embeddedConfigPath} does not match the compiled source digest (expected ${sourceBaseDrift.expectedDigest}, received ${sourceBaseDrift.actualDigest}); run the provider generator`
+              );
+            }
+          }
+          const raw = yaml.load(bytes.toString("utf8"));
+          if (!raw) continue;
+          return { path: embeddedConfigPath, raw, sourceBaseDrift };
+        } catch (error) {
+          throw new Error(
+            `Failed to load packaged provider catalog at ${embeddedConfigPath}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      return null;
+    };
+    const deepMerge = (base, overlay) => {
+      if (!overlay || typeof overlay !== "object") return base;
+      if (!base || typeof base !== "object") return overlay;
+      const baseObj = base;
+      const overlayObj = overlay;
+      const out = { ...baseObj };
+      for (const [key, overlayValue] of Object.entries(overlayObj)) {
+        const baseValue = baseObj[key];
+        if (key === "providers" && overlayValue && typeof overlayValue === "object" && !Array.isArray(overlayValue)) {
+          const existingProviders = baseValue && typeof baseValue === "object" && !Array.isArray(baseValue) ? baseValue : {};
+          const overlayProviders = overlayValue;
+          const mergedProviders = { ...existingProviders };
+          for (const [providerId, providerOverlay] of Object.entries(overlayProviders)) {
+            const existingProvider = existingProviders[providerId];
+            if (existingProvider && typeof existingProvider === "object" && !Array.isArray(existingProvider) && providerOverlay && typeof providerOverlay === "object" && !Array.isArray(providerOverlay)) {
+              mergedProviders[providerId] = deepMerge(existingProvider, providerOverlay);
+            } else {
+              mergedProviders[providerId] = providerOverlay;
+            }
+          }
+          out.providers = mergedProviders;
+          continue;
+        }
+        if (overlayValue && typeof overlayValue === "object" && !Array.isArray(overlayValue) && !(overlayValue instanceof Date) && baseValue && typeof baseValue === "object" && !Array.isArray(baseValue) && !(baseValue instanceof Date)) {
+          out[key] = deepMerge(baseValue, overlayValue);
+          continue;
+        }
+        out[key] = overlayValue;
+      }
+      return out;
+    };
+    const isFullRegistrySnapshot = (raw, base) => {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return false;
+      if (!base || typeof base !== "object" || Array.isArray(base)) return false;
+      const rawObject = raw;
+      const baseObject = base;
+      const rawProviders = rawObject.providers;
+      const baseProviders = baseObject.providers;
+      if (!rawProviders || typeof rawProviders !== "object" || Array.isArray(rawProviders) || !baseProviders || typeof baseProviders !== "object" || Array.isArray(baseProviders)) {
+        return false;
+      }
+      return "version" in rawObject && "defaults" in rawObject && "metadata" in rawObject && Object.keys(rawProviders).length > 0;
+    };
+    const migrateLegacyFullSnapshotOverlay = (raw, base) => {
+      if (!isFullRegistrySnapshot(raw, base)) return raw;
+      const migrated = cloneProviderRegistryValue(raw);
+      const migratedProviders = migrated.providers;
+      const baseProviders = base.providers;
+      for (const [providerId, providerValue] of Object.entries(migratedProviders)) {
+        const baseProviderValue = baseProviders[providerId];
+        if (!baseProviderValue || typeof baseProviderValue !== "object" || Array.isArray(baseProviderValue)) {
+          continue;
+        }
+        if (!providerValue || typeof providerValue !== "object" || Array.isArray(providerValue)) {
+          continue;
+        }
+        const provider = providerValue;
+        const modelsValue = provider.models;
+        const baseModelsValue = baseProviderValue.models;
+        if (!modelsValue || typeof modelsValue !== "object" || Array.isArray(modelsValue)) {
+          continue;
+        }
+        if (!baseModelsValue || typeof baseModelsValue !== "object" || Array.isArray(baseModelsValue)) {
+          continue;
+        }
+        const models = modelsValue;
+        const baseModels = baseModelsValue;
+        if (Array.isArray(baseModels.allowed_patterns) && Array.isArray(models.allowed_patterns) && [...baseModels.allowed_patterns, ...models.allowed_patterns].every(
+          (pattern) => typeof pattern === "string"
+        )) {
+          models.allowed_patterns = [
+            .../* @__PURE__ */ new Set([...baseModels.allowed_patterns, ...models.allowed_patterns])
+          ];
+        }
+        for (const key of ["mappings", "roles"]) {
+          const baseRecord = baseModels[key];
+          const overlayRecord = models[key];
+          if (baseRecord && typeof baseRecord === "object" && !Array.isArray(baseRecord) && overlayRecord && typeof overlayRecord === "object" && !Array.isArray(overlayRecord)) {
+            models[key] = {
+              ...baseRecord,
+              ...overlayRecord
+            };
+          }
+        }
+      }
+      return migrated;
+    };
+    const getRawProvider = (raw, providerId) => {
+      if (!raw || typeof raw !== "object") return void 0;
+      const providers = raw.providers;
+      if (!providers || typeof providers !== "object") return void 0;
+      return providers[providerId];
+    };
+    const stableJson = (value) => {
+      if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableJson(entry)).join(",")}]`;
+      }
+      if (value && typeof value === "object") {
+        return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+      }
+      return JSON.stringify(value);
+    };
+    const normalizeProviderForTrustComparison = (providerId, provider) => {
+      try {
+        return ProviderConfigSchema.parse(provider);
+      } catch (error) {
+        debugLog(
+          `[provider-registry] Failed to normalize provider "${providerId}" for trust comparison`,
+          error instanceof Error ? error.message : String(error)
+        );
+        return provider;
+      }
+    };
+    const listUntrustedExecutionFieldChanges = (raw, trustedRaw) => {
+      if (!raw || typeof raw !== "object") return [];
+      const providers = raw.providers;
+      if (!providers || typeof providers !== "object" || Array.isArray(providers)) return [];
+      const changes = [];
+      for (const [providerId, candidate] of Object.entries(providers)) {
+        if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) continue;
+        const candidateProvider = candidate;
+        const trusted = getRawProvider(trustedRaw, providerId);
+        const trustedProvider = trusted && typeof trusted === "object" && !Array.isArray(trusted) ? trusted : null;
+        if (!trustedProvider) {
+          const declaredFields = EXECUTION_SENSITIVE_PROVIDER_FIELDS.filter(
+            (field) => candidateProvider[field] !== void 0
+          );
+          if (declaredFields.length > 0) {
+            changes.push({ providerId, fields: [...declaredFields] });
+          }
+          continue;
+        }
+        const effective = normalizeProviderForTrustComparison(
+          providerId,
+          deepMerge(trustedProvider, candidateProvider)
+        );
+        const baseline = normalizeProviderForTrustComparison(providerId, trustedProvider);
+        const changedFields = EXECUTION_SENSITIVE_PROVIDER_FIELDS.filter((field) => {
+          if (candidateProvider[field] === void 0) return false;
+          return stableJson(effective?.[field]) !== stableJson(baseline?.[field]);
+        });
+        if (changedFields.length > 0) {
+          changes.push({ providerId, fields: [...changedFields] });
+        }
+      }
+      return changes;
+    };
+    const listUntrustedApiIdentityChanges = (projectRaw, effectiveRaw, trustedRaw) => {
+      if (!projectRaw || typeof projectRaw !== "object" || Array.isArray(projectRaw)) return [];
+      const projectProviders = projectRaw.providers;
+      if (!projectProviders || typeof projectProviders !== "object" || Array.isArray(projectProviders)) {
+        return [];
+      }
+      const changes = [];
+      for (const [providerId, projectValue] of Object.entries(
+        projectProviders
+      )) {
+        if (!projectValue || typeof projectValue !== "object" || Array.isArray(projectValue)) {
+          continue;
+        }
+        const projectProvider = projectValue;
+        const effectiveProviderValue = getRawProvider(effectiveRaw, providerId);
+        const trustedProviderValue = getRawProvider(trustedRaw, providerId);
+        if (!effectiveProviderValue || typeof effectiveProviderValue !== "object" || Array.isArray(effectiveProviderValue)) {
+          continue;
+        }
+        const effectiveProvider = effectiveProviderValue;
+        const trustedProvider = trustedProviderValue && typeof trustedProviderValue === "object" && !Array.isArray(trustedProviderValue) ? trustedProviderValue : {};
+        const effectiveApi = effectiveProvider.api && typeof effectiveProvider.api === "object" && !Array.isArray(effectiveProvider.api) ? effectiveProvider.api : {};
+        const trustedApi = trustedProvider.api && typeof trustedProvider.api === "object" && !Array.isArray(trustedProvider.api) ? trustedProvider.api : {};
+        const projectApi = projectProvider.api && typeof projectProvider.api === "object" && !Array.isArray(projectProvider.api) ? projectProvider.api : {};
+        const effectiveChannels = Array.isArray(effectiveProvider.channels) ? effectiveProvider.channels : [];
+        const apiCanRun = effectiveProvider.transport === "api" || effectiveChannels.includes("api");
+        if (!apiCanRun) continue;
+        const fields = [];
+        if (projectProvider.transport !== void 0 && effectiveProvider.transport === "api" && trustedProvider.transport !== "api") {
+          fields.push("transport");
+        }
+        for (const field of ["base_url", "api_key_env_var"]) {
+          if (projectApi[field] !== void 0 && stableJson(effectiveApi[field]) !== stableJson(trustedApi[field])) {
+            fields.push(`api.${field}`);
+          }
+        }
+        if (fields.length > 0) {
+          changes.push({ providerId, fields });
+        }
+      }
+      return changes;
+    };
+    const describeExecutionFieldChanges = (changes) => changes.map(({ providerId, fields }) => `${providerId} (${fields.join(", ")})`).join(", ");
+    const buildUntrustedExecutionFieldError = (changes, root) => new Error(
+      `Security: Project config changes provider execution fields (${describeExecutionFieldChanges(changes)}) which are not allowed unless BUILD_TRUST_PROJECT_PROVIDER_TEMPLATES names this canonical project root.
+
+These fields can select the binary Build executes or installs, or redirect a credentialed API request, so a cloned repo could otherwise redirect a built-in provider to attacker-controlled code or infrastructure:
+  - User config: ${getUserProviderRegistryPaths(root)[0]}
+  - Project config: .build-project/config/providers.yaml (requires explicit trust)
+
+Providers are trusted only when their normalized execution config matches the embedded template.
+
+To trust only this project, run:
+` + projectTrustInstruction
+    );
+    const isAutoLoadedProjectRegistryPath = (candidatePath, root) => [
+      resolveProvidersConfigPath({ cwd: root }),
+      resolve5(root, ".build-project", "config", "provider-registry.yaml.v1.backup")
+    ].some((registryPath) => resolve5(registryPath) === resolve5(candidatePath));
+    const embedded = loadEmbeddedRaw();
+    if (!embedded) {
+      throw new Error("Failed to load the provider catalog. Run the provider generator and retry.");
+    }
+    if (configPath) {
+      const pathValidation = validateConfigPath(configPath, projectRoot, { allowTempDir: false });
+      if (!pathValidation.isValid) {
+        throw new Error(
+          `Security Error: Invalid config path "${configPath}": ${pathValidation.reason}. Risk level: ${pathValidation.riskLevel}`
+        );
+      }
+      const raw = loadYamlRawIfExists(pathValidation.normalizedPath);
+      if (!raw) {
+        throw new Error(
+          `Failed to read unified provider config at ${pathValidation.normalizedPath}`
+        );
+      }
+      const projectBuildDir = resolve5(projectRoot, ".build-project");
+      const isProjectConfig = pathValidation.normalizedPath.startsWith(projectBuildDir + sep);
+      if (isProjectConfig && isAutoLoadedProjectRegistryPath(pathValidation.normalizedPath, projectRoot) && !isTrustedProjectForProviderOverrides()) {
+        const executionFieldChanges = listUntrustedExecutionFieldChanges(raw, embedded.raw);
+        if (executionFieldChanges.length > 0) {
+          throw buildUntrustedExecutionFieldError(executionFieldChanges, projectRoot);
+        }
+      }
+      if (isProjectConfig && isAutoLoadedProjectRegistryPath(pathValidation.normalizedPath, projectRoot) && !isTrustedProjectForProviderOverrides()) {
+        const apiIdentityChanges = listUntrustedApiIdentityChanges(raw, raw, embedded.raw);
+        if (apiIdentityChanges.length > 0) {
+          throw buildUntrustedExecutionFieldError(apiIdentityChanges, projectRoot);
+        }
+      }
+      const withEnvOverrides2 = _ProviderRegistry.applyEnvOverrides(
+        dropRemovedBuiltinProviders(ensureCursorIdSyntaxAdmissionPattern(raw))
+      );
+      const validated2 = _ProviderRegistry.parseRegistryConfig(withEnvOverrides2);
+      return _ProviderRegistry.replaceCachedRegistry(
+        validated2,
+        pathValidation.normalizedPath,
+        requestedCacheKey,
+        "explicit",
+        projectRoot,
+        [pathValidation.normalizedPath]
+      );
+    }
+    let mergedRaw = embedded.raw;
+    const refresh = readEffectiveRefreshOverlay(projectRoot, {
+      expectedBaseCatalogDigest: PROVIDER_CATALOG_SHA256,
+      sourceBaseDrift: embedded.sourceBaseDrift
+    });
+    let appliedOverlayPath;
+    if (refresh.disposition.status === "ready") {
+      mergedRaw = applyRefreshOverlay(mergedRaw, refresh.disposition.overlay, refresh);
+      appliedOverlayPath = refresh.path;
+    } else if (refresh.disposition.status !== "absent") {
+      debugLog(
+        refresh.disposition.status === "degraded" ? refresh.disposition.warning : `Refresh overlay ignored: ${refresh.disposition.error}`
+      );
+    }
+    let securityMergedRaw = mergedRaw;
+    let trustedMergedRaw = mergedRaw;
+    let loadedProjectRaw = null;
+    let projectSelectionPolicy = null;
+    const loadedConfigSources = [
+      embedded.path,
+      ...appliedOverlayPath ? [appliedOverlayPath] : []
+    ];
+    const projectConfigV2 = resolveProvidersConfigPath({ cwd: projectRoot });
+    const projectConfigV1 = resolve5(
+      projectRoot,
+      ".build-project",
+      "config",
+      "provider-registry.yaml.v1.backup"
+    );
+    const discoveredProjectConfigPath = existsSync5(projectConfigV2) ? projectConfigV2 : existsSync5(projectConfigV1) ? projectConfigV1 : null;
+    const projectConfigPath = discoveredProjectConfigPath && resolve5(discoveredProjectConfigPath) !== resolve5(embedded.path) ? discoveredProjectConfigPath : null;
+    let loadedConfigPath = embedded.path;
+    if (projectConfigPath) {
+      const configParentDir = resolve5(projectRoot, ".build-project", "config");
+      if (!existsSync5(configParentDir)) {
+        throw new Error(
+          `Build not initialized: directory '${configParentDir}' does not exist.
+Run 'build init' to initialize Build in this project.`
+        );
+      }
+      const pathValidation = validateConfigPath(projectConfigPath, projectRoot, {
+        allowTempDir: false
+      });
+      if (!pathValidation.isValid) {
+        throw new Error(
+          `Security Error: Invalid config path "${projectConfigPath}": ${pathValidation.reason}. Risk level: ${pathValidation.riskLevel}`
+        );
+      }
+      const projectRaw = loadYamlRawIfExists(pathValidation.normalizedPath);
+      if (!projectRaw) {
+        throw new Error(
+          `Failed to read unified provider config at ${pathValidation.normalizedPath}`
+        );
+      }
+      loadedProjectRaw = projectRaw;
+      const projectIsTrusted = isTrustedProjectForProviderOverrides();
+      securityMergedRaw = deepMerge(securityMergedRaw, projectRaw);
+      if (!projectIsTrusted) {
+        const executionFieldChanges = listUntrustedExecutionFieldChanges(projectRaw, embedded.raw);
+        if (executionFieldChanges.length > 0) {
+          throw buildUntrustedExecutionFieldError(executionFieldChanges, projectRoot);
+        }
+      }
+      const projectedProjectRaw = projectProjectRegistryPolicy(projectRaw, embedded.raw, {
+        trusted: projectIsTrusted
+      });
+      mergedRaw = deepMerge(mergedRaw, projectedProjectRaw);
+      projectSelectionPolicy = pickProjectSelectionPolicy(projectedProjectRaw, embedded.raw);
+      warnOverlaySettingsOnce({
+        path: pathValidation.normalizedPath,
+        raw: projectRaw,
+        appliedRaw: projectedProjectRaw,
+        embeddedRaw: embedded.raw,
+        projectRoot
+      });
+      loadedConfigPath = pathValidation.normalizedPath;
+      loadedConfigSources.push(pathValidation.normalizedPath);
+    }
+    let ignoredUserModelEntries = [];
+    const userRegistryPaths = getUserProviderRegistryPaths(projectRoot);
+    for (const [index, candidate] of userRegistryPaths.entries()) {
+      const userRaw = loadYamlRawIfExists(candidate);
+      if (userRaw) {
+        warnOverlaySettingsOnce({ path: candidate, raw: userRaw, embeddedRaw: embedded.raw });
+        const migratedUserOverlay = index > 0 ? migrateLegacyFullSnapshotOverlay(userRaw, mergedRaw) : userRaw;
+        const merged = mergeUserModelEntries(migratedUserOverlay, mergedRaw, {
+          validateEntry: listModelEntryIssues,
+          sourcePath: candidate
+        });
+        const userOverlay = merged.overlay;
+        ignoredUserModelEntries = merged.ignored;
+        for (const ignored of merged.ignored) {
+          emitWarning(
+            "CFG-001",
+            { taskId: "provider-registry", subsystem: "config", executionPhase: "setup" },
+            {
+              severity: "WARN" /* WARN */,
+              message: describeIgnoredUserModelEntry(ignored),
+              metadata: { ...ignored, operation: "mergeUserModelEntries" }
+            }
+          );
+        }
+        mergedRaw = deepMerge(mergedRaw, userOverlay);
+        securityMergedRaw = deepMerge(securityMergedRaw, userOverlay);
+        trustedMergedRaw = deepMerge(trustedMergedRaw, userOverlay);
+        loadedConfigSources.push(candidate);
+        break;
+      }
+    }
+    if (projectSelectionPolicy) mergedRaw = deepMerge(mergedRaw, projectSelectionPolicy);
+    if (loadedProjectRaw && !isTrustedProjectForProviderOverrides()) {
+      const apiIdentityChanges = listUntrustedApiIdentityChanges(
+        loadedProjectRaw,
+        securityMergedRaw,
+        trustedMergedRaw
+      );
+      if (apiIdentityChanges.length > 0) {
+        throw buildUntrustedExecutionFieldError(apiIdentityChanges, projectRoot);
+      }
+    }
+    const withEnvOverrides = _ProviderRegistry.applyEnvOverrides(
+      dropRemovedBuiltinProviders(ensureCursorIdSyntaxAdmissionPattern(mergedRaw))
+    );
+    const validated = _ProviderRegistry.parseRegistryConfig(withEnvOverrides);
+    return _ProviderRegistry.replaceCachedRegistry(
+      applyProviderEnableSwitches(validated, projectRoot),
+      loadedConfigPath,
+      requestedCacheKey,
+      "implicit",
+      projectRoot,
+      loadedConfigSources,
+      ignoredUserModelEntries
+    );
+  }
+  /**
+   * Resolve every live registry read through the same active-root view.
+   *
+   * A prior explicit-root load establishes which project this process is
+   * serving. Rechecking that root on each read preserves file/environment
+   * fingerprint invalidation without letting a later process.cwd() change
+   * silently switch the live registry to another checkout.
+   * Snapshot consumers use this same accessor to retain the model-decision root.
+   */
+  static getActiveRegistry(registryOverride) {
+    if (registryOverride) {
+      return registryOverride;
+    }
+    if (!_ProviderRegistry.instance || !_ProviderRegistry.cacheProjectRoot) {
+      return _ProviderRegistry.load();
+    }
+    if (_ProviderRegistry.cacheMode === "explicit" && _ProviderRegistry.configPath) {
+      return _ProviderRegistry.load(_ProviderRegistry.configPath, _ProviderRegistry.cacheProjectRoot);
+    }
+    return _ProviderRegistry.load(void 0, _ProviderRegistry.cacheProjectRoot);
+  }
+  /**
+   * Get configuration for a specific provider
+   *
+   * @param providerId - Provider identifier (e.g., 'claude', 'codex')
+   * @returns Provider configuration with defaults applied
+   */
+  static getProviderConfig(providerId, registryOverride) {
+    const registry = _ProviderRegistry.getActiveRegistry(registryOverride);
+    const normalizedProviderId = normalizeProviderConfigId(providerId);
+    const providerConfig = registry.providers[providerId] ?? registry.providers[normalizedProviderId];
+    if (!providerConfig) {
+      const availableProviders = Object.values(registry.providers).filter((provider) => provider.enabled).sort((a, b) => a.order - b.order).map((provider) => provider.id).join(", ");
+      throw new Error(
+        `Provider '${providerId}' not found in unified config. Available providers: ${availableProviders}`
+      );
+    }
+    return cloneProviderRegistryValue(providerConfig);
+  }
+  /**
+   * Get all provider IDs
+   *
+   * @returns Array of provider IDs
+   */
+  static getAllProviderIds() {
+    const registry = _ProviderRegistry.getActiveRegistry();
+    return Object.keys(registry.providers);
+  }
+  /**
+   * Get all enabled providers
+   *
+   * @returns Array of enabled provider configurations
+   */
+  static getEnabledProviders(registryOverride) {
+    const registry = _ProviderRegistry.getActiveRegistry(registryOverride);
+    return Object.values(registry.providers).filter((p) => p.enabled).sort((a, b) => a.order - b.order);
+  }
+  /**
+   * Registry-owned provider family for judge independence. Falls back to
+   * `vendor` for overlay/custom providers, then to the provider id.
+   */
+  static getProviderFamily(providerId, registryOverride) {
+    return getProviderFamily(providerId, registryOverride);
+  }
+  /** Registry-owned judge-capability facts. Unknown providers fail closed. */
+  static getJudgeCapabilities(providerId) {
+    return getJudgeCapabilities(providerId);
+  }
+  /** The provider's `models.judge_reasoning_effort`; undefined when unset or unknown. */
+  static getJudgeReasoningEffort(providerId, registryOverride) {
+    const registry = _ProviderRegistry.getActiveRegistry(registryOverride);
+    const provider = registry.providers[providerId] ?? registry.providers[normalizeProviderConfigId(providerId)];
+    return provider?.models.judge_reasoning_effort;
+  }
+  /**
+   * Check if a provider is enabled
+   *
+   * @param providerId - Provider identifier
+   * @returns True if provider exists and is enabled
+   */
+  static isProviderEnabled(providerId) {
+    const registry = _ProviderRegistry.getActiveRegistry();
+    const normalizedProviderId = normalizeProviderConfigId(providerId);
+    const providerConfig = registry.providers[providerId] ?? registry.providers[normalizedProviderId];
+    return providerConfig?.enabled || false;
+  }
+  /**
+   * Report the source path the currently-cached registry was actually loaded
+   * from.
+   *
+   * This is the coherent provenance signal: when the project providers.yaml is
+   * absent and `load()` falls back to the embedded template seed, this returns
+   * the embedded template path that was actually used — NOT the nonexistent
+   * project `.build-project/config/providers.yaml` path. Diagnostics and logs should
+   * read this instead of recomputing the project path (e.g. via
+   * `resolveProvidersConfigPath`), which would falsely claim a project registry
+   * that is not present on disk.
+   *
+   * Returns `null` when no registry has been loaded yet in this process.
+   *
+   * @returns Absolute path of the loaded registry source, or `null`.
+   */
+  static getLoadedConfigPath() {
+    return _ProviderRegistry.configPath;
+  }
+  /**
+   * Report every source that contributed to the currently-cached registry,
+   * ordered from lowest to highest precedence.
+   */
+  static getLoadedConfigSources() {
+    return [..._ProviderRegistry.configSources];
+  }
+  /** User model entries the loaded registry ignored as invalid. */
+  static getIgnoredUserModelEntries() {
+    return [..._ProviderRegistry.ignoredUserModelEntries];
+  }
+  /** The ignored entries as report lines, or undefined when there are none. */
+  static describeIgnoredUserModelEntries() {
+    const lines = _ProviderRegistry.ignoredUserModelEntries.map(describeIgnoredUserModelEntry);
+    return lines.length > 0 ? lines.join("\n") : void 0;
+  }
+  /**
+   * Force reload configuration from disk
+   * Useful for testing or when config file has been modified
+   */
+  /**
+   * Per-provider `concurrency.max` set in USER-scope provider config only.
+   *
+   * Deliberately NOT read through `getProviderConfig()`. That returns the merged
+   * embedded < project < user view, and `concurrency` is in
+   * PROJECT_POLICY_PROVIDER_FIELDS — a list retained even for UNTRUSTED project
+   * snapshots — so a cloned repository's `.build-project/config/providers.yaml` can set
+   * it. The orchestrator raises how many provider processes actually run from
+   * this value, spending the operator's host resources and account quota, so it
+   * must come from config the operator owns. A project may still ship a lower
+   * value for its own planning; it just cannot raise process concurrency.
+   *
+   * Returns raw declared maxima without validation or clamping; the caller owns
+   * normalization and correctness ceilings. Unreadable or malformed user config
+   * yields an empty map rather than failing the run: the shipped baseline is
+   * always a safe fallback.
+   */
+  static getUserScopeProviderConcurrencyMax(cwd = process.cwd()) {
+    const projectRoot = findProjectRoot(cwd) ?? cwd;
+    const result = {};
+    for (const candidate of getUserProviderRegistryPaths(projectRoot)) {
+      if (!existsSync5(candidate)) continue;
+      let raw;
+      try {
+        raw = yaml.load(readFileSync8(candidate, "utf-8"));
+      } catch {
+        return {};
+      }
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        continue;
+      }
+      const providers = raw.providers;
+      if (!providers || typeof providers !== "object" || Array.isArray(providers)) {
+        return result;
+      }
+      for (const [providerId, providerValue] of Object.entries(
+        providers
+      )) {
+        if (!providerValue || typeof providerValue !== "object" || Array.isArray(providerValue)) {
+          continue;
+        }
+        const concurrency = providerValue.concurrency;
+        if (!concurrency || typeof concurrency !== "object" || Array.isArray(concurrency)) {
+          continue;
+        }
+        const max = concurrency.max;
+        if (typeof max === "number" && Number.isFinite(max)) {
+          result[providerId] = max;
+        }
+      }
+      return result;
+    }
+    return result;
+  }
+  static reload() {
+    _ProviderRegistry.instance = null;
+    _ProviderRegistry.configPath = null;
+    _ProviderRegistry.configSources = [];
+    _ProviderRegistry.ignoredUserModelEntries = [];
+    _ProviderRegistry.cacheKey = null;
+    _ProviderRegistry.cacheMode = null;
+    _ProviderRegistry.cacheProjectRoot = null;
+    runProviderRegistryReloadInvalidators();
+  }
+  static buildEnvOverrideCacheKey() {
+    return fingerprintEnvironment(
+      { ...process.env, ...getExecutionContext().envOverrides },
+      (name) => name.startsWith("BUILD_PROVIDER_") || /^BUILD_\w+_ENABLED$/.test(name) || // provider-enable-switches.ts inputs
+      [
+        "BUILD_TRUST_PROJECT_PROVIDER_TEMPLATES",
+        "BUILD_CONFIG_DIR",
+        "BUILD_DATA_DIR",
+        "BUILD_HOME",
+        "XDG_DATA_HOME",
+        "BUILD_MODEL_REFRESH_CONTEXT",
+        "AWS_PROFILE",
+        "AWS_REGION",
+        "AWS_DEFAULT_REGION",
+        "GOOGLE_CLOUD_PROJECT",
+        "CLOUD_ML_REGION",
+        "CODEX_HOME",
+        "CLAUDE_CONFIG_DIR",
+        "XDG_CONFIG_HOME",
+        "HOME",
+        "USERPROFILE"
+      ].includes(name)
+    );
+  }
+  static buildCacheKey(configPath, envKey, projectRoot) {
+    if (configPath) {
+      return combineCacheFingerprints(
+        `path:${resolve5(configPath)}`,
+        `root:${projectRoot}`,
+        envKey,
+        fingerprintFiles([configPath])
+      );
+    }
+    return combineCacheFingerprints(
+      `root:${projectRoot}`,
+      envKey,
+      enableSwitchCacheKey(projectRoot),
+      fingerprintFiles(getProviderRegistryInputPaths(projectRoot))
+    );
+  }
+  static canReuseExplicitCacheForImplicit(configPath, projectRoot) {
+    return resolve5(configPath) !== resolveProvidersConfigPath({ cwd: projectRoot });
+  }
+  /**
+   * Apply environment variable overrides
+   * Supports: BUILD_PROVIDER_<ID>_<KEY>=value
+   *
+   * Examples:
+   * - BUILD_PROVIDER_CODEX_TIMEOUT_MS=900000
+   * - BUILD_PROVIDER_CLAUDE_ENABLED=false
+   * - BUILD_PROVIDER_GEMINI_MODELS_DEFAULT=gemini-2.5-flash
+   *
+   * @param config - Parsed YAML configuration
+   * @returns Configuration with environment overrides applied
+   */
+  static applyEnvOverrides(config) {
+    if (!config || typeof config !== "object") {
+      return config;
+    }
+    const result = cloneProviderRegistryValue(config);
+    const runtimeEnv2 = {
+      ...process.env,
+      ...getExecutionContext().envOverrides
+    };
+    for (const [key, value] of Object.entries(runtimeEnv2)) {
+      if (!key.startsWith("BUILD_PROVIDER_")) {
+        continue;
+      }
+      if (getEnvVarEntry(key)) {
+        continue;
+      }
+      const overrideName = key.substring("BUILD_PROVIDER_".length);
+      if (!overrideName.includes("_")) {
+        continue;
+      }
+      const providers = result.providers;
+      const providerEntries = providers && typeof providers === "object" ? Object.keys(providers) : [];
+      const providerId = providerEntries.filter((id) => overrideName.startsWith(`${id.toUpperCase()}_`)).sort((a, b) => b.length - a.length)[0];
+      if (!providerId) {
+        const claimedProvider = overrideName.split("_")[0]?.toLowerCase() ?? overrideName;
+        throw new InvalidExplicitConfigError(
+          `Environment variable ${key} targets unknown provider '${claimedProvider}'.`
+        );
+      }
+      const configKey = overrideName.slice(providerId.length + 1).toLowerCase();
+      const providerConfig = providers[providerId];
+      if (providerConfig && typeof providerConfig === "object") {
+        _ProviderRegistry.setNestedValue(
+          providerConfig,
+          configKey,
+          String(value ?? ""),
+          key
+        );
+      }
+    }
+    return result;
+  }
+  static dynamicProviderOverrideKeys() {
+    const runtimeEnv2 = {
+      ...process.env,
+      ...getExecutionContext().envOverrides
+    };
+    return Object.keys(runtimeEnv2).filter((key) => {
+      if (!key.startsWith("BUILD_PROVIDER_") || getEnvVarEntry(key)) return false;
+      return key.substring("BUILD_PROVIDER_".length).includes("_");
+    });
+  }
+  static parseRegistryConfig(config) {
+    try {
+      return ProviderRegistryConfigSchema.parse(config);
+    } catch (error) {
+      if (error instanceof z3.ZodError) {
+        const issues = error.issues.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`).join("\n");
+        const overrideKeys = _ProviderRegistry.dynamicProviderOverrideKeys();
+        if (overrideKeys.length > 0) {
+          throw new InvalidExplicitConfigError(
+            `Invalid provider environment override (${overrideKeys.join(", ")}):
+${issues}`,
+            error
+          );
+        }
+        throw new Error(`Unified provider config validation failed:
+${issues}`);
+      }
+      if (error instanceof TypeError && error.message.includes("_zod")) {
+        throw new Error(
+          `Schema validation failed due to undefined nested schema. This typically indicates incorrect Zod v4 syntax (e.g., z.record() requires two parameters). Original error: ${error.message}
+
+Fix: Change z.record(z.string()) to z.record(z.string(), z.string()) in schema definitions.`
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Set a nested value in an object using underscore notation
+   *
+   * @param obj - Object to modify
+   * @param path - Underscore-separated path (TIMEOUT_MS -> timeout_ms, MODELS_DEFAULT -> models.default)
+   * @param value - Value to set
+   */
+  static setNestedValue(obj, path5, value, envKey) {
+    const normalizedPath = path5.toLowerCase();
+    if (normalizedPath in obj) {
+      obj[normalizedPath] = _ProviderRegistry.canonicalizeLegacyApiOverride(
+        normalizedPath,
+        _ProviderRegistry.coerceOverrideValue(value, obj[normalizedPath], envKey)
+      );
+      return;
+    }
+    const parts = normalizedPath.split("_");
+    if (parts[0] === "models" && parts.length > 1) {
+      if (typeof obj.models !== "object" || obj.models === null || Array.isArray(obj.models)) {
+        obj.models = {};
+      }
+      const nestedPath = parts.slice(1).join("_");
+      if (nestedPath === "default" && !("default" in obj.models)) {
+        obj.models.default = value;
+        return;
+      }
+      _ProviderRegistry.setNestedValue(
+        obj.models,
+        nestedPath,
+        value,
+        envKey
+      );
+      return;
+    }
+    for (let i = 1; i < parts.length; i++) {
+      const firstKey = parts.slice(0, i).join("_");
+      const restKey = parts.slice(i).join("_");
+      if (firstKey in obj && typeof obj[firstKey] === "object" && obj[firstKey] !== null) {
+        _ProviderRegistry.setNestedValue(
+          obj[firstKey],
+          restKey,
+          value,
+          envKey
+        );
+        return;
+      }
+    }
+    throw new InvalidExplicitConfigError(
+      `Environment variable ${envKey} targets unknown provider configuration key '${normalizedPath}'.`
+    );
+  }
+  /**
+   * Keep legacy API-shaped env overrides parseable as `api` rather than
+   * converting them to CLI or letting mixed-case `API` fail as a generic
+   * enum/array validation error. Selection still fails closed later.
+   */
+  static canonicalizeLegacyApiOverride(path5, value) {
+    if (typeof value !== "string" || value.trim().toLowerCase() !== "api") {
+      return value;
+    }
+    if (path5 === "transport") {
+      return "api";
+    }
+    if (path5 === "channels") {
+      return ["api"];
+    }
+    return value;
+  }
+  /**
+   * Parse environment variable value to appropriate type
+   *
+   * @param value - String value from environment
+   * @returns Parsed value (boolean, number, or string)
+   */
+  static coerceOverrideValue(value, destination, envKey) {
+    if (typeof destination === "boolean") {
+      const normalized = value.trim().toLowerCase();
+      if (["1", "true", "yes", "on"].includes(normalized)) return true;
+      if (["0", "false", "no", "off"].includes(normalized)) return false;
+      throw new InvalidExplicitConfigError(
+        `Environment variable ${envKey} must be a boolean (true/false, yes/no, on/off, or 1/0).`
+      );
+    }
+    if (typeof destination === "number") {
+      const numeric = Number(value);
+      if (Number.isFinite(numeric)) return numeric;
+      throw new InvalidExplicitConfigError(
+        `Environment variable ${envKey} must be a finite number.`
+      );
+    }
+    return value;
+  }
+  /**
+   * Get global defaults
+   *
+   * @returns Global defaults configuration
+   */
+  static getDefaults() {
+    const registry = _ProviderRegistry.getActiveRegistry();
+    return registry.defaults;
+  }
+  /**
+   * Get configuration metadata
+   *
+   * @returns Configuration metadata
+   */
+  static getMetadata() {
+    const registry = _ProviderRegistry.getActiveRegistry();
+    return registry.metadata;
+  }
+  /**
+   * Resolve a model name for a specific provider
+   * Applies model mappings and validates against allowed patterns
+   *
+   * @param providerId - Provider identifier
+   * @param model - Model name to resolve (may be generic like 'gpt-4')
+   * @returns Resolved provider-specific model name
+   */
+  static resolveModel(providerId, model, registryOverride) {
+    const config = _ProviderRegistry.getProviderConfig(providerId, registryOverride);
+    const trimmedModel = !model || model.trim() === "" ? config.models.default : model.trim();
+    if (trimmedModel in config.models.mappings) {
+      const mapped = config.models.mappings[trimmedModel];
+      if (mapped !== void 0) {
+        return mapped;
+      }
+    }
+    if (declaresFamilyAlias(config.models.family_aliases, trimmedModel)) {
+      return trimmedModel;
+    }
+    for (const pattern of config.models.allowed_patterns) {
+      let regex;
+      try {
+        regex = new RegExp(pattern);
+      } catch (error) {
+        debugLog(
+          `Skipping invalid allowed_patterns regex for provider '${providerId}': ${pattern} (${error instanceof Error ? error.message : String(error)})`
+        );
+        continue;
+      }
+      if (regex.test(trimmedModel)) {
+        return trimmedModel;
+      }
+    }
+    const availableModels = config.models.available.map((info) => info.id);
+    if (availableModels.includes(trimmedModel)) {
+      return trimmedModel;
+    }
+    const offered = offeredModelIds(config.models);
+    const validModels = offered.length > 0 ? offered.join(", ") : "None";
+    const validPatterns = config.models.allowed_patterns.length > 0 ? config.models.allowed_patterns.join(", ") : "None";
+    const registrySources = !registryOverride || registryOverride === _ProviderRegistry.instance ? _ProviderRegistry.getLoadedConfigSources() : [];
+    const sourceDetail = registrySources.length > 0 ? ` Registry sources: ${registrySources.join(", ")}.` : "";
+    throw new Error(
+      `Model '${trimmedModel}' is not available for provider '${providerId}'. Available models: ${validModels}. Allowed patterns: ${validPatterns}.${sourceDetail}`
+    );
+  }
+  /**
+   * Get timeout for a specific provider
+   *
+   * @param providerId - Provider identifier
+   * @returns Timeout in milliseconds
+   */
+  static getTimeout(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return config.timeout_ms;
+  }
+  /**
+   * Get pricing configuration for a specific provider
+   *
+   * @param providerId - Provider identifier
+   * @returns Pricing configuration if available, undefined otherwise
+   */
+  static getProviderPricing(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return config.pricing;
+  }
+  /**
+   * Get model pricing for a specific provider and model
+   *
+   * @param providerId - Provider identifier
+   * @param modelId - Model identifier
+   * @returns Model pricing if available, undefined otherwise
+   */
+  static getModelPricing(providerId, modelId) {
+    const pricing = _ProviderRegistry.getProviderPricing(providerId);
+    if (!pricing || !pricing.models) return void 0;
+    return pricing.models[modelId];
+  }
+  /**
+   * Resolve provider ID from model name using allowed_patterns
+   *
+   * @param model - Model name (e.g., 'gemini-2.5-flash', 'sonnet-4-5')
+   * @param registryOverride - Optional registry snapshot; defaults to the active registry
+   * @returns Provider ID if model matches a pattern, undefined otherwise
+   */
+  static resolveProviderByModel(model, registryOverride) {
+    if (!model) return void 0;
+    const registry = _ProviderRegistry.getActiveRegistry(registryOverride);
+    const isNonAuthoritativeOwnershipPattern = (pattern) => {
+      const normalized = pattern.trim();
+      return normalized === ".*" || normalized === "^.*$" || normalized === CURSOR_ID_SYNTAX_ADMISSION_PATTERN;
+    };
+    const matches = [];
+    for (const [providerId, provider] of Object.entries(registry.providers)) {
+      if (!provider.enabled) continue;
+      const patterns = provider.models.allowed_patterns || [];
+      let providerMatched = false;
+      for (const pattern of patterns) {
+        try {
+          const regex = new RegExp(pattern, "i");
+          if (regex.test(model)) {
+            if (isNonAuthoritativeOwnershipPattern(pattern)) {
+              continue;
+            }
+            providerMatched = true;
+            break;
+          }
+        } catch (error) {
+          emitWarning(
+            "CFG-003",
+            {
+              taskId: "provider-registry",
+              subsystem: "config",
+              executionPhase: "setup"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                providerId,
+                pattern,
+                error: error instanceof Error ? error.message : String(error),
+                operation: "resolveProviderByModel"
+              }
+            }
+          );
+        }
+      }
+      if (providerMatched) {
+        matches.push(providerId);
+      }
+    }
+    if (matches.length === 1) {
+      return matches[0];
+    }
+    return void 0;
+  }
+  /**
+   * Get options for a specific provider
+   *
+   * @param providerId - Provider identifier
+   * @returns Provider options, or empty object if none defined
+   */
+  static getProviderOptions(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return config.options || {};
+  }
+  /**
+   * Get requirements for a specific provider
+   *
+   * @param providerId - Provider identifier
+   * @returns Provider requirements with both unconditional and conditional deps
+   */
+  static getProviderRequirements(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return {
+      requires: config.requires || [],
+      requires_if: config.requires_if || {}
+    };
+  }
+  /**
+   * Get a specific option by key from a provider
+   *
+   * @param providerId - Provider identifier
+   * @param optionKey - Option key
+   * @returns Provider option if found, undefined otherwise
+   */
+  static getOption(providerId, optionKey) {
+    const options = _ProviderRegistry.getProviderOptions(providerId);
+    return options[optionKey];
+  }
+  /**
+   * Get the default model for a provider, from static registry config.
+   * For runtime-observed defaults, use provider-specific discovery.
+   *
+   * @param providerId - Provider identifier
+   * @returns Default model ID, or undefined if not configured
+   */
+  static getDefaultModel(providerId, registryOverride) {
+    const config = _ProviderRegistry.getProviderConfig(providerId, registryOverride);
+    return config.models.default || void 0;
+  }
+  /**
+   * Get a model assigned to a provider-specific role, if configured.
+   *
+   * Roles encode product intent such as "quality" or "fast" without assuming
+   * the provider default is suitable for every outcome strategy.
+   *
+   * @param providerId - Provider identifier
+   * @param role - Model role name
+   * @returns Resolved model ID for the role, or undefined if the role is not configured
+   */
+  static getModelForRole(providerId, role, registryOverride) {
+    const trimmedRole = role.trim();
+    if (!trimmedRole) return void 0;
+    const config = _ProviderRegistry.getProviderConfig(providerId, registryOverride);
+    const configuredModel = config.models.roles?.[trimmedRole];
+    if (!configuredModel) return void 0;
+    return _ProviderRegistry.resolveModel(providerId, configuredModel, registryOverride);
+  }
+  /**
+   * Resolve a reviewer model across all enabled providers, excluding specified providers.
+   *
+   * Implements the cross-provider review rule from the Wave 2 design record:
+   * reviewer != orchestrator provider != executor provider (and any additional
+   * mutation-owner providers the caller passes). Callers pass the provider IDs
+   * already assigned to other stages so this method returns the first remaining
+   * provider, with its model for the first role in the role chain it declares,
+   * else its default model (role `default`). Every eligible provider qualifies.
+   *
+   * Callers that honor a configured `roles.reviewer.modelRole` pass a chain with
+   * that role so automatic selection does not silently ignore it.
+   *
+   * Candidate order: `providerPreference` ids first (skipping excluded, disabled,
+   * unknown and non-`preferenceProviders` entries), then `eligibleProviders` in the
+   * caller's order (the one provider order), else the enabled providers in `order`.
+   *
+   * Returns null when no qualifying provider is found. Pure and static — reads
+   * only from the loaded registry and applies no side effects: `eligibleProviders`
+   * is an eligibility filter the CALLER established (e.g. installed CLIs); this
+   * method never probes the filesystem or a provider CLI itself.
+   *
+   * @param excludeProviders - Provider IDs to skip (e.g. orchestrator + executor + mutation owners)
+   * @param options.roleChain - Model roles tried before the default model (default: none)
+   * @param options.providerPreference - Preferred provider order for selection
+   * @param options.eligibleProviders - When set, only these provider IDs may be
+   *   selected (an empty list qualifies nobody). Omit for no eligibility filter.
+   * @param options.preferenceProviders - Ids a preference entry may name (default: eligibleProviders)
+   * @param options.roleModel - Looks up a provider's model for a role, including
+   *   `default` (default: its providers.yaml slot or default model); lets the caller
+   *   resolve roles that honor user config.
+   * @returns Provider + resolved model + winning role, or null if none qualify
+   */
+  static resolveReviewerModel(excludeProviders, options = {}, registryOverride) {
+    const toKeys = (ids) => new Set(ids.map((p) => p.trim().toLowerCase()).filter((p) => p.length > 0));
+    const excludeSet = toKeys(excludeProviders);
+    const preferable = options.preferenceProviders ?? options.eligibleProviders;
+    const preferableSet = preferable ? toKeys(preferable) : void 0;
+    const ineligible = (key) => preferableSet?.has(key) === false;
+    const roleChain = [
+      ...(options.roleChain ?? []).map((r) => r.trim()).filter((r) => r.length > 0),
+      "default"
+    ];
+    const registryRoleModel = (pid, role) => {
+      if (role !== "default") return _ProviderRegistry.getModelForRole(pid, role, registryOverride);
+      try {
+        return _ProviderRegistry.resolveModel(pid, void 0, registryOverride);
+      } catch {
+        return void 0;
+      }
+    };
+    const enabled = _ProviderRegistry.getEnabledProviders(registryOverride);
+    const enabledById = new Map(enabled.map((p) => [p.id.toLowerCase(), p]));
+    const ordered = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const pref of options.providerPreference ?? []) {
+      const key = pref.trim().toLowerCase();
+      if (!key || seen.has(key) || excludeSet.has(key) || ineligible(key)) continue;
+      const match = enabledById.get(key);
+      if (match) {
+        ordered.push(match);
+        seen.add(key);
+      }
+    }
+    const rest = options.eligibleProviders?.map((id) => enabledById.get(id.trim().toLowerCase()));
+    for (const providerConfig of rest ?? enabled) {
+      const key = providerConfig?.id.toLowerCase();
+      if (!providerConfig || !key || seen.has(key) || excludeSet.has(key)) continue;
+      ordered.push(providerConfig);
+      seen.add(key);
+    }
+    for (const providerConfig of ordered) {
+      const pid = providerConfig.id;
+      for (const role of roleChain) {
+        const model = (options.roleModel ?? registryRoleModel)(pid, role);
+        if (model) {
+          return { provider: pid, model, role };
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Get the list of available models for a provider, from static registry config.
+   * `getDiscoveredModels()` currently returns this same static inventory.
+   * For observation-backed IDs, read the provider's discovery cache directly
+   * (for example `getCachedCursorModelIds` or `getCachedOpencodeModelIds`).
+   *
+   * @param providerId - Provider identifier
+   * @returns Array of available model IDs from the static registry
+   */
+  static getAvailableModels(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return config.models.available.map((m) => m.id);
+  }
+  /**
+   * Model ids to offer in listings and pickers: the available rows limited to the
+   * CLI's observed inventory when one was refreshed. Unlisted rows still resolve.
+   */
+  static getOfferedModels(providerId) {
+    return offeredModelIds(_ProviderRegistry.getProviderConfig(providerId).models);
+  }
+  /**
+   * Get static model mappings for a provider (logical name → native CLI ID).
+   * For Cursor, also check getCachedCanonicalMappings() from
+   * src/core/providers/cursor/model-discovery.ts for discovery-fed mappings.
+   *
+   * @param providerId - Provider identifier
+   * @returns Record mapping logical model names to native CLI IDs
+   */
+  static getMappings(providerId) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    return cloneProviderRegistryValue(config.models.mappings);
+  }
+  /**
+   * Return the static available-model list from this registry.
+   *
+   * Despite the name, this is not live discovery and does not read an
+   * observation cache. It is equivalent to `getAvailableModels()`.
+   *
+   * Callers that need observation-backed IDs should read the provider's
+   * discovery cache directly (`getCachedCursorModelIds`,
+   * `getCachedOpencodeModelIds`). Those readers return local cache evidence
+   * only (empty when none) and do not fall back to this registry.
+   *
+   * @param providerId - Provider identifier
+   * @returns Array of model IDs from the static registry
+   */
+  static getDiscoveredModels(providerId) {
+    const normalized = normalizeProviderConfigId(providerId);
+    return _ProviderRegistry.getAvailableModels(normalized);
+  }
+  /**
+   * Read a single capability flag for a provider.
+   *
+   * Returns the boolean value when explicitly set in providers.yaml, or
+   * `undefined` when the flag is absent (caller must decide the default).
+   *
+   * @param providerId - Provider identifier
+   * @param name - Capability key (e.g. 'supports_api_judge')
+   * @returns boolean if set, undefined if not declared
+   */
+  static getCapability(providerId, name) {
+    const config = _ProviderRegistry.getProviderConfig(providerId);
+    const value = config.capabilities[name];
+    return typeof value === "boolean" ? value : void 0;
+  }
+};
+function loadProviderRegistry(configPath) {
+  return ProviderRegistry.load(configPath);
+}
+function getProviderConfig(providerId, registryOverride) {
+  return ProviderRegistry.getProviderConfig(providerId, registryOverride);
+}
+function getCapability(providerId, name) {
+  return ProviderRegistry.getCapability(providerId, name);
+}
+
+export {
+  PROVIDER_CATALOG_SHA256,
+  BEDROCK_CODEX_MODEL_PROVIDER,
+  isCodexBedrockProviderId,
+  isBedrockRuntimeCodexProvider,
+  resolveCodexBackendDetailed,
+  resolveCodexBackend,
+  describeCodexBackendConflict,
+  resolveBedrockCodexWireModel,
+  readCodexConnection,
+  opencodeInventoryContext,
+  REFRESH_OVERLAY_SCHEMA_VERSION,
+  OverlayModelAvailableEntrySchema,
+  OverlayPricingRowSchema,
+  getRefreshOverlayOperatorNotice,
+  emptyRefreshOverlay,
+  serializeRefreshOverlay,
+  parseRefreshOverlay,
+  loadRefreshOverlayFile,
+  withRefreshOrigin,
+  refreshEnvironment,
+  refreshInventoryContext,
+  resolveSharedRefreshPaths,
+  carriedForwardOverlay,
+  readEffectiveRefreshOverlay,
+  fingerprintEnvironment,
+  fingerprintFile,
+  fingerprintFiles,
+  combineCacheFingerprints,
+  InvalidExplicitConfigError,
+  InvalidConfigContentError,
+  isInvalidExplicitConfigError,
+  isConfigValidityError,
+  rethrowConfigValidityError,
+  getEmbeddedProviderConfigPaths,
+  isPackagedCatalogPath,
+  resolveSourceBaseDrift,
+  detectSourceBaseDrift,
+  normalizeModelSelectorForComparison,
+  isOfferedModel,
+  offeredModelRows,
+  offeredModelIds,
+  warnIfModelUnobserved,
+  isTrustedProjectRoot,
+  providerDisableSwitch,
+  disabledBySuffix,
+  ModelPricingSchema,
+  ToolPricingSchema,
+  SubscriptionPricingSchema,
+  InfrastructurePricingSchema,
+  ProviderPricingSchema,
+  registerProviderRegistryReloadInvalidator,
+  catalogAdditions,
+  applyRefreshOverlay,
+  getConfiguredProviderRegistryPaths,
+  getProviderRegistryInputPaths,
+  RetryConfigSchema,
+  CircuitBreakerConfigSchema,
+  RateLimitEntrySchema,
+  RateLimitsConfigSchema,
+  MemoryConfigSchema,
+  PollingConfigSchema,
+  CLIConfigSchema,
+  AuthConfigSchema,
+  TemplatedAuthConfigSchema,
+  ProbeExpectationSchema,
+  CommandProbeSchema,
+  ModelsDiscoverySchema,
+  ModelAccessClassSchema,
+  ModelAccessConfigSchema,
+  ModelsConfigSchema,
+  TemplatedModelsConfigSchema,
+  CapabilitiesConfigSchema,
+  TemplatedCapabilitiesConfigSchema,
+  BotIdentityConfigSchema,
+  EnvConfigSchema,
+  RefreshStrategyConfigSchema,
+  DefaultPricingSchema,
+  ConcurrencyConfigSchema,
+  RouteConfigSchema,
+  WorkspaceEditsConfigSchema,
+  GenerationConfigSchema,
+  TaskSettingsSchema,
+  RequirementSchema,
+  ProviderOptionSchema,
+  ProviderOptionsSchema,
+  ConditionalRequiresSchema,
+  ProviderRequiresSchema,
+  ApiConfigSchema,
+  TemplatedCLIExecutionSchema,
+  NativeProviderConfigSchema,
+  TemplatedProviderConfigSchema,
+  ProviderConfigSchema,
+  DefaultsConfigSchema,
+  MetadataConfigSchema,
+  ProviderRegistryConfigSchema,
+  getProviderFamily,
+  getJudgeCapabilities,
+  ProviderRegistry,
+  loadProviderRegistry,
+  getProviderConfig,
+  getCapability
+};
+//# sourceMappingURL=chunk-QJ6OEH4K.js.map