@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-EN62WLFD.js

@@ -0,0 +1,849 @@
+import {
+  DEFAULT_MATRIX_ESCALATION_THRESHOLDS,
+  buildMatrixReplayEnv,
+  normalizeMatrixEscalationThresholds,
+  readMatrixEscalationThresholdPatchFromEnv
+} from "./chunk-HHWDTB6S.js";
+import {
+  formatIdleTimeoutPlan,
+  resolveIdleTimeoutPlan
+} from "./chunk-WJAL4JL3.js";
+import {
+  assertUsableProviderOrder,
+  resolveJudgeType,
+  resolveProviderOrder
+} from "./chunk-C3DH3NCY.js";
+import {
+  SUPPORTED_JUDGE_IDS,
+  canonicalJudgeId,
+  retiredJudgeSelectionError
+} from "./chunk-IVZEONFC.js";
+import {
+  isSkipAuthEnvActive
+} from "./chunk-33IGPPUI.js";
+import {
+  consumeBuildConfigRead,
+  readCanonicalBuildConfig,
+  selectedBuildConfigCandidate
+} from "./chunk-FKCG7K6H.js";
+import {
+  isProviderCliResolvable
+} from "./chunk-KKQKWAMF.js";
+import {
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+import {
+  getConfigPaths
+} from "./chunk-35J4NE6S.js";
+import {
+  quotePosixShellArg
+} from "./chunk-N5DX4JAK.js";
+
+// src/core/config/compete-config-resolver.ts
+import { createHash } from "crypto";
+import { resolve } from "path";
+
+// src/core/config/compete-judge-run.ts
+function normalizeJudgeRunToken(value) {
+  if (!value?.trim()) return null;
+  const retired = retiredJudgeSelectionError(value);
+  if (retired) throw retired;
+  const judge = canonicalJudgeId(value);
+  if (!judge) {
+    throw new Error(
+      `Unknown judge '${value.trim()}'. Supported judges: ${SUPPORTED_JUDGE_IDS.join(", ")}.`
+    );
+  }
+  return judge;
+}
+function normalizeJudgeRunList(value) {
+  if (value === true) return "ai";
+  if (typeof value !== "string") return void 0;
+  const judges = value.split(",").map((entry) => normalizeJudgeRunToken(entry)).filter((entry) => entry !== null).filter((entry, index, entries) => entries.indexOf(entry) === index);
+  return judges.length > 0 ? judges.join(",") : void 0;
+}
+function normalizeJudgeRunForDisplay(aiJudgeRun) {
+  const normalizedRun = normalizeJudgeRunList(aiJudgeRun);
+  if (!normalizedRun) return null;
+  const judges = [
+    ...new Set(
+      normalizedRun.split(",").map((judge) => judge.trim()).filter(Boolean)
+    )
+  ];
+  return judges.length > 0 ? judges.join(",") : null;
+}
+
+// src/core/config/compete-replay-extras.ts
+function quoteReplayValue(value) {
+  return /^[A-Za-z0-9_./:=,+@%-]+$/.test(value) ? value : quotePosixShellArg(value);
+}
+function replayExtraGroups(options, fusionRun, readoptsFusion = false) {
+  const groups = [];
+  if (readoptsFusion && options.research === true) {
+    groups.push(["--research"]);
+  }
+  if (!fusionRun) {
+    if (options.judgeModels) {
+      groups.push(["--judge-models", options.judgeModels]);
+    }
+    for (const override of options.judgeModel ?? []) {
+      groups.push(["--judge-model", override]);
+    }
+    if (options.judgeAllowUnsafeModel === true) {
+      groups.push(["--judge-force-model"]);
+    }
+    if (options.synthesize === true) {
+      groups.push(["--synthesize"]);
+    } else if (options.synthesize === false) {
+      groups.push(["--no-synthesize"]);
+    }
+  }
+  if (options.synthesisModel) {
+    groups.push(["--synthesis-model", options.synthesisModel]);
+  }
+  if (fusionRun) {
+    if (options.research === false) {
+      groups.push(["--no-research"]);
+    }
+    if (options.reconcile === true) {
+      groups.push(["--reconcile"]);
+    }
+  }
+  return groups;
+}
+function buildReplayExtraArgv(options, fusionRun) {
+  return replayExtraGroups(options, fusionRun).flat();
+}
+function buildReplayExtraFlags(options, fusionRun, readoptsFusion = false) {
+  return replayExtraGroups(options, fusionRun, readoptsFusion).map(
+    (group) => group.map(quoteReplayValue).join(" ")
+  );
+}
+function buildVariantReplayFlags(variants, variantOpts) {
+  return [
+    ...variants.map((v) => `--variant ${v}`),
+    ...(variantOpts ?? []).map((o) => `--variant-opt ${o}`)
+  ];
+}
+
+// src/core/config/compete-config-resolver.ts
+var RESOLVER_VERSION = 2;
+var _ENV_JUDGE_NEW = "BUILD_JUDGE_TYPE";
+var _ENV_JUDGE_LEGACY = "BUILD_JUDGE";
+var _legacyJudgeWarningEmitted = false;
+var _multiJudgeTypeWarningEmitted = false;
+var _configJudgeLineupWarningEmitted = false;
+function readJudgeTypeEnv() {
+  const newVal = process.env[_ENV_JUDGE_NEW];
+  const legacyVal = process.env[_ENV_JUDGE_LEGACY];
+  if (legacyVal !== void 0 && newVal === void 0 && !_legacyJudgeWarningEmitted) {
+    console.warn(`Warning: ${_ENV_JUDGE_LEGACY} is deprecated; use ${_ENV_JUDGE_NEW}.`);
+    _legacyJudgeWarningEmitted = true;
+  }
+  return newVal ?? legacyVal;
+}
+function _resetJudgeWarningGuard() {
+  _legacyJudgeWarningEmitted = false;
+  _multiJudgeTypeWarningEmitted = false;
+  _configJudgeLineupWarningEmitted = false;
+}
+function warnDeprecatedJudgeTypeLineup(value, replacement) {
+  if (_multiJudgeTypeWarningEmitted) return;
+  console.warn(
+    `Warning: BUILD_JUDGE_TYPE=${value} is deprecated for selecting multi-judge engines; use ${replacement}.`
+  );
+  _multiJudgeTypeWarningEmitted = true;
+}
+function warnDeprecatedConfigJudgeLineup(source, value) {
+  if (_configJudgeLineupWarningEmitted) return;
+  console.warn(
+    `Warning: compete.judge=${value} in ${source} config is deprecated for selecting multi-judge engines; use compete.judgeRun=${value} and compete.judgePrimary=${value}.`
+  );
+  _configJudgeLineupWarningEmitted = true;
+}
+function warnConfigJudgeOffIgnoresLineup(source, field) {
+  console.warn(`Warning: compete.${field} in ${source} config ignored because compete.judge=off.`);
+}
+function classifyJudgeFieldValue(value, cwd) {
+  if (value === "off") {
+    return { kind: "off" };
+  }
+  if (value.startsWith("experimental:")) {
+    return { kind: "experimental", value };
+  }
+  const retired = retiredJudgeSelectionError(value);
+  if (retired) throw retired;
+  if (value === "ai" || value === "multi-lens") {
+    const delegated = resolveJudgeType({ judgeType: value }, cwd);
+    return { kind: "implementation", value: delegated.value };
+  }
+  return null;
+}
+function resolveJudgeFieldValue(value, cwd) {
+  const classified = classifyJudgeFieldValue(value, cwd);
+  if (!classified) return null;
+  switch (classified.kind) {
+    case "off":
+      return { judge: "off" };
+    case "experimental":
+      return { judge: classified.value };
+    case "implementation":
+      return classified.value === "ai" ? { judge: "ai" } : { judge: "ai", lineup: classified.value };
+  }
+}
+var BUILT_IN = {
+  variants: null,
+  judge: "ai",
+  judgeRun: "ai",
+  judgePrimary: "ai",
+  completionMode: "auto",
+  synthesisStrategy: "agentic-synthesis",
+  timeout: 30,
+  requireMinVariants: 0,
+  matrixEscalation: DEFAULT_MATRIX_ESCALATION_THRESHOLDS
+};
+async function discoverAvailableProviders() {
+  let providers;
+  try {
+    providers = ProviderRegistry.getEnabledProviders();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Provider registry initialization failed during provider discovery: ${message}`
+    );
+  }
+  return providers.flatMap((provider) => {
+    if (!provider.auth) return [];
+    const skipEnvVar = provider.auth.skip_env_var;
+    if (skipEnvVar && isSkipAuthEnvActive(skipEnvVar)) {
+      return [
+        {
+          providerId: provider.id,
+          available: true,
+          authMethod: "skip_env",
+          discoverySource: "skip_env"
+        }
+      ];
+    }
+    return [
+      {
+        providerId: provider.id,
+        available: isProviderCliResolvable(provider.id),
+        authMethod: "cli_check",
+        discoverySource: "cli_check"
+      }
+    ];
+  });
+}
+function orderAvailableProviders(discoveryResults, preferredProviderId, providerOrder = []) {
+  const sorted = discoveryResults.filter((result) => result.available);
+  if (sorted.length === 0) return [];
+  const orderedProviders = [
+    ...preferredProviderId ? [preferredProviderId] : [],
+    ...providerOrder.filter((provider) => provider !== preferredProviderId)
+  ];
+  if (providerOrder.length > 0) {
+    const eligible = sorted.filter((result) => orderedProviders.includes(result.providerId));
+    eligible.sort(
+      (a, b) => orderedProviders.indexOf(a.providerId) - orderedProviders.indexOf(b.providerId)
+    );
+    return eligible.map((result) => result.providerId);
+  }
+  if (preferredProviderId) {
+    const idx = sorted.findIndex((result) => result.providerId === preferredProviderId);
+    if (idx > 0) {
+      const spliced = sorted.splice(idx, 1);
+      const preferred = spliced[0];
+      if (preferred) sorted.unshift(preferred);
+    }
+  }
+  return sorted.map((result) => result.providerId);
+}
+function deriveDefaultVariants(discoveryResults, preferredProviderId, providerOrder = []) {
+  return orderAvailableProviders(discoveryResults, preferredProviderId, providerOrder).slice(0, 2);
+}
+function toCompeteSource(source) {
+  const map = {
+    project: "repo",
+    "user-config": "user",
+    env: "env"
+  };
+  return source ? map[source] : void 0;
+}
+function resolvePanelOrder(projectRoot, invocationPreferred) {
+  const oneOrder = resolveProviderOrder({ cwd: projectRoot });
+  const preferred = oneOrder.preferred;
+  const layers = [
+    ["repo", loadRepoCompeteConfigLayer(projectRoot)],
+    ["user", loadUserCompeteConfigLayer(projectRoot)]
+  ];
+  for (const [source, layer] of layers) {
+    const configured = layer?.compete?.providerOrder;
+    const legacy = Array.isArray(configured) ? configured.filter(
+      (provider) => typeof provider === "string" && provider.trim().length > 0
+    ) : [];
+    if (legacy.length > 0) return { order: legacy, preferred: preferred?.value, source };
+  }
+  if (invocationPreferred && oneOrder.unusable && oneOrder.ordered.length === 0) {
+    return { order: [invocationPreferred], preferred: invocationPreferred };
+  }
+  assertUsableProviderOrder(oneOrder, oneOrder.ordered);
+  return {
+    order: oneOrder.ordered,
+    preferred: preferred?.value,
+    source: toCompeteSource(preferred?.source) ?? toCompeteSource(oneOrder.source)
+  };
+}
+async function resolveAvailableProviderOrder(options = {}) {
+  const discovered = await discoverAvailableProviders();
+  const panel = resolvePanelOrder(options.projectRoot ?? process.cwd(), options.preferredProvider);
+  return orderAvailableProviders(
+    discovered,
+    options.preferredProvider ?? panel.preferred,
+    panel.order
+  );
+}
+function loadCompeteConfigLayer(baseCandidates) {
+  for (const baseCandidate of baseCandidates) {
+    const selected = selectedBuildConfigCandidate(baseCandidate);
+    const read = readCanonicalBuildConfig(selected);
+    if (read.status === "missing") continue;
+    const config = consumeBuildConfigRead(read);
+    if (!config) continue;
+    const compete = config.compete && typeof config.compete === "object" ? config.compete : null;
+    const competeMatrix = compete?.matrixEscalation;
+    const judgeMatrix = config.judge && typeof config.judge === "object" ? config.judge.matrixEscalation : void 0;
+    const matrixEscalation = competeMatrix ?? judgeMatrix;
+    return {
+      compete,
+      matrix: matrixEscalation ? { matrixEscalation } : null
+    };
+  }
+  return null;
+}
+function loadUserCompeteConfigLayer(projectRoot) {
+  const { userConfigFile } = getConfigPaths(projectRoot);
+  return loadCompeteConfigLayer([userConfigFile]);
+}
+function loadRepoCompeteConfigLayer(projectRoot) {
+  return loadCompeteConfigLayer([
+    resolve(projectRoot, ".build-project", "config", "build.config.jsonc"),
+    // Explicit legacy project-root location. It is consulted only when the
+    // canonical .build-project/config layer is absent, never when that layer is invalid.
+    resolve(projectRoot, "build.config.jsonc")
+  ]);
+}
+function readEnvLayer() {
+  const result = {};
+  const completionModeRaw = process.env.BUILD_COMPLETION_MODE;
+  if (completionModeRaw?.trim()) {
+    const v = completionModeRaw.trim();
+    if (["auto", "isolated", "none", "pr", "branch"].includes(v)) {
+      result.completionMode = v;
+    }
+  }
+  const judgeRaw = readJudgeTypeEnv();
+  if (judgeRaw?.trim()) {
+    const v = judgeRaw.trim();
+    const resolved = resolveJudgeFieldValue(v);
+    if (resolved) {
+      result.judge = resolved.judge;
+      if (resolved.lineup) {
+        result.judgeRun = resolved.lineup;
+        result.judgePrimary = resolved.lineup;
+        warnDeprecatedJudgeTypeLineup(v, `BUILD_JUDGE_RUN=${v} BUILD_JUDGE_PRIMARY=${v}`);
+      }
+    }
+  }
+  const judgeOff = result.judge === "off";
+  const judgeRunRaw = process.env.BUILD_JUDGE_RUN ?? process.env.BUILD_AI_JUDGE_RUN;
+  const judgeRun = normalizeJudgeRunList(judgeRunRaw);
+  if (judgeRun && !judgeOff) {
+    result.judge = "ai";
+    result.judgeRun = judgeRun;
+  } else if (judgeRun && judgeOff) {
+    console.warn(`Warning: BUILD_JUDGE_RUN=${judgeRunRaw} ignored because BUILD_JUDGE_TYPE=off.`);
+  }
+  const judgePrimaryRaw = process.env.BUILD_JUDGE_PRIMARY ?? process.env.BUILD_AI_JUDGE_PRIMARY;
+  const judgePrimary = normalizeJudgeRunToken(judgePrimaryRaw);
+  if (judgePrimary && !judgeOff) {
+    result.judge = "ai";
+    result.judgePrimary = judgePrimary;
+  } else if (judgePrimary && judgeOff) {
+    console.warn(
+      `Warning: BUILD_JUDGE_PRIMARY=${judgePrimaryRaw} ignored because BUILD_JUDGE_TYPE=off.`
+    );
+  }
+  const synthesisStrategyRaw = process.env.BUILD_SYNTHESIS_STRATEGY;
+  const normalizedSynthesisStrategy = synthesisStrategyRaw?.trim();
+  const hasExplicitSynthesisStrategy = Boolean(
+    normalizedSynthesisStrategy && isValidSynthesisStrategy(normalizedSynthesisStrategy)
+  );
+  if (hasExplicitSynthesisStrategy && normalizedSynthesisStrategy) {
+    result.synthesisStrategy = normalizedSynthesisStrategy;
+  }
+  const aiFirstRaw = process.env.BUILD_SYNTHESIS_AI_FIRST;
+  if (aiFirstRaw?.trim()) {
+    const normalized = aiFirstRaw.trim().toLowerCase();
+    if (normalized === "1" || normalized === "true") {
+      if (hasExplicitSynthesisStrategy) {
+        console.warn(
+          "Warning: BUILD_SYNTHESIS_AI_FIRST ignored because BUILD_SYNTHESIS_STRATEGY is set."
+        );
+      } else {
+        result.synthesisStrategy = "agentic-synthesis";
+      }
+    }
+  }
+  const timeoutMsRaw = process.env.BUILD_TIMEOUT_MS;
+  if (timeoutMsRaw?.trim()) {
+    const ms = parseInt(timeoutMsRaw.trim(), 10);
+    if (!Number.isNaN(ms) && ms > 0) {
+      result.timeout = Math.ceil(ms / 6e4);
+    }
+  }
+  return result;
+}
+function computeSchemaHash(config) {
+  const canonical = JSON.stringify({
+    resolverVersion: config.resolverVersion,
+    variants: [...config.variants].sort(),
+    variantOpts: [...config.variantOpts ?? []].sort(),
+    judge: config.judge,
+    judgeRun: config.judgeRun,
+    judgePrimary: config.judgePrimary,
+    completionMode: config.completionMode,
+    synthesisStrategy: config.synthesisStrategy,
+    timeout: config.timeout,
+    requireMinVariants: config.requireMinVariants ?? 0,
+    matrixEscalation: config.matrixEscalation ?? DEFAULT_MATRIX_ESCALATION_THRESHOLDS
+  });
+  return createHash("sha256").update(canonical).digest("hex").slice(0, 8);
+}
+function resolveMatrixEscalationCascade(userLayer, repoLayer) {
+  let matrixEscalation = BUILT_IN.matrixEscalation;
+  let source = "built-in";
+  const userPatch = userLayer?.compete?.matrixEscalation ?? userLayer?.matrix?.matrixEscalation;
+  if (userPatch) {
+    matrixEscalation = normalizeMatrixEscalationThresholds(userPatch);
+    source = "user";
+  }
+  const repoPatch = repoLayer?.compete?.matrixEscalation ?? repoLayer?.matrix?.matrixEscalation;
+  if (repoPatch) {
+    matrixEscalation = normalizeMatrixEscalationThresholds(repoPatch);
+    source = "repo";
+  }
+  const envPatch = readMatrixEscalationThresholdPatchFromEnv();
+  if (Object.keys(envPatch).length > 0) {
+    matrixEscalation = normalizeMatrixEscalationThresholds(envPatch, matrixEscalation);
+    source = "env";
+  }
+  return { matrixEscalation, source };
+}
+function resolveMatrixEscalationThresholds(projectRoot = process.cwd()) {
+  return resolveMatrixEscalationCascade(
+    loadUserCompeteConfigLayer(projectRoot),
+    loadRepoCompeteConfigLayer(projectRoot)
+  ).matrixEscalation;
+}
+async function resolveCompeteConfig(cliFlags = {}, options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  let resolvedJudge = BUILT_IN.judge;
+  let resolvedJudgeRun = BUILT_IN.judgeRun;
+  let resolvedJudgePrimary = BUILT_IN.judgePrimary;
+  let resolvedCompletionMode = BUILT_IN.completionMode;
+  let resolvedSynthesisStrategy = BUILT_IN.synthesisStrategy;
+  let resolvedTimeout = BUILT_IN.timeout;
+  let resolvedRequireMinVariants = BUILT_IN.requireMinVariants;
+  let resolvedVariants = null;
+  let sourceJudge = "built-in";
+  let sourceJudgeRun = "built-in";
+  let sourceJudgePrimary = "built-in";
+  let sourceCompletionMode = "built-in";
+  let sourceSynthesisStrategy = "built-in";
+  let sourceTimeout = "built-in";
+  let sourceRequireMinVariants = "built-in";
+  let sourceVariants = "built-in";
+  const userLayer = loadUserCompeteConfigLayer(projectRoot);
+  const userConfig = userLayer?.compete ?? null;
+  if (userConfig) {
+    if (userConfig.variants && Array.isArray(userConfig.variants) && userConfig.variants.length > 0) {
+      resolvedVariants = userConfig.variants;
+      sourceVariants = "user";
+    }
+    const userJudge = userConfig.judge ? resolveJudgeFieldValue(userConfig.judge, projectRoot) : null;
+    if (userJudge) {
+      if (userJudge.lineup) {
+        warnDeprecatedConfigJudgeLineup("user", userJudge.lineup);
+        resolvedJudgeRun = userJudge.lineup;
+        resolvedJudgePrimary = userJudge.lineup;
+        sourceJudgeRun = "user";
+        sourceJudgePrimary = "user";
+      }
+      resolvedJudge = userJudge.judge;
+      sourceJudge = "user";
+    }
+    const userJudgeOff = userJudge?.judge === "off";
+    const userJudgeRun = normalizeJudgeRunList(userConfig.judgeRun);
+    if (userJudgeRun && userJudgeOff) {
+      warnConfigJudgeOffIgnoresLineup("user", "judgeRun");
+    } else if (userJudgeRun) {
+      resolvedJudge = "ai";
+      resolvedJudgeRun = userJudgeRun;
+      sourceJudge = "user";
+      sourceJudgeRun = "user";
+    }
+    const userJudgePrimary = normalizeJudgeRunToken(userConfig.judgePrimary);
+    if (userJudgePrimary && userJudgeOff) {
+      warnConfigJudgeOffIgnoresLineup("user", "judgePrimary");
+    } else if (userJudgePrimary) {
+      resolvedJudge = "ai";
+      resolvedJudgePrimary = userJudgePrimary;
+      sourceJudge = "user";
+      sourceJudgePrimary = "user";
+    }
+    if (userConfig.completionMode && isValidCompletionMode(userConfig.completionMode)) {
+      resolvedCompletionMode = userConfig.completionMode;
+      sourceCompletionMode = "user";
+    }
+    if (userConfig.synthesisStrategy && isValidSynthesisStrategy(userConfig.synthesisStrategy)) {
+      resolvedSynthesisStrategy = userConfig.synthesisStrategy;
+      sourceSynthesisStrategy = "user";
+    }
+    if (typeof userConfig.timeout === "number" && userConfig.timeout > 0) {
+      resolvedTimeout = userConfig.timeout;
+      sourceTimeout = "user";
+    }
+    if (typeof userConfig.requireMinVariants === "number" && userConfig.requireMinVariants >= 0) {
+      resolvedRequireMinVariants = userConfig.requireMinVariants;
+      sourceRequireMinVariants = "user";
+    }
+  }
+  const repoLayer = loadRepoCompeteConfigLayer(projectRoot);
+  const repoConfig = repoLayer?.compete ?? null;
+  if (repoConfig) {
+    if (repoConfig.variants && Array.isArray(repoConfig.variants) && repoConfig.variants.length > 0) {
+      resolvedVariants = repoConfig.variants;
+      sourceVariants = "repo";
+    }
+    const repoJudge = repoConfig.judge ? resolveJudgeFieldValue(repoConfig.judge, projectRoot) : null;
+    if (repoJudge) {
+      if (repoJudge.lineup) {
+        warnDeprecatedConfigJudgeLineup("repo", repoJudge.lineup);
+        resolvedJudgeRun = repoJudge.lineup;
+        resolvedJudgePrimary = repoJudge.lineup;
+        sourceJudgeRun = "repo";
+        sourceJudgePrimary = "repo";
+      }
+      resolvedJudge = repoJudge.judge;
+      sourceJudge = "repo";
+    }
+    const repoJudgeOff = repoJudge?.judge === "off";
+    const repoJudgeRun = normalizeJudgeRunList(repoConfig.judgeRun);
+    if (repoJudgeRun && repoJudgeOff) {
+      warnConfigJudgeOffIgnoresLineup("repo", "judgeRun");
+    } else if (repoJudgeRun) {
+      resolvedJudge = "ai";
+      resolvedJudgeRun = repoJudgeRun;
+      sourceJudge = "repo";
+      sourceJudgeRun = "repo";
+    }
+    const repoJudgePrimary = normalizeJudgeRunToken(repoConfig.judgePrimary);
+    if (repoJudgePrimary && repoJudgeOff) {
+      warnConfigJudgeOffIgnoresLineup("repo", "judgePrimary");
+    } else if (repoJudgePrimary) {
+      resolvedJudge = "ai";
+      resolvedJudgePrimary = repoJudgePrimary;
+      sourceJudge = "repo";
+      sourceJudgePrimary = "repo";
+    }
+    if (repoConfig.completionMode && isValidCompletionMode(repoConfig.completionMode)) {
+      resolvedCompletionMode = repoConfig.completionMode;
+      sourceCompletionMode = "repo";
+    }
+    if (repoConfig.synthesisStrategy && isValidSynthesisStrategy(repoConfig.synthesisStrategy)) {
+      resolvedSynthesisStrategy = repoConfig.synthesisStrategy;
+      sourceSynthesisStrategy = "repo";
+    }
+    if (typeof repoConfig.timeout === "number" && repoConfig.timeout > 0) {
+      resolvedTimeout = repoConfig.timeout;
+      sourceTimeout = "repo";
+    }
+    if (typeof repoConfig.requireMinVariants === "number" && repoConfig.requireMinVariants >= 0) {
+      resolvedRequireMinVariants = repoConfig.requireMinVariants;
+      sourceRequireMinVariants = "repo";
+    }
+  }
+  const envLayer = readEnvLayer();
+  if (envLayer.completionMode !== void 0) {
+    resolvedCompletionMode = envLayer.completionMode;
+    sourceCompletionMode = "env";
+  }
+  if (envLayer.judge !== void 0) {
+    resolvedJudge = envLayer.judge;
+    sourceJudge = "env";
+  }
+  if (envLayer.judgeRun !== void 0) {
+    resolvedJudgeRun = envLayer.judgeRun;
+    sourceJudgeRun = "env";
+  }
+  if (envLayer.judgePrimary !== void 0) {
+    resolvedJudgePrimary = envLayer.judgePrimary;
+    sourceJudgePrimary = "env";
+  }
+  if (envLayer.synthesisStrategy !== void 0) {
+    resolvedSynthesisStrategy = envLayer.synthesisStrategy;
+    sourceSynthesisStrategy = "env";
+  }
+  if (envLayer.timeout !== void 0) {
+    resolvedTimeout = envLayer.timeout;
+    sourceTimeout = "env";
+  }
+  const { matrixEscalation: resolvedMatrixEscalation, source: sourceMatrixEscalation } = resolveMatrixEscalationCascade(userLayer, repoLayer);
+  if (cliFlags.variant && cliFlags.variant.length > 0) {
+    resolvedVariants = cliFlags.variant;
+    sourceVariants = "flag";
+  }
+  const cliJudge = cliFlags.judge ? resolveJudgeFieldValue(cliFlags.judge, projectRoot) : null;
+  if (cliJudge) {
+    if (cliJudge.lineup) {
+      resolvedJudgeRun = cliJudge.lineup;
+      resolvedJudgePrimary = cliJudge.lineup;
+      sourceJudgeRun = "flag";
+      sourceJudgePrimary = "flag";
+    }
+    resolvedJudge = cliJudge.judge;
+    sourceJudge = "flag";
+  }
+  const cliJudgeRun = normalizeJudgeRunList(cliFlags.judgeRun);
+  if (cliJudgeRun !== void 0) {
+    resolvedJudge = "ai";
+    resolvedJudgeRun = cliJudgeRun;
+    sourceJudge = "flag";
+    sourceJudgeRun = "flag";
+  }
+  const cliJudgePrimary = normalizeJudgeRunToken(cliFlags.judgePrimary);
+  if (cliJudgePrimary !== null) {
+    resolvedJudge = "ai";
+    resolvedJudgePrimary = cliJudgePrimary;
+    sourceJudge = "flag";
+    sourceJudgePrimary = "flag";
+  }
+  if (cliFlags.completionMode && isValidCompletionMode(cliFlags.completionMode)) {
+    resolvedCompletionMode = cliFlags.completionMode;
+    sourceCompletionMode = "flag";
+  }
+  if (cliFlags.synthesisStrategy && isValidSynthesisStrategy(cliFlags.synthesisStrategy)) {
+    resolvedSynthesisStrategy = cliFlags.synthesisStrategy;
+    sourceSynthesisStrategy = "flag";
+  }
+  if (typeof cliFlags.timeout === "number" && cliFlags.timeout > 0) {
+    resolvedTimeout = cliFlags.timeout;
+    sourceTimeout = "flag";
+  }
+  if (typeof cliFlags.requireMinVariants === "number" && cliFlags.requireMinVariants >= 0) {
+    resolvedRequireMinVariants = cliFlags.requireMinVariants;
+    sourceRequireMinVariants = "flag";
+  }
+  if (!resolvedVariants) {
+    const discovered = await discoverAvailableProviders();
+    const panel = resolvePanelOrder(projectRoot);
+    const defaults = deriveDefaultVariants(discovered, panel.preferred, panel.order);
+    if (defaults.length === 0) {
+      throw new Error(
+        'No available providers found. Run "build config resolved" to check provider setup.\nInstall at least one provider CLI, then retry.'
+      );
+    }
+    resolvedVariants = defaults;
+    sourceVariants = panel.source ?? "built-in";
+    if (resolvedVariants.length === 1) {
+      console.warn(
+        "Competition degraded: only 1 provider found. Install another provider to compare."
+      );
+    }
+  }
+  if (resolvedRequireMinVariants > 0 && resolvedVariants.length < resolvedRequireMinVariants) {
+    throw new Error(
+      `Competition degraded: only ${resolvedVariants.length} variant(s) resolved, but requireMinVariants=${resolvedRequireMinVariants}.
+Authenticate more providers or lower requireMinVariants.`
+    );
+  }
+  const schemaHash = computeSchemaHash({
+    resolverVersion: RESOLVER_VERSION,
+    variants: resolvedVariants,
+    ...cliFlags.variantOpt && cliFlags.variantOpt.length > 0 ? { variantOpts: cliFlags.variantOpt } : {},
+    judge: resolvedJudge,
+    ...resolvedJudgeRun !== void 0 ? { judgeRun: resolvedJudgeRun } : {},
+    ...resolvedJudgePrimary !== void 0 ? { judgePrimary: resolvedJudgePrimary } : {},
+    completionMode: resolvedCompletionMode,
+    synthesisStrategy: resolvedSynthesisStrategy,
+    timeout: resolvedTimeout,
+    requireMinVariants: resolvedRequireMinVariants,
+    matrixEscalation: resolvedMatrixEscalation
+  });
+  const resolvedVariantOpts = cliFlags.variantOpt && cliFlags.variantOpt.length > 0 ? [...cliFlags.variantOpt] : void 0;
+  return {
+    variants: resolvedVariants,
+    ...resolvedVariantOpts ? { variantOpts: resolvedVariantOpts } : {},
+    judge: resolvedJudge,
+    judgeRun: resolvedJudgeRun,
+    judgePrimary: resolvedJudgePrimary,
+    completionMode: resolvedCompletionMode,
+    synthesisStrategy: resolvedSynthesisStrategy,
+    timeout: resolvedTimeout,
+    requireMinVariants: resolvedRequireMinVariants,
+    matrixEscalation: resolvedMatrixEscalation,
+    sources: {
+      variants: sourceVariants,
+      judge: sourceJudge,
+      ...sourceJudgeRun !== void 0 ? { judgeRun: sourceJudgeRun } : {},
+      ...sourceJudgePrimary !== void 0 ? { judgePrimary: sourceJudgePrimary } : {},
+      completionMode: sourceCompletionMode,
+      synthesisStrategy: sourceSynthesisStrategy,
+      timeout: sourceTimeout,
+      requireMinVariants: sourceRequireMinVariants,
+      matrixEscalation: sourceMatrixEscalation
+    },
+    resolverVersion: RESOLVER_VERSION,
+    schemaHash
+  };
+}
+function isValidCompletionMode(value) {
+  return ["auto", "isolated", "none", "pr", "branch"].includes(value);
+}
+function isValidSynthesisStrategy(value) {
+  return ["agentic-synthesis", "cherry-pick"].includes(value);
+}
+function buildReplayFlags(task, config, options = {}) {
+  const keepVariantOpts = options.fusionRun === true && (config.variantOpts?.length ?? 0) > 0;
+  const fusionRun = options.fusionRun === true && !keepVariantOpts;
+  const matrixEnv = buildMatrixReplayEnv(config.matrixEscalation);
+  const parts = [
+    `${matrixEnv}${fusionRun ? "build run fusion" : "build run competition"} ${JSON.stringify(task)}`
+  ];
+  parts.push(...buildVariantReplayFlags(config.variants, config.variantOpts));
+  if (keepVariantOpts) parts.push("--analysis-only", "--analysis-synthesis", "--judge off");
+  if (!fusionRun && !keepVariantOpts && config.judge !== BUILT_IN.judge) {
+    parts.push(`--judge ${config.judge}`);
+  }
+  const judgeDisabled = fusionRun || keepVariantOpts || config.judge === "off";
+  const judgeRun = judgeDisabled ? null : normalizeJudgeRunForDisplay(options.aiJudgeRun ?? config.judgeRun);
+  const judgePrimary = judgeDisabled ? void 0 : options.aiJudgePrimary ?? config.judgePrimary;
+  if (judgeRun) {
+    parts.push(`--judge-run ${judgeRun}`);
+  }
+  if (judgePrimary) {
+    parts.push(`--judge-primary ${judgePrimary}`);
+  }
+  if (!fusionRun && config.completionMode !== BUILT_IN.completionMode) {
+    parts.push(`--completion-mode ${config.completionMode}`);
+  }
+  if (!fusionRun && config.synthesisStrategy !== BUILT_IN.synthesisStrategy) {
+    parts.push(`--synthesis-strategy ${config.synthesisStrategy}`);
+  }
+  if (config.timeout !== BUILT_IN.timeout) {
+    parts.push(`--timeout ${config.timeout}`);
+  }
+  if (!fusionRun && config.requireMinVariants !== BUILT_IN.requireMinVariants) {
+    parts.push(`--require-min-variants ${config.requireMinVariants}`);
+  }
+  parts.push(...buildReplayExtraFlags(options, fusionRun, keepVariantOpts));
+  return parts.join(" \\\n    ");
+}
+function formatTimeoutSourceLabel(minutes, source) {
+  return `${minutes}m [${source}]`;
+}
+function resolveProviderIdlePlanLine(ceilingMinutes, options) {
+  const overrides = options.idleWarnMinutes !== void 0 && options.idleKillMinutes !== void 0 ? {
+    idleWarnMs: options.idleWarnMinutes * 6e4,
+    idleKillMs: options.idleKillMinutes * 6e4
+  } : void 0;
+  const idlePlan = resolveIdleTimeoutPlan("opencode", [], ceilingMinutes * 6e4, overrides);
+  return idlePlan ? `    idle policy: ${formatIdleTimeoutPlan(idlePlan)}` : null;
+}
+function formatResolvedPlan(task, config, executorTimeoutMinutes, options = {}) {
+  const lines = ["Resolved execution plan:"];
+  const matrixEscalation = config.matrixEscalation ?? DEFAULT_MATRIX_ESCALATION_THRESHOLDS;
+  const matrixEscalationSource = config.sources.matrixEscalation ?? "built-in";
+  lines.push(`  resolverVersion: ${config.resolverVersion}  schemaHash: ${config.schemaHash}`);
+  lines.push(`  task:            ${JSON.stringify(task)}`);
+  lines.push(
+    `  variants:        ${config.variants.map((v) => `${v} [${config.sources.variants}]`).join(", ")}`
+  );
+  if (options.fusionRun === true) {
+    lines.push("  synthesis:       fusion peer synthesis");
+  } else if (config.judge === "off" && config.variants.length > 1) {
+    lines.push(`  judge:           off [${config.sources.judge}]`);
+    lines.push("  apply:           none [judge:off]");
+  } else {
+    const judgeRun = config.judge === "off" ? null : normalizeJudgeRunForDisplay(options.aiJudgeRun ?? config.judgeRun);
+    const primaryJudge = judgeRun ? options.aiJudgePrimary ?? config.judgePrimary ?? "ai" : config.judge;
+    const sourceLabel = judgeRun ? `${config.sources.judge}, primary` : config.sources.judge;
+    lines.push(`  judge:           ${primaryJudge} [${sourceLabel}]`);
+    if (judgeRun) {
+      lines.push(`  judgeRun:        ${judgeRun}`);
+    }
+    if (options.judgeRoleModels) {
+      lines.push(`  judge models:    ${options.judgeRoleModels}`);
+    }
+  }
+  lines.push(
+    `  matrixEscalation: close<=${matrixEscalation.closeCallMargin}, borderline<=${matrixEscalation.borderlineMargin}, confidence<${matrixEscalation.confidenceThreshold} [${matrixEscalationSource}]`
+  );
+  if (config.variants.length === 1) {
+    lines.push("  mode:            single-run");
+  } else {
+    lines.push(`  completionMode:  ${config.completionMode} [${config.sources.completionMode}]`);
+  }
+  if (options.editsExpected === false) {
+    lines.push("  synthesis:       n/a (no-edit mode)");
+  } else {
+    lines.push(
+      `  synthesisStrategy: ${config.synthesisStrategy} [${config.sources.synthesisStrategy}]`
+    );
+  }
+  lines.push("  time budget:");
+  if (executorTimeoutMinutes !== void 0) {
+    const canAutoRaiseOverallTimeout = config.sources.timeout === "built-in";
+    const effectiveOrchestratorMin = canAutoRaiseOverallTimeout ? Math.max(config.timeout, executorTimeoutMinutes) : config.timeout;
+    const orchLabel = effectiveOrchestratorMin !== config.timeout ? `${effectiveOrchestratorMin}m (raised from ${config.timeout}m so the run ceiling covers the per-variant ceiling) [${config.sources.timeout}]` : formatTimeoutSourceLabel(effectiveOrchestratorMin, config.sources.timeout);
+    lines.push(`    overall ceiling: ${orchLabel}`);
+    lines.push(`    per-variant ceiling: ${executorTimeoutMinutes}m`);
+    const idlePlanLine = resolveProviderIdlePlanLine(executorTimeoutMinutes, options);
+    if (idlePlanLine) {
+      lines.push(idlePlanLine);
+    }
+  } else {
+    lines.push(
+      `    overall ceiling: ${formatTimeoutSourceLabel(config.timeout, config.sources.timeout)}`
+    );
+    const idlePlanLine = resolveProviderIdlePlanLine(config.timeout, options);
+    if (idlePlanLine) {
+      lines.push(idlePlanLine);
+    }
+  }
+  lines.push(
+    "    estimates: advisory only; timed-out partials require verification before delivery"
+  );
+  lines.push("");
+  lines.push("Replay:");
+  lines.push(`  ${options.replayCommand ?? buildReplayFlags(task, config, options)}`);
+  return lines.join("\n");
+}
+
+export {
+  normalizeJudgeRunToken,
+  normalizeJudgeRunList,
+  buildReplayExtraArgv,
+  readJudgeTypeEnv,
+  _resetJudgeWarningGuard,
+  discoverAvailableProviders,
+  deriveDefaultVariants,
+  resolveAvailableProviderOrder,
+  computeSchemaHash,
+  resolveMatrixEscalationThresholds,
+  resolveCompeteConfig,
+  buildReplayFlags,
+  formatResolvedPlan
+};
+//# sourceMappingURL=chunk-EN62WLFD.js.map