@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-C3DH3NCY.js

@@ -0,0 +1,2773 @@
+import {
+  retiredJudgeSelectionError
+} from "./chunk-IVZEONFC.js";
+import {
+  assertProviderReady
+} from "./chunk-XTXYIISX.js";
+import {
+  ENABLED_PROVIDER_IDS
+} from "./chunk-I7SCBHJN.js";
+import {
+  closestOfferedModelId,
+  isUnknownRegistryModel,
+  parseEffortToken
+} from "./chunk-TGXXYDL4.js";
+import {
+  getActiveProfilePath,
+  isAutoCreatedProfile,
+  loadActiveProfileStrict,
+  profileToBuildConfig,
+  warnIfShadowedConfigCandidate
+} from "./chunk-M4BUEXXF.js";
+import {
+  normalizeLegacyIntoCanonical,
+  readProviderModelFromEnv,
+  warnRetiredConfigKeysOnce
+} from "./chunk-726G6WDL.js";
+import {
+  JUDGE_SCORING_CONFIG
+} from "./chunk-SVUNZOPG.js";
+import {
+  familyFlagshipModel,
+  isFamilyAlias,
+  modelFamilies
+} from "./chunk-FAZBRHGG.js";
+import {
+  BuildConfigReadError,
+  buildConfigCandidates,
+  readCanonicalBuildConfig,
+  selectedBuildConfigCandidate
+} from "./chunk-FKCG7K6H.js";
+import {
+  firstInstalledEnabledProvider,
+  isProviderCliResolvable
+} from "./chunk-KKQKWAMF.js";
+import {
+  InvalidExplicitConfigError,
+  ProviderRegistry,
+  combineCacheFingerprints,
+  fingerprintEnvironment,
+  fingerprintFile,
+  fingerprintFiles,
+  isOfferedModel,
+  normalizeModelSelectorForComparison,
+  providerDisableSwitch,
+  warnIfModelUnobserved
+} from "./chunk-QJ6OEH4K.js";
+import {
+  listModelRouteIds
+} from "./chunk-QXBKTJT6.js";
+import {
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.js";
+import {
+  getConfigPaths,
+  projectConfigAliasesUserConfig,
+  resolveProvidersConfigPath
+} from "./chunk-35J4NE6S.js";
+import {
+  quotePosixShellArg
+} from "./chunk-N5DX4JAK.js";
+import {
+  getUserConfigDir,
+  getUserPreferencesPath
+} from "./chunk-56WPYDJH.js";
+import {
+  getPackageRoot
+} from "./chunk-STW7OFOA.js";
+import {
+  BUILD_TELEMETRY_EPHEMERAL_REPLICATION,
+  emitWarning,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/config/resolution-engine.ts
+import { existsSync } from "fs";
+import { join as join4 } from "path";
+
+// src/core/config/explicit-model-warning.ts
+function warnIfExplicitModelUnobserved(providerId, model) {
+  try {
+    const { models } = ProviderRegistry.getProviderConfig(providerId);
+    warnIfModelUnobserved(providerId, models, ProviderRegistry.resolveModel(providerId, model));
+  } catch {
+  }
+}
+function assertExplicitModelNotMistyped(providerId, model) {
+  let suggestion;
+  let resolved;
+  try {
+    const { models } = ProviderRegistry.getProviderConfig(providerId);
+    resolved = ProviderRegistry.resolveModel(providerId, model);
+    if (isOfferedModel(models, resolved) || !isUnknownRegistryModel(providerId, resolved)) return;
+    suggestion = closestOfferedModelId(providerId, resolved);
+  } catch {
+    return;
+  }
+  if (!suggestion) return;
+  throw new Error(
+    `Unknown ${providerId} model "${model}". Did you mean "${suggestion}"? Check the model id, or run the provider CLI to list the models it offers.`
+  );
+}
+
+// src/core/config/resolution-warnings.ts
+var RESOLUTION_WARNING_CODE = "CFG-008";
+var emittedKeys = /* @__PURE__ */ new Set();
+function emitResolutionWarningOnce(warning) {
+  const value = warning.model ?? warning.source ?? "";
+  const key = `${warning.operation}|${warning.provider}|${value}`;
+  if (emittedKeys.has(key)) return;
+  emittedKeys.add(key);
+  emitWarning(
+    RESOLUTION_WARNING_CODE,
+    {
+      taskId: "resolution-engine",
+      subsystem: "config",
+      executionPhase: "setup"
+    },
+    {
+      severity: "WARN" /* WARN */,
+      message: warning.message,
+      metadata: { ...warning }
+    }
+  );
+}
+
+// src/core/config/active-profile.ts
+var activeProfileCache = null;
+function getActiveProfile() {
+  const profilePath = getActiveProfilePath();
+  const fingerprint = combineCacheFingerprints(
+    fingerprintEnvironment(
+      process.env,
+      (name) => ["BUILD_ACTIVE_PROFILE", "BUILD_CONFIG_DIR", "BUILD_PROFILES_DIR"].includes(name)
+    ),
+    fingerprintFiles([getUserPreferencesPath(), ...profilePath ? [profilePath] : []])
+  );
+  if (activeProfileCache === null || activeProfileCache.fingerprint !== fingerprint) {
+    let profile;
+    try {
+      profile = loadActiveProfileStrict();
+    } catch (error) {
+      throw new BuildConfigReadError(
+        profilePath ?? "active profile",
+        "unreadable",
+        [{ message: error instanceof Error ? error.message : String(error) }],
+        error
+      );
+    }
+    if (profile && profilePath) warnRetiredConfigKeysOnce(profilePath, profile);
+    const value = profile ? { ...profile, ...profileToBuildConfig(profile) } : null;
+    activeProfileCache = { value, fingerprint };
+  }
+  return activeProfileCache.value ?? null;
+}
+function resetActiveProfileCache() {
+  activeProfileCache = null;
+}
+function warnSetupProviderPin(profile, pinned, loadLayers) {
+  warnSetupPin(
+    profile,
+    "defaults.provider",
+    pinned,
+    pinned,
+    loadLayers,
+    (layer) => layer?.defaults?.provider?.toLowerCase().trim()
+  );
+}
+function warnSetupModelPin(profile, provider, pinned, loadLayers) {
+  const key = `defaults.providers.${provider}.model`;
+  warnSetupPin(
+    profile,
+    key,
+    pinned,
+    provider,
+    loadLayers,
+    (layer) => layer?.defaults?.providers?.[provider]?.model?.trim()
+  );
+}
+function warnSetupPin(profile, key, pinned, provider, loadLayers, read) {
+  if (!isAutoCreatedProfile(profile)) return;
+  let layers;
+  try {
+    layers = loadLayers();
+  } catch {
+    return;
+  }
+  const projectValue = read(layers.project);
+  const [value, path3] = projectValue ? [projectValue, layers.paths.projectConfigFile] : [read(layers.user), layers.paths.userConfigFile];
+  if (!value || value === pinned) return;
+  emitResolutionWarningOnce({
+    operation: "autoCreatedProfilePin",
+    provider,
+    source: `${key}=${value}`,
+    message: `profile '${profile.name}' sets ${key}=${pinned}, written by first-run setup; it overrides ${key}=${value} in ${path3}. Run 'build provider setup --first-run --reset-defaults' to remove it.`
+  });
+}
+
+// src/core/config/provider-order.ts
+import { AsyncLocalStorage } from "async_hooks";
+var CONFIG_LAYER_PRECEDENCE = [
+  "user-config",
+  "project",
+  "profile",
+  "env",
+  "cli"
+];
+var PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+var RETIRED_PURPOSE_ORDER_KEYS = {
+  synthesis: "defaults.synthesis.providerOrder",
+  decomposition: "defaults.intent.decomposition.providerOrder"
+};
+function retiredPurposeOrder(defaults, purpose) {
+  return purpose === "synthesis" ? defaults?.synthesis?.providerOrder : defaults?.intent?.decomposition?.providerOrder;
+}
+function resolveDeclaredDefaultProvider(cli, cwd) {
+  if (cli?.provider) {
+    return assertDefaultProviderEnabled({ value: cli.provider, source: "cli" }, cwd);
+  }
+  const envProvider = process.env.BUILD_DEFAULT_PROVIDER;
+  if (envProvider) {
+    const normalized = envProvider.toLowerCase().trim();
+    if (PROVIDER_ID_PATTERN.test(normalized)) {
+      return assertDefaultProviderEnabled(
+        { value: normalized, source: "env", sourcePath: "env:BUILD_DEFAULT_PROVIDER" },
+        cwd
+      );
+    }
+    throw new InvalidExplicitConfigError(
+      "Invalid BUILD_DEFAULT_PROVIDER: expected a provider id containing only letters, digits, underscores, or hyphens"
+    );
+  }
+  const activeProfile = getActiveProfile();
+  if (activeProfile?.defaults?.provider) {
+    const normalized = activeProfile.defaults.provider.toLowerCase().trim();
+    if (PROVIDER_ID_PATTERN.test(normalized)) {
+      warnSetupProviderPin(activeProfile, normalized, () => loadConfigLayers(cwd));
+      return assertDefaultProviderEnabled(
+        {
+          value: normalized,
+          source: "profile",
+          sourcePath: `profile:${activeProfile.name}#defaults.provider`
+        },
+        cwd
+      );
+    }
+    throw new InvalidExplicitConfigError(
+      `Invalid default provider '${activeProfile.defaults.provider}' in active profile '${activeProfile.name}'`
+    );
+  }
+  const { paths, project, user } = loadConfigLayers(cwd);
+  if (project?.defaults?.provider) {
+    return assertDefaultProviderEnabled(
+      {
+        value: project.defaults.provider,
+        source: "project",
+        sourcePath: `${paths.projectConfigFile}#defaults.provider`
+      },
+      cwd
+    );
+  }
+  if (user?.defaults?.provider) {
+    return assertDefaultProviderEnabled(
+      {
+        value: user.defaults.provider,
+        source: "user-config",
+        sourcePath: `${paths.userConfigFile}#defaults.provider`
+      },
+      cwd
+    );
+  }
+  return void 0;
+}
+function declaredDefaultOverridingOwner(modelOwner, layerSource, cli, cwd) {
+  const declared = modelOwner ? resolveDeclaredDefaultProvider(cli, cwd) : void 0;
+  if (!declared) return void 0;
+  const provider = normalizeProviderId(declared.value);
+  const outranks = CONFIG_LAYER_PRECEDENCE.indexOf(declared.source) >= CONFIG_LAYER_PRECEDENCE.indexOf(layerSource);
+  return provider !== modelOwner && outranks ? { ...declared, value: provider } : void 0;
+}
+function filterRunnableProviderOrder(providerOrder, sourceLabel, cwd) {
+  const registry = loadProviderRegistryForCwd(cwd);
+  const filtered = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rawProvider of providerOrder) {
+    const normalized = normalizeProviderId(rawProvider.trim());
+    if (!normalized) continue;
+    const providerConfig = registry.providers[normalized] ?? registry.providers[rawProvider.trim()] ?? registry.providers[rawProvider];
+    if (!providerConfig) {
+      emitResolutionWarningOnce({
+        operation: "resolveCandidates",
+        provider: rawProvider,
+        source: sourceLabel,
+        message: `Skipping unknown provider '${rawProvider}' from ${sourceLabel}`
+      });
+      continue;
+    }
+    if (!providerConfig.enabled) {
+      emitResolutionWarningOnce({
+        operation: "resolveCandidates",
+        provider: providerConfig.id,
+        source: sourceLabel,
+        message: `Skipping disabled provider '${providerConfig.id}' from ${sourceLabel}`
+      });
+      continue;
+    }
+    if (!seen.has(providerConfig.id)) {
+      seen.add(providerConfig.id);
+      filtered.push(providerConfig.id);
+    }
+  }
+  return filtered;
+}
+function resolveConfiguredProviderOrder(options) {
+  const { cwd, purpose } = options;
+  const profile = getActiveProfile();
+  const { paths, project, user } = loadConfigLayers(cwd);
+  const layers = [
+    ...profile ? [
+      {
+        defaults: profile.defaults,
+        source: "profile",
+        path: `profile:${profile.name}`
+      }
+    ] : [],
+    { defaults: project?.defaults, source: "project", path: paths.projectConfigFile },
+    { defaults: user?.defaults, source: "user-config", path: paths.userConfigFile }
+  ];
+  for (const layer of layers) {
+    const lists = [{ key: "defaults.providerOrder", order: layer.defaults?.providerOrder }];
+    if (purpose) {
+      const key = RETIRED_PURPOSE_ORDER_KEYS[purpose];
+      lists.unshift({ key, order: retiredPurposeOrder(layer.defaults, purpose) });
+    }
+    const found = lists.find((list) => list.order && list.order.length > 0);
+    if (!found?.order) continue;
+    const sourcePath = `${layer.path}#${found.key}`;
+    const providers = filterRunnableProviderOrder(
+      found.order,
+      `${layer.source}:${sourcePath}`,
+      cwd
+    );
+    const unusable = providers.length > 0 ? void 0 : `${sourcePath} lists no known, enabled provider (${found.order.join(", ")}). Enable one of the listed providers in providers.yaml, or change the list.`;
+    return { providers, source: layer.source, sourcePath, ...unusable ? { unusable } : {} };
+  }
+  const registry = loadProviderRegistryForCwd(cwd);
+  const registryPath = ProviderRegistry.getLoadedConfigPath() ?? resolveProvidersConfigPath({ cwd });
+  return {
+    providers: ProviderRegistry.getEnabledProviders(registry).map((provider) => provider.id),
+    source: "registry",
+    sourcePath: `${registryPath}#providers.*.order`
+  };
+}
+var orderScope = new AsyncLocalStorage();
+function withReadOnlyProviderOrder(fn) {
+  return orderScope.run({ ...orderScope.getStore(), readOnly: true }, fn);
+}
+function enterReadOnlyProviderOrderView() {
+  orderScope.enterWith({ ...orderScope.getStore(), readOnly: true });
+}
+function withPurposeProviderOrder(cwd, purpose, fn) {
+  let governing;
+  const resolveGoverning = () => {
+    governing ??= resolveConfiguredProviderOrder({ cwd, purpose });
+    return governing;
+  };
+  return orderScope.run({ ...orderScope.getStore(), governing: resolveGoverning }, fn);
+}
+function assertUsableProviderOrder(order, selected) {
+  if (order.unusable && selected.length === 0 && !orderScope.getStore()?.readOnly) {
+    throw new InvalidExplicitConfigError(order.unusable);
+  }
+}
+function resolveFallbackProviderOrder(cwd) {
+  const globalOrder = resolveConfiguredProviderOrder({ cwd });
+  const order = globalOrder.unusable && orderScope.getStore()?.governing?.() || globalOrder;
+  assertUsableProviderOrder(order, order.providers);
+  return order;
+}
+function keepInstalledProviders(providers, registry) {
+  const installed = providers.filter((provider) => isProviderCliResolvable(provider, registry));
+  return installed.length > 0 ? { providers: installed, installedFilterApplied: true } : { providers, installedFilterApplied: false };
+}
+function firstInstalledProvider(providers, registry) {
+  return providers.find((provider) => isProviderCliResolvable(provider, registry)) ?? providers[0];
+}
+function resolveProviderOrder(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const configured = resolveConfiguredProviderOrder({ cwd });
+  const preferred = resolveDeclaredDefaultProvider(options.cli, cwd);
+  const ordered = preferred ? [preferred.value, ...configured.providers.filter((id) => id !== preferred.value)] : configured.providers;
+  const installed = keepInstalledProviders(ordered, loadProviderRegistryForCwd(cwd));
+  return {
+    ...configured,
+    ...installed,
+    ordered,
+    configured: configured.providers,
+    ...preferred ? { preferred } : {}
+  };
+}
+
+// src/core/config/default-judge-provider.ts
+var REGISTRY_DEFAULT_JUDGE_SOURCE_PATH = "registry:default-judge";
+var NoEligibleArbiterError = class extends Error {
+  constructor() {
+    super("No registered provider can fill arbiter-capable judge roles.");
+    this.name = "NoEligibleArbiterError";
+  }
+};
+function canJudgeAndArbitrate(providerId) {
+  const caps = ProviderRegistry.getJudgeCapabilities(providerId);
+  return caps.canJudge && caps.canArbitrate;
+}
+function selectFromConfiguredOrder(cwd, registry) {
+  const order = resolveConfiguredProviderOrder({ cwd });
+  if (order.source === "registry") return void 0;
+  const capable = order.providers.filter(canJudgeAndArbitrate);
+  const value = capable.find((provider) => isProviderCliResolvable(provider, registry)) ?? capable[0];
+  return value ? { value, source: "registry", sourcePath: order.sourcePath } : void 0;
+}
+function selectDefaultJudgeProvider(registry, cwd = process.cwd()) {
+  const fromOrder = selectFromConfiguredOrder(cwd, registry);
+  if (fromOrder) return fromOrder;
+  const installed = firstInstalledEnabledProvider(
+    registry,
+    (provider) => canJudgeAndArbitrate(provider.id)
+  );
+  if (installed) {
+    return {
+      value: installed,
+      source: "registry",
+      sourcePath: REGISTRY_DEFAULT_JUDGE_SOURCE_PATH
+    };
+  }
+  const capable = ProviderRegistry.getEnabledProviders(registry).find(
+    (provider) => canJudgeAndArbitrate(provider.id)
+  );
+  if (capable) {
+    return {
+      value: capable.id,
+      source: "fallback",
+      sourcePath: "judge-default:capable-provider"
+    };
+  }
+  throw new NoEligibleArbiterError();
+}
+
+// src/core/config/git-attribution.ts
+import { dirname, join as join3 } from "path";
+
+// src/core/guard-kit/attribution-policy.ts
+import * as fs from "fs";
+import * as path2 from "path";
+
+// src/core/guard-kit/paths.ts
+import * as path from "path";
+var GUARD_DIR_REL = path.join(".build-project", "guard");
+var CHECK_SCRIPT_REL = "check.mjs";
+var CONFIG_FILE_REL = "config.json";
+var POLICY_FILE_REL = "policy.json";
+var LOCK_FILE_REL = "checks.lock";
+var SETUP_PLAYBOOK_REL = "GUARD_SETUP.md";
+var CI_WORKFLOW_TEMPLATE_FILE = "build-guard.yml.template";
+var GENERATED_HASHED_FILES = [CHECK_SCRIPT_REL, POLICY_FILE_REL];
+function getGuardKitTemplatesDir() {
+  return path.join(getPackageRoot(), "templates", "guard-kit");
+}
+
+// src/core/guard-kit/attribution-policy.ts
+var HUMAN_ONLY_BOT_ALLOWLIST = [
+  "dependabot[bot]",
+  "github-actions[bot]",
+  "renovate[bot]"
+];
+function buildAttributionPolicy(input) {
+  return {
+    attribution: input.mode,
+    botAllow: [...HUMAN_ONLY_BOT_ALLOWLIST],
+    catalog: {
+      identities: [...input.catalog.identities],
+      trailerKeys: [...input.catalog.trailerKeys],
+      bylines: [...input.catalog.bylines],
+      bylineRegexSources: [...input.catalog.bylineRegexSources]
+    }
+  };
+}
+function readAttributionPolicy(repoRoot) {
+  const policyPath = path2.join(repoRoot, GUARD_DIR_REL, POLICY_FILE_REL);
+  let raw;
+  try {
+    if (!fs.lstatSync(policyPath).isFile()) {
+      return {
+        status: "invalid",
+        reason: "policy must be a regular file, not a symlink or directory"
+      };
+    }
+    raw = fs.readFileSync(policyPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return { status: "missing" };
+    return { status: "invalid", reason: error instanceof Error ? error.message : String(error) };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    return { status: "invalid", reason: error instanceof Error ? error.message : String(error) };
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return { status: "invalid", reason: "policy is not a JSON object" };
+  }
+  if (Array.isArray(parsed)) {
+    return { status: "invalid", reason: "policy is not a JSON object" };
+  }
+  const candidate = parsed;
+  if (candidate.attribution !== "allow" && candidate.attribution !== "human-only") {
+    return { status: "invalid", reason: 'attribution must be "allow" or "human-only"' };
+  }
+  if (candidate.botAllow !== void 0 && !isStringList(candidate.botAllow)) {
+    return { status: "invalid", reason: "botAllow must be an array of non-empty strings" };
+  }
+  const catalog = candidate.catalog;
+  if (!catalog || typeof catalog !== "object" || Array.isArray(catalog)) {
+    return { status: "invalid", reason: "catalog must be an object" };
+  }
+  for (const key of ["identities", "trailerKeys", "bylines", "bylineRegexSources"]) {
+    const value = catalog[key];
+    if (value !== void 0 && !isStringList(value)) {
+      return { status: "invalid", reason: `catalog.${key} must be an array of non-empty strings` };
+    }
+  }
+  return { status: "ok", policy: candidate };
+}
+function isStringList(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string" && entry.length > 0);
+}
+
+// src/core/config/git-attribution.ts
+function resolveGitAttributionFromLayers(options) {
+  if (options.project?.git?.attribution) {
+    return {
+      value: options.project.git.attribution,
+      source: "project",
+      sourcePath: `${options.projectConfigFile}#git.attribution`
+    };
+  }
+  const repoRoot = dirname(dirname(dirname(options.projectConfigFile)));
+  const policyPath = join3(repoRoot, ".build-project", "guard", "policy.json");
+  const policy = readAttributionPolicy(repoRoot);
+  if (policy.status === "invalid" && !options.ignoreInvalidGuardPolicy) {
+    throw new InvalidExplicitConfigError(
+      `Invalid Guard attribution policy ${policyPath}: ${policy.reason}`
+    );
+  }
+  if (policy.status === "ok") {
+    return {
+      value: policy.policy.attribution,
+      source: "project",
+      sourcePath: `${policyPath}#attribution`
+    };
+  }
+  const user = options.readUser();
+  if (user?.git?.attribution) {
+    return {
+      value: user.git.attribution,
+      source: "user-config",
+      sourcePath: `${options.userConfigFile}#git.attribution`
+    };
+  }
+  return { value: "allow", source: "fallback" };
+}
+
+// src/core/config/fast-model.ts
+function resolveFastModel(provider, { cwd = process.cwd(), registry } = {}) {
+  const profile = getActiveProfile();
+  const { paths, project, user } = loadConfigLayers(cwd);
+  const keyPath = `defaults.providers.${provider}.fastModel`;
+  const configured = [
+    [profile?.defaults?.providers?.[provider]?.fastModel, "profile", `profile:${profile?.name}`],
+    [project?.defaults?.providers?.[provider]?.fastModel, "project", paths.projectConfigFile],
+    [user?.defaults?.providers?.[provider]?.fastModel, "user-config", paths.userConfigFile]
+  ];
+  for (const [value, source, file] of configured) {
+    if (!value) continue;
+    const sourcePath = `${file}#${keyPath}`;
+    validateModelForProvider(provider, value, sourcePath, cwd);
+    return { value, source, sourcePath, slot: "user" };
+  }
+  const slotModel = ProviderRegistry.getModelForRole(provider, "fast", registry);
+  if (slotModel) {
+    return {
+      value: slotModel,
+      source: "registry",
+      sourcePath: `providers.yaml#providers.${provider}.models.roles.fast`,
+      slot: "registry"
+    };
+  }
+  const defaultModel = resolveProviderModel(provider, void 0, cwd);
+  return {
+    value: defaultModel.value,
+    source: defaultModel.source,
+    sourcePath: `fast-model:${provider} has no fast model configured; falls back to the default model`,
+    slot: "default"
+  };
+}
+function hasDistinctFastModel(provider, model, options = {}) {
+  const fast = resolveFastModel(provider, options);
+  if (fast.slot === "default") return false;
+  const { registry } = options;
+  const selected = normalizeModelSelectorForComparison(ProviderRegistry.resolveModel(provider, model, registry));
+  const fastId = normalizeModelSelectorForComparison(ProviderRegistry.resolveModel(provider, fast.value, registry));
+  if (selected === fastId) return true;
+  const config = ProviderRegistry.getProviderConfig(provider, registry);
+  const selectedEntry = config.models.available.find(
+    (entry) => modelSelectors(entry).some((selector) => normalizeModelSelectorForComparison(selector) === selected)
+  );
+  const fastEntry = config.models.available.find(
+    (entry) => modelSelectors(entry).some((selector) => normalizeModelSelectorForComparison(selector) === fastId)
+  );
+  if (selectedEntry && selectedEntry === fastEntry) return true;
+  const role = config.models.roles?.fast;
+  if (!role || !isFamilyAlias(provider, role, registry)) return false;
+  const flagship = familyFlagshipModel(provider, role, registry);
+  return Boolean(
+    selectedEntry && (modelFamilies(selectedEntry).some(
+      (family) => normalizeModelSelectorForComparison(family) === normalizeModelSelectorForComparison(role)
+    ) || flagship?.lineage && selectedEntry.lineage === flagship.lineage)
+  );
+}
+function modelSelectors(entry) {
+  return [entry.id, ...entry.full_name ? [entry.full_name] : [], ...listModelRouteIds(entry)];
+}
+
+// src/core/config/judge-coherence.ts
+var DEPRECATED_JUDGE_MODELS_ALIASES = ["claude", "codex"];
+var JUDGE_SPECIFICITY = {
+  cli: 100,
+  env: 90,
+  /** Per-judge config block: `judge.<tier>.{provider,model}` */
+  perJudge: 80,
+  /** All-judge config: root `judge.{provider,model}` */
+  allJudge: 70,
+  /** Legacy `defaults.judge.{provider,model}` */
+  legacyDefaults: 60,
+  profile: 55,
+  /** Compete shorthand plan / `--judge-models` role spec (provider-coherent by construction) */
+  plan: 30,
+  /** Derived registry/role/default values */
+  derived: 0
+};
+function coherentJudgeModelForProvider(provider, registryOverride) {
+  try {
+    const roleModel = ProviderRegistry.getModelForRole(provider, "judge_primary", registryOverride);
+    if (roleModel) return roleModel;
+    const defaultModel = ProviderRegistry.getProviderConfig(provider, registryOverride).models.default;
+    if (defaultModel) {
+      return ProviderRegistry.resolveModel(provider, defaultModel, registryOverride);
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function judgeModelMatchesProvider(provider, model, registryOverride) {
+  try {
+    ProviderRegistry.resolveModel(provider, model, registryOverride);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function inferProviderFromRegistryOwnership(model, registryOverride) {
+  const trimmed = model.trim();
+  if (!trimmed) return void 0;
+  const owners = [];
+  for (const provider of ProviderRegistry.getEnabledProviders(registryOverride)) {
+    let config;
+    try {
+      config = ProviderRegistry.getProviderConfig(provider.id, registryOverride);
+    } catch {
+      continue;
+    }
+    const availableIds = config.models.available?.map((info) => info.id) ?? [];
+    const mappingKeys = Object.keys(config.models.mappings ?? {});
+    if (availableIds.includes(trimmed) || mappingKeys.includes(trimmed) || isFamilyAlias(provider.id, trimmed, registryOverride)) {
+      owners.push(provider.id);
+    }
+  }
+  return owners.length === 1 ? owners[0] : void 0;
+}
+function reconcileJudgePair(provider, model, registryOverride) {
+  if (!model || !model.value || model.value === "auto") {
+    return { provider: provider.value, model: model?.value, changed: "none" };
+  }
+  if (model.specificity > provider.specificity) {
+    const owner = inferProviderFromRegistryOwnership(model.value, registryOverride);
+    if (owner && owner !== provider.value) {
+      return { provider: owner, model: model.value, changed: "provider" };
+    }
+  }
+  if (judgeModelMatchesProvider(provider.value, model.value, registryOverride)) {
+    return { provider: provider.value, model: model.value, changed: "none" };
+  }
+  if (model.specificity > provider.specificity) {
+    const owner = inferProviderFromRegistryOwnership(model.value, registryOverride);
+    if (owner) {
+      return { provider: owner, model: model.value, changed: "provider" };
+    }
+  }
+  const coherent = coherentJudgeModelForProvider(provider.value, registryOverride);
+  if (coherent) {
+    return { provider: provider.value, model: coherent, changed: "model" };
+  }
+  return { provider: provider.value, model: "auto", changed: "model-cleared" };
+}
+var JUDGE_TYPE_TO_ROLE = {
+  ai: "ai-primary",
+  "multi-lens": "multi-lens-technical"
+};
+var ALL_JUDGE_ROLES = ["ai-primary", "multi-lens-technical"];
+function rolesForActiveJudgeTypes(activeJudgeTypes) {
+  if (!activeJudgeTypes) {
+    return ALL_JUDGE_ROLES;
+  }
+  const activeRoles = /* @__PURE__ */ new Set();
+  for (const judgeType of activeJudgeTypes) {
+    if (judgeType === "ai") {
+      activeRoles.add("ai-primary");
+    } else {
+      activeRoles.add("multi-lens-technical");
+    }
+  }
+  return ALL_JUDGE_ROLES.filter((role) => activeRoles.has(role));
+}
+var ROLE_TO_JUDGE_TYPE = {
+  "ai-primary": "ai",
+  "multi-lens-technical": "multi-lens"
+};
+var OVERRIDE_ROLE_TO_JUDGE_ROLE = {
+  ai: "ai-primary",
+  "multi-lens": "multi-lens-technical"
+};
+var ARBITER_ROLES = /* @__PURE__ */ new Set(["ai-primary", "multi-lens-technical"]);
+var OVERRIDE_ROLE_EFFORT_SETTING = {
+  ai: "judge.ai.reasoningEffort (or judge.reasoningEffort)",
+  "multi-lens": "judge.multiLens.reasoningEffort (or judge.reasoningEffort)"
+};
+function parseJudgeModelOverride(value) {
+  const [rawRole, rawTarget] = value.split("=", 2);
+  const role = rawRole?.trim();
+  if (!role || !(role in OVERRIDE_ROLE_TO_JUDGE_ROLE) || !rawTarget?.trim()) {
+    throw new Error(
+      `Invalid --judge-model value "${value}". Expected <role>=<provider>:<model> where role is ai or multi-lens.`
+    );
+  }
+  const separator = rawTarget.indexOf(":");
+  if (separator <= 0 || separator === rawTarget.length - 1) {
+    throw new Error(`Invalid --judge-model value "${value}". Expected <role>=<provider>:<model>.`);
+  }
+  const provider = rawTarget.slice(0, separator).trim();
+  const model = rawTarget.slice(separator + 1).trim();
+  const lastSegment = model.slice(model.lastIndexOf(":") + 1);
+  if (model.includes(":") && (lastSegment.startsWith("effort-") || parseEffortToken(lastSegment, true))) {
+    throw new Error(
+      `Invalid --judge-model value "${value}". Inline effort "${lastSegment}" is not supported here; the grammar is ${role}=<provider>:<model> (effort levels: low, medium, high, extra-high, max). Set the ${role} judge effort with ${OVERRIDE_ROLE_EFFORT_SETTING[role]} in config.`
+    );
+  }
+  return { role, provider, model };
+}
+function resolveRoleModel(provider, modelRole, registryOverride) {
+  if (modelRole === "fast") {
+    const fastModel = resolveFastModel(provider, { registry: registryOverride }).value;
+    return ProviderRegistry.resolveModel(provider, fastModel, registryOverride);
+  }
+  const roleModel = ProviderRegistry.getModelForRole(provider, modelRole, registryOverride);
+  if (roleModel) {
+    return roleModel;
+  }
+  const defaultModel = ProviderRegistry.getDefaultModel(provider, registryOverride);
+  if (defaultModel) {
+    return ProviderRegistry.resolveModel(provider, defaultModel, registryOverride);
+  }
+  throw new Error(
+    `Judge model resolution references provider "${provider}" role "${modelRole}", but that role is not configured.`
+  );
+}
+function isProviderFastModel(provider, model, registryOverride) {
+  try {
+    return hasDistinctFastModel(provider, model, { registry: registryOverride });
+  } catch (error) {
+    if (error instanceof InvalidProviderModelError) throw error;
+    return false;
+  }
+}
+function formatFastJudgeModelError(roles, registryOverride) {
+  const lines = ["Deciding judges are configured to use fast models:"];
+  const replacements = [];
+  for (const role of roles) {
+    const alias = role.judgeType;
+    lines.push(`  ${alias}: ${role.provider}:${role.model} (${role.source})`);
+    const quality = ProviderRegistry.getModelForRole(
+      role.provider,
+      "judge_primary",
+      registryOverride
+    );
+    if (quality && !isProviderFastModel(role.provider, quality, registryOverride)) {
+      replacements.push(
+        `--judge-model ${quotePosixShellArg(`${alias}=${role.provider}:${quality}`)}`
+      );
+    } else {
+      lines.push(`  ${role.provider} has no non-fast judge_primary model configured.`);
+    }
+  }
+  lines.push(
+    "Judges that decide the winner should use a quality model; fast models may gather evidence."
+  );
+  if (replacements.length > 0) lines.push(`Recommended: ${replacements.join(" ")}`);
+  lines.push("To deliberately use the selected models, add --judge-force-model.");
+  lines.push(
+    "Their verdicts will be used, but judge calibration will be marked invalid for this run."
+  );
+  return lines.join("\n");
+}
+function mergeCalibrationReasons(...reasons) {
+  const merged = /* @__PURE__ */ new Set();
+  for (const reason of reasons) {
+    for (const part of reason?.split(",") ?? []) {
+      const trimmed = part.trim();
+      if (trimmed) merged.add(trimmed);
+    }
+  }
+  return merged.size > 0 ? Array.from(merged).join(",") : void 0;
+}
+function getResolvedRole(resolution, role) {
+  return resolution?.resolvedRoles.find((entry) => entry.role === role);
+}
+function assertJudgeRoleCapabilities(role, provider) {
+  const caps = ProviderRegistry.getJudgeCapabilities(provider);
+  if (ARBITER_ROLES.has(role) && !caps.canArbitrate) {
+    throw new Error(
+      `Judge role "${role}" resolved to provider "${provider}", but that provider cannot arbitrate (registry canArbitrate=false).`
+    );
+  }
+  if (!caps.canJudge) {
+    throw new Error(
+      `Judge role "${role}" resolved to provider "${provider}", but that provider cannot fill generic judge roles (registry canJudge=false).`
+    );
+  }
+}
+function assertArbiterFamilyDisjointness(resolvedRoles, registryOverride) {
+  const familyToProviders = /* @__PURE__ */ new Map();
+  for (const entry of resolvedRoles) {
+    if (!ARBITER_ROLES.has(entry.role)) continue;
+    const provider = entry.provider.trim().toLowerCase();
+    const patternOwner = ProviderRegistry.resolveProviderByModel(entry.model, registryOverride);
+    const uniqueOwner = inferProviderFromRegistryOwnership(entry.model, registryOverride);
+    const family = ProviderRegistry.getProviderFamily(
+      patternOwner ?? uniqueOwner ?? provider,
+      registryOverride
+    );
+    const members = familyToProviders.get(family) ?? /* @__PURE__ */ new Set();
+    members.add(provider);
+    familyToProviders.set(family, members);
+  }
+  const collisions = [...familyToProviders.entries()].filter(([, members]) => members.size > 1);
+  if (collisions.length === 0) return;
+  const detail = collisions.map(([family, members]) => `family "${family}" used by ${[...members].sort().join(", ")}`).join("; ");
+  throw new Error(
+    `Same-family arbiter panel is not independent: ${detail}. Arbiter-capable roles must use disjoint model families when independence is required.`
+  );
+}
+function resolveCanonicalJudgeRoles(options) {
+  const overrideByRole = /* @__PURE__ */ new Map();
+  for (const override of options.scopedModelOverrides ?? []) {
+    overrideByRole.set(OVERRIDE_ROLE_TO_JUDGE_ROLE[override.role], override);
+  }
+  const resolvedRoles = [];
+  const fastArbiters = [];
+  let calibrationValid = true;
+  const calibrationReasons = /* @__PURE__ */ new Set();
+  const orderedRoles = rolesForActiveJudgeTypes(options.activeJudgeTypes);
+  for (const role of orderedRoles) {
+    const roleSpec = options.plan[role];
+    const bound = roleSpec.model !== void 0;
+    const override = bound ? void 0 : overrideByRole.get(role);
+    const legacyAiModel = role === "ai-primary" && !override && !bound ? options.normalizeExplicitModel ? options.normalizeExplicitModel(options.explicitModel) : options.explicitModel : void 0;
+    let provider = override?.provider ?? roleSpec.provider;
+    let requestedModel = roleSpec.model ?? (legacyAiModel ? legacyAiModel : override ? ProviderRegistry.resolveModel(provider, override.model, options.registryOverride) : resolveRoleModel(provider, roleSpec.modelRole, options.registryOverride));
+    if (legacyAiModel) {
+      const reconciled = reconcileJudgePair(
+        { value: provider, specificity: JUDGE_SPECIFICITY.plan },
+        { value: requestedModel, specificity: JUDGE_SPECIFICITY.cli },
+        options.registryOverride
+      );
+      provider = reconciled.provider;
+      if (reconciled.model) {
+        requestedModel = reconciled.model;
+      }
+    }
+    const source = legacyAiModel ? "legacy_ai_judge_model" : override ? "scoped_override" : roleSpec.source ?? options.planSource;
+    const model = requestedModel;
+    const modelRole = legacyAiModel || override || roleSpec.explicit ? "explicit" : roleSpec.modelRole;
+    assertJudgeRoleCapabilities(role, provider);
+    options.validateBackendSupport?.(role, provider);
+    const fastArbiter = ARBITER_ROLES.has(role) && isProviderFastModel(provider, model, options.registryOverride);
+    if (fastArbiter && options.allowUnsafeModel) {
+      calibrationValid = false;
+      calibrationReasons.add("unsafe_model_override");
+    }
+    const resolvedRole = {
+      role,
+      judgeType: ROLE_TO_JUDGE_TYPE[role],
+      provider,
+      modelRole,
+      model,
+      source,
+      ...fastArbiter && options.allowUnsafeModel ? { qualityFloorOverride: true } : {}
+    };
+    resolvedRoles.push(resolvedRole);
+    if (fastArbiter) fastArbiters.push(resolvedRole);
+  }
+  if (fastArbiters.length > 0 && !options.allowUnsafeModel) {
+    throw new Error(formatFastJudgeModelError(fastArbiters, options.registryOverride));
+  }
+  const panelProviders = new Set(
+    resolvedRoles.filter((role) => role.role === "ai-primary" || role.role === "multi-lens-technical").map((role) => role.provider)
+  );
+  calibrationReasons.add(`panel_providers=${Array.from(panelProviders).sort().join("+")}`);
+  if (new Set(resolvedRoles.map((role) => role.provider)).size > 1) {
+    calibrationReasons.add("mixed_providers");
+  }
+  if (overrideByRole.size > 0) {
+    calibrationReasons.add("scoped_override");
+  }
+  if (options.explicitModel && !overrideByRole.has("ai-primary")) {
+    calibrationReasons.add("legacy_ai_judge_model");
+  }
+  const activeArbiterCount = resolvedRoles.filter((entry) => ARBITER_ROLES.has(entry.role)).length;
+  if (activeArbiterCount >= 2) {
+    assertArbiterFamilyDisjointness(resolvedRoles, options.registryOverride);
+  }
+  return {
+    judgeModels: options.planId,
+    source: options.planSource,
+    resolvedRoles,
+    overrides: Array.from(new Set((options.scopedModelOverrides ?? []).map((o) => o.role))),
+    calibrationValid,
+    calibrationReason: Array.from(calibrationReasons).join(",")
+  };
+}
+function resolveCanonicalJudgeTier(options) {
+  const { judgeType, judgeConfig } = options;
+  const judgeModelResolution = resolveCanonicalJudgeRoles({
+    ...options,
+    activeJudgeTypes: [judgeType]
+  });
+  const scoringTier = (() => {
+    const tiers = JUDGE_SCORING_CONFIG.tiers;
+    if (judgeType === "ai") return tiers.ai;
+    return tiers.multiLens;
+  })();
+  const role = JUDGE_TYPE_TO_ROLE[judgeType];
+  const planRole = getResolvedRole(judgeModelResolution, role);
+  const scoringDefaults = {
+    ...planRole ? { provider: planRole.provider } : {},
+    ...planRole?.model ? { model: planRole.model } : {},
+    ...scoringTier.thinkingBudgetTokens !== void 0 ? { thinkingBudgetTokens: scoringTier.thinkingBudgetTokens } : void 0,
+    ...scoringTier.requireThinking !== void 0 ? { requireThinking: scoringTier.requireThinking } : void 0
+  };
+  const tierOverride = (() => {
+    if (!judgeConfig) return void 0;
+    if (judgeType === "ai") return judgeConfig.ai;
+    return judgeConfig.multiLens;
+  })();
+  const {
+    provider: _tierProvider,
+    model: _tierModel,
+    reasoningEffort: _tierEffort,
+    ...tierExtras
+  } = tierOverride ?? {};
+  const allJudgeExtras = Object.fromEntries(
+    Object.entries({
+      prompt: judgeType === "ai" ? judgeConfig?.prompt : void 0,
+      thinkingBudgetTokens: judgeType === "ai" ? judgeConfig?.thinkingBudgetTokens : void 0,
+      requireThinking: judgeType === "ai" ? judgeConfig?.requireThinking : void 0
+    }).filter(([, v]) => v !== void 0)
+  );
+  const resolved = {
+    ...scoringDefaults,
+    ...allJudgeExtras,
+    ...tierExtras,
+    ...options.reasoningEffort ? { reasoningEffort: options.reasoningEffort } : {}
+  };
+  resolved.judgeModels = judgeModelResolution.judgeModels;
+  resolved.judgeModelResolvedRoles = judgeModelResolution.resolvedRoles;
+  resolved.judgeModelOverrides = judgeModelResolution.overrides;
+  resolved.calibrationValid = (resolved.calibrationValid ?? true) && judgeModelResolution.calibrationValid;
+  resolved.calibrationReason = mergeCalibrationReasons(
+    judgeModelResolution.calibrationReason,
+    resolved.calibrationReason
+  );
+  return resolved;
+}
+
+// src/core/config/judge-binding.ts
+var JUDGE_TYPE_TO_CONFIG_KEY = {
+  ai: "ai",
+  "multi-lens": "multiLens"
+};
+function judgeLayerBlocks(config, pathPrefix, judgeType) {
+  if (!config) return [];
+  const blocks = [];
+  const add = (fields, keyPath) => {
+    if (!fields) return;
+    blocks.push({
+      provider: fields.provider,
+      model: fields.model,
+      reasoningEffort: fields.reasoningEffort,
+      sourcePath: (field) => `${pathPrefix}${keyPath}.${field}`
+    });
+  };
+  if (judgeType) {
+    const tierKey = JUDGE_TYPE_TO_CONFIG_KEY[judgeType];
+    add(config.judge?.[tierKey], `judge.${tierKey}`);
+  }
+  add(config.judge, "judge");
+  add(config.defaults?.judge, "defaults.judge");
+  return blocks;
+}
+function pickField(blocks, field) {
+  for (const [index, block] of blocks.entries()) {
+    const value = block[field];
+    if (value) {
+      const sourcePath = block.sourcePath(field);
+      return { value: String(value), block: index, ...sourcePath ? { sourcePath } : {} };
+    }
+  }
+  return void 0;
+}
+function modelFitsProvider(provider, model) {
+  if (model === "auto") return true;
+  try {
+    ProviderRegistry.resolveModel(provider, model);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function collapseLayer(layer) {
+  const provider = pickField(layer.blocks, "provider");
+  const model = pickField(layer.blocks, "model");
+  const effortBlock = layer.blocks.find((block) => block.reasoningEffort);
+  const resolved = (field) => ({
+    value: field.value,
+    source: layer.source,
+    ...field.sourcePath ? { sourcePath: field.sourcePath } : {}
+  });
+  const effortPath = effortBlock?.sourcePath("reasoningEffort");
+  const collapsed = {
+    ...provider ? { provider: resolved(provider) } : {},
+    ...model ? { model: resolved(model) } : {},
+    ...effortBlock ? {
+      effort: {
+        value: effortBlock.reasoningEffort,
+        source: layer.source,
+        ...effortPath ? { sourcePath: effortPath } : {}
+      }
+    } : {}
+  };
+  if (!model || model.value === "auto") return collapsed;
+  if (!provider || model.block < provider.block) {
+    const owner = inferProviderFromRegistryOwnership(model.value);
+    if (owner && owner !== provider?.value) {
+      collapsed.provider = {
+        value: owner,
+        source: layer.source,
+        sourcePath: `${model.sourcePath ?? "judge.model"} (provider inferred from model)`
+      };
+      return collapsed;
+    }
+  }
+  if (provider && !modelFitsProvider(provider.value, model.value)) {
+    delete collapsed.model;
+    collapsed.droppedModel = resolved(model);
+    collapsed.droppedModelPairedWithProvider = model.block <= provider.block;
+  }
+  return collapsed;
+}
+function parseEffort(effort) {
+  const normalized = normalizeReasoningEffortInput(effort.value);
+  if (!normalized) {
+    throw new InvalidExplicitConfigError(
+      `Invalid judge reasoning effort at ${effort.sourcePath}: ${String(effort.value)}`
+    );
+  }
+  return {
+    value: normalized,
+    source: effort.source,
+    ...effort.sourcePath ? { sourcePath: effort.sourcePath } : {}
+  };
+}
+function isRegisteredProvider(provider) {
+  try {
+    ProviderRegistry.getProviderConfig(provider);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function mustFailUnusable(model, provider) {
+  if (model.value.trim().toLowerCase() === "default") return false;
+  const owner = inferProviderFromRegistryOwnership(model.value);
+  return owner !== void 0 && owner !== provider.value && isRegisteredProvider(provider.value);
+}
+function unusableJudgeModelError(model, provider) {
+  const modelAt = model.sourcePath ?? model.source;
+  const providerAt = provider.sourcePath ?? provider.source;
+  return new InvalidExplicitConfigError(
+    `Judge model "${model.value}" (${modelAt}) cannot run on judge provider "${provider.value}" (${providerAt}). Set a model that provider hosts, or set the judge provider that hosts it.`
+  );
+}
+function resolveJudgeBinding(input) {
+  const layers = input.layers.map(collapseLayer);
+  const provider = layers.find((layer) => layer.provider)?.provider ?? input.defaultProvider();
+  const pairsWithWinner = (layer) => !layer.provider || layer.provider.value === provider.value;
+  const providerLayer = layers.findIndex((layer) => layer.provider);
+  const outranking = providerLayer === -1 ? layers.length : providerLayer;
+  let model;
+  let reconciled = false;
+  for (const [index, layer] of layers.entries()) {
+    if (layer.droppedModel) {
+      if (layer.droppedModelPairedWithProvider && pairsWithWinner(layer) && mustFailUnusable(layer.droppedModel, provider)) {
+        throw unusableJudgeModelError(layer.droppedModel, provider);
+      }
+      reconciled = true;
+    }
+    if (!layer.model) continue;
+    const fits = layer.provider || modelFitsProvider(provider.value, layer.model.value);
+    if (pairsWithWinner(layer) && fits) {
+      model = layer.model;
+      break;
+    }
+    if (pairsWithWinner(layer) && index < outranking && mustFailUnusable(layer.model, provider)) {
+      throw unusableJudgeModelError(layer.model, provider);
+    }
+    reconciled = true;
+  }
+  if (!model) {
+    const derived = coherentJudgeModelForProvider(provider.value);
+    if (reconciled) {
+      model = {
+        value: derived ?? "auto",
+        source: "registry",
+        sourcePath: `providers.yaml#providers.${provider.value}.models (judge role, reconciled)`
+      };
+    } else if (derived) {
+      model = {
+        value: derived,
+        source: "registry",
+        sourcePath: `providers.yaml#providers.${provider.value}.models (judge role)`
+      };
+    } else {
+      model = { value: "auto", source: "fallback" };
+    }
+  }
+  const effortLayer = layers.find((layer) => layer.effort && pairsWithWinner(layer));
+  const reasoningEffort = effortLayer?.effort ? parseEffort(effortLayer.effort) : input.defaultEffort(provider);
+  return { provider, model, ...reasoningEffort ? { reasoningEffort } : {} };
+}
+
+// src/core/config/resolution-engine.ts
+function getConfigPaths2(cwd) {
+  const paths = getConfigPaths(cwd);
+  return {
+    ...paths,
+    projectConfigFile: selectedBuildConfigCandidate(paths.projectConfigFile),
+    userConfigFile: selectedBuildConfigCandidate(paths.userConfigFile)
+  };
+}
+var InvalidProviderModelError = class extends Error {
+  constructor(message, model, sourcePath) {
+    super(message);
+    this.model = model;
+    this.sourcePath = sourcePath;
+    this.name = "InvalidProviderModelError";
+  }
+  model;
+  sourcePath;
+};
+var EXECUTION_TRANSPORT_MODES = /* @__PURE__ */ new Set(["auto", "headless", "tmux-exec", "interactive"]);
+var CONFIGURABLE_EXECUTION_TRANSPORT_PROVIDERS = new Set(ENABLED_PROVIDER_IDS);
+function normalizeProviderId(provider) {
+  if (typeof provider !== "string" || provider.length === 0) {
+    return "";
+  }
+  const normalized = provider.toLowerCase();
+  if (normalized === "cursor-cli") return "cursor";
+  if (normalized === "copilot-cli") return "copilot";
+  if (normalized === "anti-gravity" || normalized === "antigravity-cli" || normalized === "agy") {
+    return "antigravity";
+  }
+  if (normalized === "openai" || normalized === "gpt") {
+    return "codex";
+  }
+  return normalized;
+}
+function normalizePlanExecuteBlockerMode(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "non-interactive" || normalized === "interactive") {
+    return normalized;
+  }
+  return void 0;
+}
+function normalizeExecutionTransportMode(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "interactive") {
+    return "tmux-exec";
+  }
+  if (EXECUTION_TRANSPORT_MODES.has(normalized)) {
+    return normalized;
+  }
+  return void 0;
+}
+function resolveDurablePlanExecuteBlockerMode(value, sourcePath) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = normalizePlanExecuteBlockerMode(value);
+  if (normalized) {
+    return normalized;
+  }
+  throw new Error(
+    `Invalid planExecute.blockerMode at ${sourcePath}: ${String(value)}. Expected non-interactive or interactive. questions-only is only valid as a CLI flag.`
+  );
+}
+function resolveDurableExecutionTransportMode(value, sourcePath) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = normalizeExecutionTransportMode(value);
+  if (normalized) {
+    return normalized;
+  }
+  throw new Error(
+    `Invalid execution.transport value at ${sourcePath}: ${String(value)}. Expected auto, headless, or tmux-exec (interactive is a deprecated alias).`
+  );
+}
+function validateExecutionTransportProviderMap(providers, sourcePath) {
+  if (!providers) return;
+  for (const provider of Object.keys(providers)) {
+    if (!CONFIGURABLE_EXECUTION_TRANSPORT_PROVIDERS.has(provider)) {
+      throw new Error(
+        `Invalid execution.transport.providers key at ${sourcePath}: ${provider}. Known providers: ${[...CONFIGURABLE_EXECUTION_TRANSPORT_PROVIDERS].sort().join(", ")}.`
+      );
+    }
+  }
+}
+function inferProviderFromModel(model, cwd) {
+  if (!model || model.trim().length === 0) {
+    return void 0;
+  }
+  const trimmed = model.trim();
+  const registry = loadProviderRegistryForCwd(cwd);
+  const colonIdx = trimmed.indexOf(":");
+  if (colonIdx > 0) {
+    const provider = normalizeProviderId(trimmed.slice(0, colonIdx));
+    if (Object.hasOwn(registry.providers, provider)) {
+      return provider;
+    }
+  }
+  return inferProviderFromRegistryOwnership(trimmed, registry) ?? inferProviderFromRouteOwnership(trimmed, registry);
+}
+function inferProviderFromRouteOwnership(model, registry) {
+  const owners = ProviderRegistry.getEnabledProviders(registry).filter((provider) => {
+    try {
+      const rows = ProviderRegistry.getProviderConfig(provider.id, registry).models.available;
+      return rows?.some((row) => listModelRouteIds(row).includes(model)) ?? false;
+    } catch {
+      return false;
+    }
+  });
+  return owners.length === 1 ? owners[0]?.id : void 0;
+}
+function validateModelForProvider(provider, model, sourcePath, cwd) {
+  try {
+    ProviderRegistry.resolveModel(provider, model, loadProviderRegistryForCwd(cwd));
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new InvalidProviderModelError(
+      `Invalid model '${model}' for provider '${provider}' at ${sourcePath}. Configure a matching provider explicitly or use a model supported by '${provider}'. ${detail}`,
+      model,
+      sourcePath
+    );
+  }
+}
+function resolveJudgeType(cli, cwd = process.cwd()) {
+  const paths = getConfigPaths2(cwd);
+  const normalizeJudgeType = (value) => {
+    if (!value) return void 0;
+    const retired = retiredJudgeSelectionError(value);
+    if (retired) throw retired;
+    const normalized = value.trim().toLowerCase();
+    return normalized === "ai" || normalized === "multi-lens" ? normalized : void 0;
+  };
+  const cliJudgeType = normalizeJudgeType(cli?.judgeType);
+  if (cliJudgeType) {
+    return { value: cliJudgeType, source: "cli", sourcePath: "cli:--judge-type" };
+  }
+  const envType = normalizeJudgeType(process.env.BUILD_JUDGE_TYPE);
+  if (envType) {
+    return {
+      value: envType,
+      source: "env",
+      sourcePath: "env:BUILD_JUDGE_TYPE"
+    };
+  }
+  const activeProfile = getActiveProfile();
+  if (activeProfile?.defaults?.judge?.type) {
+    const profileType = normalizeJudgeType(activeProfile.defaults.judge.type);
+    if (profileType) {
+      return {
+        value: profileType,
+        source: "profile",
+        sourcePath: `profile:${activeProfile.name}#defaults.judge.type`
+      };
+    }
+  }
+  const projectConfig = loadProjectConfig(cwd);
+  if (projectConfig?.defaults?.judge?.type) {
+    return {
+      value: projectConfig.defaults.judge.type,
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#defaults.judge.type`
+    };
+  }
+  const userConfig = loadUserConfig(cwd);
+  if (userConfig?.defaults?.judge?.type) {
+    return {
+      value: userConfig.defaults.judge.type,
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#defaults.judge.type`
+    };
+  }
+  warnIfLegacyConfigExists(cwd);
+  return { value: "ai", source: "fallback" };
+}
+function resolveConfigExecutionTransport(config, provider, source, configPath) {
+  const transport = config?.execution?.transport;
+  if (!transport) return void 0;
+  validateExecutionTransportProviderMap(
+    transport.providers,
+    `${configPath}#execution.transport.providers`
+  );
+  if (!CONFIGURABLE_EXECUTION_TRANSPORT_PROVIDERS.has(provider)) {
+    return void 0;
+  }
+  const providerValue = resolveDurableExecutionTransportMode(
+    transport.providers?.[provider],
+    `${configPath}#execution.transport.providers.${provider}`
+  );
+  if (providerValue) {
+    return {
+      value: providerValue,
+      source,
+      sourcePath: `${configPath}#execution.transport.providers.${provider}`
+    };
+  }
+  const defaultValue = resolveDurableExecutionTransportMode(
+    transport.default,
+    `${configPath}#execution.transport.default`
+  );
+  if (defaultValue) {
+    return {
+      value: defaultValue,
+      source,
+      sourcePath: `${configPath}#execution.transport.default`
+    };
+  }
+  return void 0;
+}
+var unifiedConfigCache = /* @__PURE__ */ new Map();
+var warnedKeys = /* @__PURE__ */ new Set();
+var legacyWarningShown = false;
+function warnIfLegacyConfigExists(cwd = process.cwd()) {
+  if (legacyWarningShown) return;
+  legacyWarningShown = true;
+  const legacyPaths = /* @__PURE__ */ new Set([join4(cwd, ".build-project", "config", "build.json")]);
+  legacyPaths.add(join4(getUserConfigDir(), "defaults.yaml"));
+  if (process.env.BUILD_DEFAULTS_PATH?.trim()) {
+    legacyPaths.add(process.env.BUILD_DEFAULTS_PATH.trim());
+  }
+  for (const p of legacyPaths) {
+    if (existsSync(p)) {
+      emitWarning(
+        "CFG-LEGACY",
+        {
+          taskId: "resolution-engine",
+          subsystem: "config",
+          executionPhase: "setup"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            message: `Found deprecated config file: ${p}. This file is no longer read. Move settings to the appropriate build.config.jsonc file.`,
+            path: p,
+            operation: "warnIfLegacyConfigExists"
+          }
+        }
+      );
+    }
+  }
+}
+function clearConfigCaches() {
+  unifiedConfigCache.clear();
+  warnedKeys.clear();
+  legacyWarningShown = false;
+  resetActiveProfileCache();
+  ProviderRegistry.reload();
+}
+function normalizeLoadedBuildConfig(configData, sourceFile) {
+  return normalizeLegacyIntoCanonical(configData, { sourceFile });
+}
+function loadBuildConfigFile(configPath) {
+  const fingerprint = fingerprintFile(configPath);
+  const cached = unifiedConfigCache.get(configPath);
+  if (cached && cached.fingerprint === fingerprint) {
+    if (cached.error) throw cached.error;
+    return cached.value ?? null;
+  }
+  const result = readCanonicalBuildConfig(configPath);
+  if (result.status === "missing") {
+    unifiedConfigCache.set(configPath, {
+      value: null,
+      error: null,
+      fingerprint
+    });
+    return null;
+  }
+  if (result.status === "invalid") {
+    unifiedConfigCache.set(configPath, {
+      value: null,
+      error: result.error,
+      fingerprint
+    });
+    throw result.error;
+  }
+  const normalizedConfig = normalizeLoadedBuildConfig(
+    result.config,
+    configPath
+  );
+  unifiedConfigCache.set(configPath, {
+    value: normalizedConfig,
+    error: null,
+    fingerprint
+  });
+  return normalizedConfig;
+}
+function loadBuildConfigFromCandidates(configPath) {
+  const candidates = buildConfigCandidates(configPath);
+  warnIfShadowedConfigCandidate(candidates);
+  for (const candidate of candidates) {
+    const config = loadBuildConfigFile(candidate);
+    if (config) return config;
+  }
+  return null;
+}
+function loadUserConfig(cwd = process.cwd()) {
+  const { userConfigFile } = getConfigPaths2(cwd);
+  return loadBuildConfigFromCandidates(userConfigFile);
+}
+function loadProjectConfig(cwd = process.cwd()) {
+  if (projectConfigAliasesUserConfig(cwd)) return null;
+  const { projectConfigFile } = getConfigPaths2(cwd);
+  return loadBuildConfigFromCandidates(projectConfigFile);
+}
+function loadConfigLayers(cwd = process.cwd()) {
+  const paths = getConfigPaths2(cwd);
+  return { paths, project: loadProjectConfig(cwd), user: loadUserConfig(cwd) };
+}
+function pickAskBudgetKeys(ask) {
+  if (!ask) return void 0;
+  return {
+    timeoutSeconds: ask.timeoutSeconds,
+    idleWarnSeconds: ask.idleWarnSeconds,
+    idleKillSeconds: ask.idleKillSeconds,
+    stdinDeadlineSeconds: ask.stdinDeadlineSeconds
+  };
+}
+function resolveAskConfig(cwd = process.cwd()) {
+  const userAsk = loadUserConfig(cwd)?.ask;
+  const projectAsk = loadProjectConfig(cwd)?.ask;
+  if (!userAsk && !projectAsk) return void 0;
+  return {
+    userPresets: userAsk?.presets,
+    projectPresets: projectAsk?.presets,
+    userBudget: pickAskBudgetKeys(userAsk),
+    projectBudget: pickAskBudgetKeys(projectAsk)
+  };
+}
+function resolveProgressNarrationConfig(cwd = process.cwd()) {
+  const paths = getConfigPaths2(cwd);
+  const projectNarration = loadProjectConfig(cwd)?.progressNarration;
+  if (projectNarration) {
+    return {
+      value: projectNarration,
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#progressNarration`
+    };
+  }
+  const userNarration = loadUserConfig(cwd)?.progressNarration;
+  if (userNarration) {
+    return {
+      value: userNarration,
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#progressNarration`
+    };
+  }
+  return void 0;
+}
+function resolveEphemeralTelemetryReplication(cwd = process.cwd()) {
+  const env = readEnv(BUILD_TELEMETRY_EPHEMERAL_REPLICATION);
+  if (env.source === "env") {
+    return {
+      value: env.value ?? true,
+      source: "env",
+      sourcePath: BUILD_TELEMETRY_EPHEMERAL_REPLICATION.name
+    };
+  }
+  const paths = getConfigPaths2(cwd);
+  const projectValue = loadProjectConfig(cwd)?.telemetry?.ephemeralReplication;
+  if (typeof projectValue === "boolean") {
+    return {
+      value: projectValue,
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#telemetry.ephemeralReplication`
+    };
+  }
+  const userValue = loadUserConfig(cwd)?.telemetry?.ephemeralReplication;
+  if (typeof userValue === "boolean") {
+    return {
+      value: userValue,
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#telemetry.ephemeralReplication`
+    };
+  }
+  return {
+    value: true,
+    source: "fallback",
+    sourcePath: "built-in:telemetry.ephemeralReplication"
+  };
+}
+function warnOnce(key, message) {
+  if (warnedKeys.has(key)) return;
+  warnedKeys.add(key);
+  emitWarning(
+    "CFG-004",
+    {
+      taskId: "resolution-engine",
+      subsystem: "config",
+      executionPhase: "setup"
+    },
+    {
+      severity: "WARN" /* WARN */,
+      metadata: {
+        message
+      }
+    }
+  );
+}
+function getProviderEnvModel(provider) {
+  const envModel = readProviderModelFromEnv(provider);
+  if (!envModel) return null;
+  if (envModel.kind === "standardized") {
+    return { value: envModel.value, source: "env", sourcePath: `env:${envModel.key}` };
+  }
+  const standardizedKey = `BUILD_${provider.toUpperCase()}_DEFAULT_MODEL`;
+  warnOnce(envModel.key, `${envModel.key} is deprecated. Use ${standardizedKey} instead.`);
+  return { value: envModel.value, source: "env-legacy", sourcePath: `env-legacy:${envModel.key}` };
+}
+function loadProviderRegistryForCwd(cwd) {
+  return ProviderRegistry.load(void 0, cwd);
+}
+function checkDefaultProviderEnablement(providerValue, cwd = process.cwd()) {
+  const providerId = normalizeProviderId(providerValue.trim());
+  const registry = loadProviderRegistryForCwd(cwd);
+  const registryPath = ProviderRegistry.getLoadedConfigPath() ?? resolveProvidersConfigPath({ cwd });
+  const providerConfig = registry.providers[providerId];
+  const enabledProviders = Object.values(registry.providers).filter((provider) => provider.enabled).sort((a, b) => a.order - b.order).map((provider) => provider.id);
+  return {
+    providerId,
+    providerKnown: Boolean(providerConfig),
+    providerEnabled: Boolean(providerConfig?.enabled),
+    knownProviders: Object.keys(registry.providers).sort(),
+    enabledProviders,
+    registryPath,
+    disabledBy: providerDisableSwitch(registry, providerId)
+  };
+}
+var DefaultProviderUnusableError = class extends Error {
+  code = "DEFAULT_PROVIDER_UNUSABLE";
+  reason;
+  constructor(message, reason) {
+    super(message);
+    this.name = "DefaultProviderUnusableError";
+    this.reason = reason;
+  }
+};
+function assertDefaultProviderEnabled(resolved, cwd) {
+  const check = checkDefaultProviderEnablement(resolved.value, cwd);
+  if (!check.providerKnown) {
+    throw new DefaultProviderUnusableError(
+      `Invalid default provider '${check.providerId}' from ${resolved.sourcePath ?? resolved.source}: provider is not available in providers.yaml. Available enabled providers: ${check.enabledProviders.join(", ") || "(none)"}.`,
+      "unknown"
+    );
+  }
+  if (!check.providerEnabled) {
+    const source = resolved.sourcePath ?? resolved.source;
+    throw new DefaultProviderUnusableError(
+      `Invalid default provider '${check.providerId}' from ${source}: provider is disabled ${check.disabledBy ? `by ${check.disabledBy}. Remove that setting` : `in ${check.registryPath}. Enable providers.${check.providerId}.enabled`} or choose an enabled provider.`,
+      "disabled"
+    );
+  }
+  return { ...resolved, value: check.providerId };
+}
+function resolveDefaultProvider(cli, cwd = process.cwd()) {
+  const declared = resolveDeclaredDefaultProvider(cli, cwd);
+  if (declared) return declared;
+  warnIfLegacyConfigExists(cwd);
+  const registry = loadProviderRegistryForCwd(cwd);
+  const order = resolveFallbackProviderOrder(cwd);
+  const fromOrder = firstInstalledProvider(order.providers, registry);
+  if (fromOrder) {
+    return { value: fromOrder, source: "registry", sourcePath: order.sourcePath };
+  }
+  const registryPath = ProviderRegistry.getLoadedConfigPath() ?? resolveProvidersConfigPath({ cwd });
+  const enabled = ProviderRegistry.getEnabledProviders(registry).map((provider) => provider.id);
+  const first = firstInstalledProvider(enabled, registry);
+  if (first) {
+    return { value: first, source: "registry", sourcePath: `${registryPath}#providers.*.order` };
+  }
+  throw new Error(
+    `Invalid provider registry at ${registryPath}: no providers are enabled. Enable at least one providers.<id>.enabled entry.`
+  );
+}
+function resolveDefaultJudgeProvider(_cli, cwd = process.cwd()) {
+  return selectDefaultJudgeProvider(loadProviderRegistryForCwd(cwd), cwd);
+}
+async function resolveReadyDefaultProvider(cli, cwd = process.cwd()) {
+  const provider = resolveDefaultProvider(cli, cwd);
+  const readiness = await assertProviderReady(provider.value);
+  return { provider, readiness };
+}
+function resolveGitAttribution(cwd = process.cwd(), options = {}) {
+  const paths = getConfigPaths2(cwd);
+  return resolveGitAttributionFromLayers({
+    project: loadProjectConfig(cwd),
+    readUser: () => loadUserConfig(cwd),
+    projectConfigFile: paths.projectConfigFile,
+    userConfigFile: paths.userConfigFile,
+    ...options
+  });
+}
+function resolveProviderModel(providerInput, cli, cwd = process.cwd()) {
+  const provider = normalizeProviderId(providerInput);
+  const paths = getConfigPaths2(cwd);
+  const configuredModel = (value, source, sourcePath) => {
+    validateModelForProvider(provider, value, sourcePath, cwd);
+    if (source === "cli") warnIfExplicitModelUnobserved(provider, value);
+    return { value, source, sourcePath };
+  };
+  let defaultProviderCache;
+  const ownsUnscopedModel = (layerProvider) => {
+    if (layerProvider && normalizeProviderId(layerProvider) !== provider) return false;
+    if (defaultProviderCache === void 0) {
+      defaultProviderCache = resolveDefaultProvider(cli, cwd).value;
+    }
+    return defaultProviderCache === provider;
+  };
+  if (cli?.model) {
+    if (cli.provider && normalizeProviderId(cli.provider) === provider) {
+      return configuredModel(cli.model, "cli", "cli:--model");
+    }
+    if (!cli.provider && ownsUnscopedModel()) {
+      return configuredModel(cli.model, "cli", "cli:--model");
+    }
+  }
+  const envModel = getProviderEnvModel(provider);
+  if (envModel) {
+    return configuredModel(envModel.value, envModel.source, envModel.sourcePath);
+  }
+  const activeProfile = getActiveProfile();
+  const profileProviderModel = activeProfile?.defaults?.providers?.[provider]?.model;
+  if (activeProfile && profileProviderModel) {
+    warnSetupModelPin(activeProfile, provider, profileProviderModel, () => loadConfigLayers(cwd));
+    return configuredModel(
+      profileProviderModel,
+      "profile",
+      `profile:${activeProfile.name}#defaults.providers.${provider}.model`
+    );
+  }
+  if (activeProfile?.defaults?.model && ownsUnscopedModel(activeProfile.defaults.provider)) {
+    return configuredModel(
+      activeProfile.defaults.model,
+      "profile",
+      `profile:${activeProfile.name}#defaults.model`
+    );
+  }
+  const projectConfig = loadProjectConfig(cwd);
+  const projectConfigProviderModel = projectConfig?.defaults?.providers?.[provider]?.model;
+  if (projectConfigProviderModel) {
+    return configuredModel(
+      projectConfigProviderModel,
+      "project",
+      `${paths.projectConfigFile}#defaults.providers.${provider}.model`
+    );
+  }
+  if (projectConfig?.defaults?.model && ownsUnscopedModel(projectConfig.defaults.provider)) {
+    return configuredModel(
+      projectConfig.defaults.model,
+      "project",
+      `${paths.projectConfigFile}#defaults.model`
+    );
+  }
+  const userConfig = loadUserConfig(cwd);
+  const userConfigProviderModel = userConfig?.defaults?.providers?.[provider]?.model;
+  if (userConfigProviderModel) {
+    return configuredModel(
+      userConfigProviderModel,
+      "user-config",
+      `${paths.userConfigFile}#defaults.providers.${provider}.model`
+    );
+  }
+  if (userConfig?.defaults?.model && ownsUnscopedModel(userConfig.defaults.provider)) {
+    return configuredModel(
+      userConfig.defaults.model,
+      "user-config",
+      `${paths.userConfigFile}#defaults.model`
+    );
+  }
+  warnIfLegacyConfigExists(cwd);
+  try {
+    const registry = loadProviderRegistryForCwd(cwd);
+    const registryModel = ProviderRegistry.getProviderConfig(provider, registry).models.default;
+    const validatedModel = ProviderRegistry.resolveModel(provider, registryModel, registry);
+    return {
+      value: validatedModel,
+      source: "registry",
+      sourcePath: `providers.yaml#providers.${provider}.models.default`
+    };
+  } catch (error) {
+    emitResolutionWarningOnce({
+      operation: "resolveProviderModel",
+      provider,
+      message: `Provider '${provider}' has no usable providers.yaml default model; falling back to model 'auto'`,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return { value: "auto", source: "fallback" };
+  }
+}
+function resolveProviderReasoningEffort(provider, cli, cwd = process.cwd()) {
+  const paths = getConfigPaths2(cwd);
+  const configured = (value, source, sourcePath) => {
+    const normalized = normalizeReasoningEffortInput(value);
+    if (!normalized) {
+      throw new InvalidExplicitConfigError(
+        `Invalid reasoning effort at ${sourcePath}: ${String(value)}`
+      );
+    }
+    return { value: normalized, source, sourcePath };
+  };
+  if (cli?.reasoningEffort) {
+    return configured(cli.reasoningEffort, "cli", "cli:--reasoning-effort");
+  }
+  const activeProfile = getActiveProfile();
+  const profileEffort = activeProfile?.defaults?.providers?.[provider]?.reasoningEffort;
+  if (activeProfile && profileEffort) {
+    return configured(
+      profileEffort,
+      "profile",
+      `profile:${activeProfile.name}#defaults.providers.${provider}.reasoningEffort`
+    );
+  }
+  const projectConfig = loadProjectConfig(cwd);
+  const projectEffort = projectConfig?.defaults?.providers?.[provider]?.reasoningEffort;
+  if (projectEffort) {
+    return configured(
+      projectEffort,
+      "project",
+      `${paths.projectConfigFile}#defaults.providers.${provider}.reasoningEffort`
+    );
+  }
+  const userConfig = loadUserConfig(cwd);
+  const userEffort = userConfig?.defaults?.providers?.[provider]?.reasoningEffort;
+  if (userEffort) {
+    return configured(
+      userEffort,
+      "user-config",
+      `${paths.userConfigFile}#defaults.providers.${provider}.reasoningEffort`
+    );
+  }
+  const registry = loadProviderRegistryForCwd(cwd);
+  if (!ProviderRegistry.getEnabledProviders(registry).some((entry) => entry.id === provider)) {
+    return void 0;
+  }
+  const registryEffort = ProviderRegistry.getProviderConfig(provider, registry).models.default_reasoning_effort;
+  if (registryEffort) {
+    return configured(
+      registryEffort,
+      "registry",
+      `providers.yaml#providers.${provider}.models.default_reasoning_effort`
+    );
+  }
+  return void 0;
+}
+var CLI_JUDGE_SOURCE_PATHS = {
+  provider: void 0,
+  model: "cli:--judge-model",
+  // No CLI flag sets judge effort; only a caller's judge options do.
+  reasoningEffort: "caller:judge reasoningEffort option"
+};
+function resolveJudgeSettings(cli, cwd, judgeType, env = process.env) {
+  const paths = getConfigPaths2(cwd);
+  const activeProfile = getActiveProfile();
+  const providerId = (provider) => provider?.trim() ? normalizeProviderId(provider.trim()) : void 0;
+  const configLayer = (source, config, pathPrefix) => ({
+    source,
+    blocks: judgeLayerBlocks(config, pathPrefix, judgeType).map((block) => ({
+      ...block,
+      provider: providerId(block.provider)
+    }))
+  });
+  const layers = [
+    {
+      source: "cli",
+      blocks: [
+        {
+          provider: providerId(cli?.judgeProvider),
+          model: cli?.judgeModel,
+          reasoningEffort: cli?.judgeReasoningEffort,
+          sourcePath: (field) => CLI_JUDGE_SOURCE_PATHS[field]
+        }
+      ]
+    },
+    {
+      source: "env",
+      blocks: [
+        {
+          provider: providerId(env.BUILD_JUDGE_PROVIDER),
+          model: env.BUILD_JUDGE_MODEL?.trim() || void 0,
+          sourcePath: (field) => field === "provider" ? "env:BUILD_JUDGE_PROVIDER" : "env:BUILD_JUDGE_MODEL"
+        }
+      ]
+    },
+    ...activeProfile ? [
+      configLayer(
+        "profile",
+        activeProfile,
+        `profile:${activeProfile.name}#`
+      )
+    ] : [],
+    configLayer("project", loadProjectConfig(cwd), `${paths.projectConfigFile}#`),
+    configLayer("user-config", loadUserConfig(cwd), `${paths.userConfigFile}#`)
+  ];
+  const binding = resolveJudgeBinding({
+    layers,
+    // With no judge provider set, the first installed judge- and arbiter-capable
+    // provider in the priority list judges.
+    defaultProvider: () => {
+      warnIfLegacyConfigExists(cwd);
+      const defaultProvider = resolveDefaultJudgeProvider(cli, cwd);
+      return {
+        value: defaultProvider.value,
+        source: defaultProvider.source,
+        sourcePath: defaultProvider.sourcePath ? `judge-default:${defaultProvider.sourcePath}` : "judge-default:execution-provider"
+      };
+    },
+    // With no judge effort set, the final provider's registry judge entry supplies it,
+    // whatever chose that provider. Without an entry Build sends no effort; coding
+    // effort never applies.
+    defaultEffort: (provider) => {
+      const registryEffort = ProviderRegistry.getJudgeReasoningEffort(
+        provider.value,
+        loadProviderRegistryForCwd(cwd)
+      );
+      return registryEffort ? {
+        value: registryEffort,
+        source: "registry",
+        sourcePath: `providers.yaml#providers.${provider.value}.models.judge_reasoning_effort`
+      } : void 0;
+    }
+  });
+  if (binding.model.source === "registry" || binding.model.source === "fallback") {
+    warnIfLegacyConfigExists(cwd);
+  }
+  return binding;
+}
+function resolveJudgeProvider(cli, cwd = process.cwd(), judgeType) {
+  return resolveJudgeSettings(cli, cwd, judgeType).provider;
+}
+function resolveJudgeModel(cli, cwd = process.cwd(), judgeType) {
+  return resolveJudgeSettings(cli, cwd, judgeType).model;
+}
+function resolveJudgeReasoningEffort(cli, cwd = process.cwd(), judgeType) {
+  return resolveJudgeSettings(cli, cwd, judgeType).reasoningEffort;
+}
+function defaultsLayers(cwd) {
+  const paths = getConfigPaths2(cwd);
+  const profile = getActiveProfile();
+  const layer = (source, defaults, prefix) => ({ source, defaults, path: (key) => `${prefix}#defaults.${key}` });
+  return [
+    ...profile ? [layer("profile", profile.defaults, `profile:${profile.name}`)] : [],
+    layer("project", loadProjectConfig(cwd)?.defaults, paths.projectConfigFile),
+    layer("user-config", loadUserConfig(cwd)?.defaults, paths.userConfigFile)
+  ];
+}
+function layerFitsProvider(block, provider, cwd) {
+  const owner = block?.provider ? normalizeProviderId(block.provider) : inferProviderFromModel(block?.model, cwd);
+  return owner === void 0 || owner === provider;
+}
+function configuredReasoningEffort(value, source, sourcePath) {
+  const normalized = normalizeReasoningEffortInput(value);
+  if (!normalized) {
+    throw new InvalidExplicitConfigError(
+      `Invalid reasoning effort at ${sourcePath}: ${String(value)}`
+    );
+  }
+  return { value: normalized, source, sourcePath };
+}
+function resolvePurposeReasoningEffort(purpose, provider, cwd) {
+  for (const { source, defaults, path: path3 } of defaultsLayers(cwd)) {
+    const block = defaults?.[purpose];
+    if (block?.reasoningEffort && layerFitsProvider(block, provider, cwd)) {
+      return configuredReasoningEffort(
+        block.reasoningEffort,
+        source,
+        path3(`${purpose}.reasoningEffort`)
+      );
+    }
+    const providerEffort = defaults?.providers?.[provider]?.reasoningEffort;
+    if (providerEffort) {
+      return configuredReasoningEffort(
+        providerEffort,
+        source,
+        path3(`providers.${provider}.reasoningEffort`)
+      );
+    }
+  }
+  return resolveProviderReasoningEffort(provider, void 0, cwd);
+}
+function resolveSynthesisModel(cli, cwd = process.cwd()) {
+  const provider = resolveSynthesisProvider(cli, cwd).value;
+  const configuredModel = (value, source, sourcePath) => {
+    validateModelForProvider(provider, value, sourcePath, cwd);
+    return { value, source, sourcePath };
+  };
+  if (cli?.synthesisModel) {
+    return configuredModel(cli.synthesisModel, "cli", "cli:--synthesis-model");
+  }
+  const envSynthesisModel = process.env.BUILD_SYNTHESIS_MODEL;
+  if (envSynthesisModel) {
+    return configuredModel(envSynthesisModel, "env", "env:BUILD_SYNTHESIS_MODEL");
+  }
+  for (const { source, defaults, path: path3 } of defaultsLayers(cwd)) {
+    const synthesis = defaults?.synthesis;
+    if (synthesis?.model && layerFitsProvider(synthesis, provider, cwd)) {
+      return configuredModel(synthesis.model, source, path3("synthesis.model"));
+    }
+    const providerModel = defaults?.providers?.[provider]?.model;
+    if (providerModel) {
+      return configuredModel(providerModel, source, path3(`providers.${provider}.model`));
+    }
+    if (defaults?.model && layerFitsProvider(defaults, provider, cwd)) {
+      return configuredModel(defaults.model, source, path3("model"));
+    }
+  }
+  warnIfLegacyConfigExists(cwd);
+  try {
+    const model = ProviderRegistry.getProviderConfig(provider, loadProviderRegistryForCwd(cwd)).models.default;
+    return {
+      value: model,
+      source: "registry",
+      sourcePath: `providers.yaml#providers.${provider}.models.default`
+    };
+  } catch {
+    return { value: "auto", source: "fallback" };
+  }
+}
+function resolveForConfig(resolve, options, onInvalid) {
+  if (options?.strictSynthesisModel !== false) {
+    return resolve();
+  }
+  try {
+    return resolve();
+  } catch (error) {
+    if (!(error instanceof InvalidProviderModelError)) {
+      throw error;
+    }
+    return onInvalid({
+      value: "invalid",
+      source: "fallback",
+      sourcePath: `resolution-error:${error.message}`
+    });
+  }
+}
+function resolveSynthesisProvider(cli, cwd = process.cwd()) {
+  if (cli?.synthesisProvider) {
+    return {
+      value: normalizeProviderId(cli.synthesisProvider),
+      source: "cli",
+      sourcePath: "cli:--synthesis-provider"
+    };
+  }
+  const cliInferredProvider = inferProviderFromModel(cli?.synthesisModel, cwd);
+  if (cliInferredProvider) {
+    return {
+      value: cliInferredProvider,
+      source: "cli",
+      sourcePath: "cli:--synthesis-model"
+    };
+  }
+  const envProvider = process.env.BUILD_SYNTHESIS_PROVIDER;
+  if (envProvider) {
+    return {
+      value: normalizeProviderId(envProvider),
+      source: "env",
+      sourcePath: "env:BUILD_SYNTHESIS_PROVIDER"
+    };
+  }
+  const envModelProvider = inferProviderFromModel(process.env.BUILD_SYNTHESIS_MODEL, cwd);
+  if (envModelProvider) {
+    return {
+      value: envModelProvider,
+      source: "env",
+      sourcePath: "env:BUILD_SYNTHESIS_MODEL"
+    };
+  }
+  for (const { source, defaults, path: path3 } of defaultsLayers(cwd)) {
+    if (defaults?.synthesis?.provider) {
+      return {
+        value: normalizeProviderId(defaults.synthesis.provider),
+        source,
+        sourcePath: path3("synthesis.provider")
+      };
+    }
+    const synthesisOwner = inferProviderFromModel(defaults?.synthesis?.model, cwd);
+    if (synthesisOwner) {
+      return { value: synthesisOwner, source, sourcePath: path3("synthesis.model") };
+    }
+    const defaultOwner = inferProviderFromModel(defaults?.model, cwd);
+    const override = declaredDefaultOverridingOwner(defaultOwner, source, cli, cwd);
+    if (override) return override;
+    if (defaultOwner) return { value: defaultOwner, source, sourcePath: path3("model") };
+  }
+  warnIfLegacyConfigExists(cwd);
+  const defaultProvider = resolveDefaultProvider(cli, cwd);
+  return defaultProvider.source === "fallback" || defaultProvider.source === "registry" ? { ...defaultProvider, source: "fallback", sourcePath: "synthesis-provider:default-fallback" } : defaultProvider;
+}
+function resolveSynthesisReasoningEffort(cli, cwd = process.cwd(), provider) {
+  if (cli?.reasoningEffort) {
+    return configuredReasoningEffort(cli.reasoningEffort, "cli", "cli:--reasoning-effort");
+  }
+  const synthesisProvider = provider ? normalizeProviderId(provider) : resolveSynthesisProvider(cli, cwd).value;
+  return resolvePurposeReasoningEffort("synthesis", synthesisProvider, cwd);
+}
+function resolveSplitterExecution(cli, cwd = process.cwd()) {
+  const layers = defaultsLayers(cwd);
+  const registry = loadProviderRegistryForCwd(cwd);
+  const envModel = process.env.BUILD_SPLITTER_MODEL;
+  const modelOwner = (model2, source, sourcePath) => {
+    const value = inferProviderFromModel(model2, cwd);
+    return value ? { value, source, sourcePath } : void 0;
+  };
+  const layerProvider = () => {
+    for (const { source, defaults, path: path3 } of layers) {
+      const splitter = defaults?.splitter;
+      const named = splitter?.provider ? {
+        value: normalizeProviderId(splitter.provider),
+        source,
+        sourcePath: path3("splitter.provider")
+      } : modelOwner(splitter?.model, source, path3("splitter.model"));
+      if (named) return named;
+    }
+    return void 0;
+  };
+  const provider = (cli?.splitterProvider ? {
+    value: normalizeProviderId(cli.splitterProvider),
+    source: "cli",
+    sourcePath: "cli:--splitter-provider"
+  } : void 0) ?? modelOwner(cli?.splitterModel, "cli", "cli:--splitter-model") ?? modelOwner(envModel, "env", "env:BUILD_SPLITTER_MODEL") ?? layerProvider() ?? resolveDefaultProvider(cli, cwd);
+  const fitting = layers.filter(
+    ({ defaults }) => layerFitsProvider(defaults?.splitter, provider.value, cwd)
+  );
+  const modelLayer = fitting.find(({ defaults }) => defaults?.splitter?.model);
+  const configuredModel = cli?.splitterModel ? { value: cli.splitterModel, source: "cli", sourcePath: "cli:--splitter-model" } : envModel ? { value: envModel, source: "env", sourcePath: "env:BUILD_SPLITTER_MODEL" } : modelLayer?.defaults?.splitter?.model ? {
+    value: modelLayer.defaults.splitter.model,
+    source: modelLayer.source,
+    sourcePath: modelLayer.path("splitter.model")
+  } : void 0;
+  if (configuredModel) {
+    validateModelForProvider(
+      provider.value,
+      configuredModel.value,
+      configuredModel.sourcePath,
+      cwd
+    );
+  }
+  const selectedModel = configuredModel ?? {
+    value: ProviderRegistry.getProviderConfig(provider.value, registry).models.default,
+    source: "registry",
+    sourcePath: `providers.yaml#providers.${provider.value}.models.default`
+  };
+  const model = {
+    ...selectedModel,
+    value: ProviderRegistry.resolveModel(provider.value, selectedModel.value, registry)
+  };
+  const reasoningEffort = cli?.reasoningEffort ? configuredReasoningEffort(cli.reasoningEffort, "cli", "cli:--reasoning-effort") : resolvePurposeReasoningEffort("splitter", provider.value, cwd);
+  return { provider, model, ...reasoningEffort ? { reasoningEffort } : {} };
+}
+function resolveSplitterModel(cli, cwd = process.cwd()) {
+  return resolveSplitterExecution(cli, cwd).model;
+}
+function resolveSplitterReasoningEffort(cli, cwd = process.cwd()) {
+  return resolveSplitterExecution(cli, cwd).reasoningEffort;
+}
+function resolveIntentDecompositionHints(cwd = process.cwd()) {
+  const paths = getConfigPaths2(cwd);
+  const projectConfig = loadProjectConfig(cwd);
+  const projectHints = projectConfig?.defaults?.intent?.decompositionHints;
+  if (Array.isArray(projectHints) && projectHints.length > 0) {
+    return {
+      value: projectHints.filter((v) => typeof v === "string" && v.length > 0),
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#defaults.intent.decompositionHints`
+    };
+  }
+  const userConfig = loadUserConfig(cwd);
+  const userHints = userConfig?.defaults?.intent?.decompositionHints;
+  if (Array.isArray(userHints) && userHints.length > 0) {
+    return {
+      value: userHints.filter((v) => typeof v === "string" && v.length > 0),
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#defaults.intent.decompositionHints`
+    };
+  }
+  return { value: [], source: "fallback" };
+}
+function resolveIntentNonGoals(cwd = process.cwd()) {
+  const paths = getConfigPaths2(cwd);
+  const projectConfig = loadProjectConfig(cwd);
+  const projectNonGoals = projectConfig?.defaults?.intent?.nonGoals;
+  if (Array.isArray(projectNonGoals) && projectNonGoals.length > 0) {
+    return {
+      value: projectNonGoals.filter((v) => typeof v === "string" && v.length > 0),
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#defaults.intent.nonGoals`
+    };
+  }
+  const userConfig = loadUserConfig(cwd);
+  const userNonGoals = userConfig?.defaults?.intent?.nonGoals;
+  if (Array.isArray(userNonGoals) && userNonGoals.length > 0) {
+    return {
+      value: userNonGoals.filter((v) => typeof v === "string" && v.length > 0),
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#defaults.intent.nonGoals`
+    };
+  }
+  return { value: [], source: "fallback" };
+}
+function resolveIntentDisableRepoContext(cwd = process.cwd()) {
+  const paths = getConfigPaths2(cwd);
+  const projectConfig = loadProjectConfig(cwd);
+  const projectDisable = projectConfig?.defaults?.intent?.disableRepoContext;
+  if (typeof projectDisable === "boolean") {
+    return {
+      value: projectDisable,
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#defaults.intent.disableRepoContext`
+    };
+  }
+  const userConfig = loadUserConfig(cwd);
+  const userDisable = userConfig?.defaults?.intent?.disableRepoContext;
+  if (typeof userDisable === "boolean") {
+    return {
+      value: userDisable,
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#defaults.intent.disableRepoContext`
+    };
+  }
+  return { value: false, source: "fallback" };
+}
+function resolveJudgeConfig(cli, cwd = process.cwd(), judgeType, env = process.env) {
+  const type = resolveJudgeType(cli, cwd);
+  const { provider, model, reasoningEffort } = resolveJudgeSettings(cli, cwd, judgeType, env);
+  return { type, provider, model, ...reasoningEffort ? { reasoningEffort } : {} };
+}
+function resolveConfig(cli, cwd = process.cwd(), options) {
+  if (options?.strictSynthesisModel === false) {
+    return withReadOnlyProviderOrder(() => resolveConfigStrict(cli, cwd, options));
+  }
+  return resolveConfigStrict(cli, cwd, options);
+}
+function resolveConfigStrict(cli, cwd, options) {
+  const defaultProvider = resolveDefaultProvider(cli, cwd);
+  const registry = loadProviderRegistryForCwd(cwd);
+  const providers = ProviderRegistry.getEnabledProviders(registry).map((provider) => provider.id);
+  const providerModels = {};
+  const providerReasoningEfforts = {};
+  for (const provider of providers) {
+    providerModels[provider] = resolveProviderModel(provider, cli, cwd);
+    providerReasoningEfforts[provider] = resolveProviderReasoningEffort(provider, cli, cwd);
+  }
+  const splitter = resolveForConfig(
+    () => resolveSplitterExecution(cli, cwd),
+    options,
+    (model) => ({ model })
+  );
+  const judgeType = resolveJudgeType(cli, cwd);
+  let judge;
+  try {
+    judge = resolveJudgeConfig(cli, cwd, judgeType.value);
+  } catch (error) {
+    if (options?.strictSynthesisModel !== false || !(error instanceof NoEligibleArbiterError)) {
+      throw error;
+    }
+    const invalid = {
+      value: "invalid",
+      source: "fallback",
+      sourcePath: `resolution-error:${error.message}`
+    };
+    judge = { type: judgeType, provider: invalid, model: invalid };
+  }
+  return {
+    defaultProvider,
+    defaultModel: resolveProviderModel(defaultProvider.value, cli, cwd),
+    planExecute: resolvePlanExecuteConfig(cli, cwd),
+    providerExecutionTransport: resolveProviderExecutionTransportConfig(cli, cwd),
+    judge,
+    synthesisModel: resolveForConfig(
+      () => resolveSynthesisModel(cli, cwd),
+      options,
+      (model) => model
+    ),
+    synthesisReasoningEffort: resolveSynthesisReasoningEffort(cli, cwd),
+    splitterModel: splitter.model,
+    splitterReasoningEffort: splitter.reasoningEffort,
+    providerModels,
+    providerReasoningEfforts,
+    gitAttribution: resolveGitAttribution(cwd)
+  };
+}
+function resolvePlanExecuteConfig(cli, cwd = process.cwd()) {
+  return {
+    blockerMode: resolvePlanExecuteBlockerMode(cli, cwd)
+  };
+}
+function resolvePlanExecuteBlockerMode(cli, cwd = process.cwd()) {
+  const paths = getConfigPaths2(cwd);
+  if (cli?.planExecuteBlockerMode) {
+    return {
+      value: cli.planExecuteBlockerMode,
+      source: "cli",
+      sourcePath: "cli:--blocker-mode"
+    };
+  }
+  const projectConfig = loadProjectConfig(cwd);
+  const projectBlockerMode = resolveDurablePlanExecuteBlockerMode(
+    projectConfig?.planExecute?.blockerMode,
+    `${paths.projectConfigFile}#planExecute.blockerMode`
+  );
+  if (projectBlockerMode) {
+    return {
+      value: projectBlockerMode,
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#planExecute.blockerMode`
+    };
+  }
+  const userConfig = loadUserConfig(cwd);
+  const userBlockerMode = resolveDurablePlanExecuteBlockerMode(
+    userConfig?.planExecute?.blockerMode,
+    `${paths.userConfigFile}#planExecute.blockerMode`
+  );
+  if (userBlockerMode) {
+    return {
+      value: userBlockerMode,
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#planExecute.blockerMode`
+    };
+  }
+  return { value: "non-interactive", source: "fallback" };
+}
+function providerExecutionTransportEnvKey(provider) {
+  return `BUILD_${provider.trim().toUpperCase().replace(/[^A-Z0-9_]/g, "_")}_EXECUTION_TRANSPORT`;
+}
+function resolveEnvProviderExecutionTransport(provider, env = process.env) {
+  const providerKey = providerExecutionTransportEnvKey(provider);
+  const providerRaw = env[providerKey];
+  const providerValue = normalizeExecutionTransportMode(providerRaw);
+  if (providerValue) {
+    return {
+      value: providerValue,
+      source: "env",
+      sourcePath: `env:${providerKey}`
+    };
+  }
+  if (providerRaw?.trim()) {
+    throw new InvalidExplicitConfigError(
+      `Invalid ${providerKey}: expected auto, headless, tmux-exec, or interactive`
+    );
+  }
+  const legacyRaw = env.BUILD_PROVIDER_EXECUTION_TRANSPORT;
+  const canonicalRaw = env.BUILD_EXECUTION_TRANSPORT;
+  const legacyValue = normalizeExecutionTransportMode(legacyRaw);
+  const canonicalValue = normalizeExecutionTransportMode(canonicalRaw);
+  if (legacyRaw?.trim() && !legacyValue) {
+    throw new InvalidExplicitConfigError(
+      "Invalid BUILD_PROVIDER_EXECUTION_TRANSPORT: expected auto, headless, tmux-exec, or interactive"
+    );
+  }
+  if (canonicalRaw?.trim() && !canonicalValue) {
+    throw new InvalidExplicitConfigError(
+      "Invalid BUILD_EXECUTION_TRANSPORT: expected auto, headless, tmux-exec, or interactive"
+    );
+  }
+  const genericValue = legacyValue ?? canonicalValue;
+  if (genericValue) {
+    return {
+      value: genericValue,
+      source: "env",
+      sourcePath: env.BUILD_PROVIDER_EXECUTION_TRANSPORT ? "env:BUILD_PROVIDER_EXECUTION_TRANSPORT" : "env:BUILD_EXECUTION_TRANSPORT"
+    };
+  }
+  return void 0;
+}
+function resolveConfiguredProviderExecutionTransport(provider, cwd = process.cwd()) {
+  const normalizedProvider = normalizeProviderId(provider);
+  const paths = getConfigPaths2(cwd);
+  if (!CONFIGURABLE_EXECUTION_TRANSPORT_PROVIDERS.has(normalizedProvider)) {
+    return { value: "headless", source: "fallback" };
+  }
+  const activeProfile = getActiveProfile();
+  const profileResolved = resolveConfigExecutionTransport(
+    activeProfile,
+    normalizedProvider,
+    "profile",
+    `profile:${activeProfile?.name ?? "active"}`
+  );
+  if (profileResolved && activeProfile) {
+    return profileResolved;
+  }
+  const projectConfig = loadProjectConfig(cwd);
+  const projectResolved = resolveConfigExecutionTransport(
+    projectConfig,
+    normalizedProvider,
+    "project",
+    paths.projectConfigFile
+  );
+  if (projectResolved) return projectResolved;
+  const userConfig = loadUserConfig(cwd);
+  const userResolved = resolveConfigExecutionTransport(
+    userConfig,
+    normalizedProvider,
+    "user-config",
+    paths.userConfigFile
+  );
+  if (userResolved) return userResolved;
+  return { value: "headless", source: "fallback" };
+}
+function resolveProviderExecutionTransport(provider, cli, cwd = process.cwd()) {
+  const normalizedProvider = normalizeProviderId(provider);
+  const cliValue = cli?.providerExecutionTransport ?? cli?.executionTransport;
+  const normalizedCliValue = normalizeExecutionTransportMode(cliValue);
+  if (normalizedCliValue) {
+    return {
+      value: normalizedCliValue,
+      source: "cli",
+      sourcePath: "cli:--provider-execution-transport"
+    };
+  }
+  const envResolved = resolveEnvProviderExecutionTransport(normalizedProvider);
+  if (envResolved) return envResolved;
+  return resolveConfiguredProviderExecutionTransport(normalizedProvider, cwd);
+}
+function resolveProviderExecutionTransportConfig(cli, cwd = process.cwd()) {
+  const defaultProvider = resolveDefaultProvider(cli, cwd).value;
+  const providers = {};
+  for (const provider of CONFIGURABLE_EXECUTION_TRANSPORT_PROVIDERS) {
+    providers[provider] = resolveProviderExecutionTransport(provider, cli, cwd);
+  }
+  return {
+    current: resolveProviderExecutionTransport(defaultProvider, cli, cwd),
+    providers
+  };
+}
+function isRunnableModel(provider, model, registry) {
+  try {
+    ProviderRegistry.resolveModel(provider, model.value, registry);
+    return true;
+  } catch {
+    const source = `${model.source}:${model.sourcePath}`;
+    emitResolutionWarningOnce({
+      operation: "resolveCandidates",
+      provider,
+      model: model.value,
+      source,
+      message: `Skipping invalid model '${model.value}' for provider '${provider}' from ${source}`
+    });
+    return false;
+  }
+}
+function inRegistry(provider, registry) {
+  try {
+    ProviderRegistry.getProviderConfig(provider, registry);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function registryDefaultModel(provider, registry) {
+  try {
+    const model = ProviderRegistry.getProviderConfig(provider, registry).models.default;
+    return {
+      value: ProviderRegistry.resolveModel(provider, model, registry),
+      source: "registry",
+      sourcePath: `providers.yaml#providers.${provider}.models.default`
+    };
+  } catch {
+    return void 0;
+  }
+}
+function retiredModelOrder(provider, layers) {
+  const key = `defaults.providers.${provider}.modelOrder`;
+  const { profile, project, user, paths } = layers;
+  const layer = [
+    {
+      source: "profile",
+      sourcePath: `profile:${profile?.name}#${key}`,
+      models: profile?.defaults?.providers?.[provider]?.modelOrder
+    },
+    {
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#${key}`,
+      models: project?.defaults?.providers?.[provider]?.modelOrder
+    },
+    {
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#${key}`,
+      models: user?.defaults?.providers?.[provider]?.modelOrder
+    }
+  ].find(({ models }) => models !== void 0);
+  if (!layer?.models) return [];
+  const { source, sourcePath } = layer;
+  return layer.models.filter((model) => model.trim().length > 0).map((value) => ({ value, source, sourcePath }));
+}
+function chainProviderModel(provider, cli, cwd, registry) {
+  try {
+    const shown = resolveProviderModel(provider, cli, cwd);
+    return shown.source === "fallback" ? void 0 : shown;
+  } catch (error) {
+    if (!(error instanceof InvalidProviderModelError)) throw error;
+    emitResolutionWarningOnce({
+      operation: "resolveCandidates",
+      provider,
+      model: error.model,
+      source: error.sourcePath,
+      message: `Skipping invalid model '${error.model}' for provider '${provider}' from ${error.sourcePath}`
+    });
+    return registryDefaultModel(provider, registry);
+  }
+}
+function toLegacyCliOptions(cli) {
+  if (!cli) return void 0;
+  return {
+    provider: cli.provider,
+    model: cli.model,
+    judgeProvider: cli.judgeProvider,
+    judgeModel: cli.judgeModel,
+    synthesisProvider: cli.synthesisProvider,
+    synthesisModel: cli.synthesisModel,
+    splitterModel: cli.splitterModel
+  };
+}
+function resolvePurposeProviderScalar(purpose, cli, cwd) {
+  switch (purpose) {
+    case "judge":
+      return resolveJudgeProvider(cli, cwd);
+    case "synthesis":
+      return resolveSynthesisProvider(cli, cwd);
+    case "splitter":
+      return resolveDefaultProvider(cli, cwd);
+    case "decomposition":
+    case "flywheel":
+    case "orchestration":
+    case "global":
+      return resolveDefaultProvider(cli, cwd);
+  }
+}
+function resolvePurposeModelScalar(purpose, provider, cli, cwd) {
+  switch (purpose) {
+    case "judge":
+      return resolveJudgeModel(cli, cwd);
+    case "synthesis":
+      return resolveSynthesisModel(cli, cwd);
+    case "splitter":
+      return resolveSplitterModel(cli, cwd);
+    case "decomposition":
+    case "flywheel":
+    case "orchestration":
+    case "global":
+      return resolveProviderModel(provider, cli, cwd);
+  }
+}
+function shouldUseScalarCandidate(providerResolved, modelResolved) {
+  const isConfigured = (source) => source !== "registry" && source !== "fallback";
+  return isConfigured(providerResolved.source) || isConfigured(modelResolved.source);
+}
+function buildCandidate(params) {
+  return {
+    provider: params.provider,
+    model: params.model,
+    source: params.providerSource,
+    sourcePath: params.providerSourcePath,
+    providerSource: params.providerSource,
+    providerSourcePath: params.providerSourcePath,
+    modelSource: params.modelSource,
+    modelSourcePath: params.modelSourcePath,
+    purpose: params.purpose,
+    index: params.index
+  };
+}
+function resolveCandidates(purpose, options) {
+  return purpose === "synthesis" || purpose === "decomposition" ? withPurposeProviderOrder(
+    options?.cwd ?? process.cwd(),
+    purpose,
+    () => resolveCandidatesInScope(purpose, options)
+  ) : resolveCandidatesInScope(purpose, options);
+}
+function resolveCandidatesInScope(purpose, options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const cli = toLegacyCliOptions(options?.cli);
+  const paths = getConfigPaths2(cwd);
+  warnIfLegacyConfigExists(cwd);
+  const preserveFallbackChain = options?.preserveFallbackChain === true;
+  const scalarProvider = resolvePurposeProviderScalar(purpose, cli, cwd);
+  let scalarModel;
+  try {
+    scalarModel = resolvePurposeModelScalar(purpose, scalarProvider.value, cli, cwd);
+  } catch (error) {
+    if (!preserveFallbackChain || !(error instanceof InvalidProviderModelError)) {
+      throw error;
+    }
+    scalarModel = {
+      value: "invalid",
+      source: "fallback",
+      sourcePath: `resolution-error:${error.message}`
+    };
+  }
+  const scalarConfigured = shouldUseScalarCandidate(scalarProvider, scalarModel);
+  if (scalarConfigured && !preserveFallbackChain) {
+    return [
+      buildCandidate({
+        provider: scalarProvider.value,
+        model: scalarModel.value,
+        purpose,
+        index: 0,
+        providerSource: scalarProvider.source,
+        providerSourcePath: scalarProvider.sourcePath ?? "resolution-engine:provider",
+        modelSource: scalarModel.source,
+        modelSourcePath: scalarModel.sourcePath ?? "resolution-engine:model"
+      })
+    ];
+  }
+  const projectConfig = loadProjectConfig(cwd);
+  const userConfig = loadUserConfig(cwd);
+  const registry = loadProviderRegistryForCwd(cwd);
+  const candidateActiveProfile = getActiveProfile();
+  const configuredOrder = resolveConfiguredProviderOrder({
+    cwd,
+    ...purpose === "synthesis" || purpose === "decomposition" ? { purpose } : {}
+  });
+  const providerOrderSource = configuredOrder.source;
+  const providerOrderSourcePath = configuredOrder.sourcePath;
+  let providerOrder = keepInstalledProviders(configuredOrder.providers, registry).providers;
+  if (scalarConfigured && preserveFallbackChain) {
+    providerOrder = [
+      scalarProvider.value,
+      ...providerOrder.filter((provider) => provider !== scalarProvider.value)
+    ];
+  }
+  assertUsableProviderOrder(configuredOrder, providerOrder);
+  const scalarModelConfigured = scalarModel.source !== "registry" && scalarModel.source !== "fallback";
+  const purposeModel = (purpose === "judge" || purpose === "synthesis") && scalarModel.source !== "fallback" ? scalarModel : void 0;
+  const layers = {
+    profile: candidateActiveProfile,
+    project: projectConfig,
+    user: userConfig,
+    paths
+  };
+  const candidates = [];
+  for (const provider of providerOrder) {
+    const preferredProviderSelected = scalarConfigured && preserveFallbackChain && provider === scalarProvider.value;
+    const providerSource = preferredProviderSelected ? scalarProvider.source : providerOrderSource;
+    const providerSourcePath = preferredProviderSelected ? scalarProvider.sourcePath ?? "resolution-engine:preferred-provider" : providerOrderSourcePath;
+    if (!inRegistry(provider, registry)) {
+      emitResolutionWarningOnce({
+        operation: "resolveCandidates",
+        provider,
+        message: `Provider '${provider}' from ${providerSource}:${providerSourcePath} is not in the registry; skipping`
+      });
+      continue;
+    }
+    const head = (preferredProviderSelected && scalarModelConfigured ? [scalarModel] : [getProviderEnvModel(provider), provider === scalarProvider.value ? purposeModel : null]).find((model) => model && isRunnableModel(provider, model, registry));
+    const models = [...head ? [head] : [], ...retiredModelOrder(provider, layers)].filter(
+      (model, at, all) => all.findIndex((other) => other.value === model.value) === at && isRunnableModel(provider, model, registry)
+    );
+    const shown = models.length === 0 ? chainProviderModel(provider, cli, cwd, registry) : null;
+    if (shown) models.push(shown);
+    if (models.length === 0) {
+      const source = `providers.yaml#providers.${provider}.models.default`;
+      emitResolutionWarningOnce({
+        operation: "resolveCandidates",
+        provider,
+        source,
+        message: `Provider '${provider}' has no runnable model (no valid pin, and ${source} does not resolve); skipping`
+      });
+      continue;
+    }
+    for (const model of models) {
+      candidates.push(
+        buildCandidate({
+          provider,
+          model: model.value,
+          purpose,
+          index: candidates.length,
+          providerSource,
+          providerSourcePath,
+          modelSource: model.source,
+          modelSourcePath: model.sourcePath ?? "resolution-engine:model"
+        })
+      );
+    }
+  }
+  return candidates;
+}
+function resolvePreferred(purpose, options) {
+  const candidates = resolveCandidates(purpose, options);
+  const first = candidates[0];
+  if (first) {
+    return first;
+  }
+  const cwd = options?.cwd ?? process.cwd();
+  const registry = loadProviderRegistryForCwd(cwd);
+  const registryPath = ProviderRegistry.getLoadedConfigPath() ?? resolveProvidersConfigPath({ cwd });
+  const fallbackProvider = Object.values(registry.providers).filter((p) => p.enabled).sort((a, b) => a.order - b.order)[0]?.id;
+  if (!fallbackProvider) {
+    throw new Error(
+      `Invalid provider registry at ${registryPath}: no providers are enabled. Enable at least one providers.<id>.enabled entry.`
+    );
+  }
+  return {
+    provider: fallbackProvider,
+    model: "auto",
+    source: "registry",
+    sourcePath: `${registryPath}#providers.*.order`,
+    providerSource: "registry",
+    providerSourcePath: `${registryPath}#providers.*.order`,
+    modelSource: "fallback",
+    modelSourcePath: "resolution-engine:fallback-model",
+    purpose,
+    index: 0
+  };
+}
+function formatResolvedValue(resolved) {
+  let result = String(resolved.value);
+  result += ` (from: ${resolved.source}`;
+  if (resolved.sourcePath) {
+    result += `, path: ${resolved.sourcePath}`;
+  }
+  result += ")";
+  return result;
+}
+
+export {
+  resolveFastModel,
+  DEPRECATED_JUDGE_MODELS_ALIASES,
+  JUDGE_SPECIFICITY,
+  coherentJudgeModelForProvider,
+  inferProviderFromRegistryOwnership,
+  reconcileJudgePair,
+  parseJudgeModelOverride,
+  assertJudgeRoleCapabilities,
+  resolveCanonicalJudgeRoles,
+  resolveCanonicalJudgeTier,
+  warnIfExplicitModelUnobserved,
+  assertExplicitModelNotMistyped,
+  emitResolutionWarningOnce,
+  getActiveProfile,
+  resolveConfiguredProviderOrder,
+  enterReadOnlyProviderOrderView,
+  assertUsableProviderOrder,
+  keepInstalledProviders,
+  resolveProviderOrder,
+  GUARD_DIR_REL,
+  CHECK_SCRIPT_REL,
+  CONFIG_FILE_REL,
+  POLICY_FILE_REL,
+  LOCK_FILE_REL,
+  SETUP_PLAYBOOK_REL,
+  CI_WORKFLOW_TEMPLATE_FILE,
+  GENERATED_HASHED_FILES,
+  getGuardKitTemplatesDir,
+  buildAttributionPolicy,
+  readAttributionPolicy,
+  JUDGE_TYPE_TO_CONFIG_KEY,
+  judgeLayerBlocks,
+  resolveJudgeBinding,
+  InvalidProviderModelError,
+  normalizeProviderId,
+  validateModelForProvider,
+  resolveJudgeType,
+  clearConfigCaches,
+  loadBuildConfigFile,
+  loadConfigLayers,
+  resolveAskConfig,
+  resolveProgressNarrationConfig,
+  resolveEphemeralTelemetryReplication,
+  loadProviderRegistryForCwd,
+  checkDefaultProviderEnablement,
+  DefaultProviderUnusableError,
+  assertDefaultProviderEnabled,
+  resolveDefaultProvider,
+  resolveDefaultJudgeProvider,
+  resolveReadyDefaultProvider,
+  resolveGitAttribution,
+  resolveProviderModel,
+  resolveProviderReasoningEffort,
+  resolveJudgeProvider,
+  resolveJudgeModel,
+  resolveJudgeReasoningEffort,
+  resolveSynthesisModel,
+  resolveSynthesisProvider,
+  resolveSynthesisReasoningEffort,
+  resolveSplitterExecution,
+  resolveSplitterModel,
+  resolveSplitterReasoningEffort,
+  resolveIntentDecompositionHints,
+  resolveIntentNonGoals,
+  resolveIntentDisableRepoContext,
+  resolveJudgeConfig,
+  resolveConfig,
+  resolvePlanExecuteConfig,
+  resolvePlanExecuteBlockerMode,
+  resolveConfiguredProviderExecutionTransport,
+  resolveProviderExecutionTransport,
+  resolveProviderExecutionTransportConfig,
+  resolveCandidates,
+  resolvePreferred,
+  formatResolvedValue
+};
+//# sourceMappingURL=chunk-C3DH3NCY.js.map