@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-4XICK3HN.js

@@ -0,0 +1,784 @@
+import {
+  DEFAULT_MATRIX_ESCALATION_THRESHOLDS,
+  normalizeMatrixEscalationThresholds,
+  readMatrixEscalationThresholdPatchFromEnv
+} from "./chunk-AX6GWE7V.js";
+import {
+  resolveDefaultProvider,
+  resolveJudgeType
+} from "./chunk-IZZK3H6I.js";
+import {
+  formatIdleTimeoutPlan,
+  resolveIdleTimeoutPlan
+} from "./chunk-E3NTPHEO.js";
+import {
+  consumePoeticConfigRead,
+  readCanonicalPoeticConfig,
+  selectedPoeticConfigCandidate
+} from "./chunk-G36W2T2S.js";
+import {
+  ProviderRegistry
+} from "./chunk-AT4TNPWW.js";
+import {
+  getConfigPaths
+} from "./chunk-L6OM4A22.js";
+
+// src/core/config/compete-config-resolver.ts
+import { execFileSync } from "child_process";
+import { createHash } from "crypto";
+import { platform } from "os";
+import { resolve } from "path";
+var RESOLVER_VERSION = 2;
+var _ENV_JUDGE_NEW = "POETIC_JUDGE_TYPE";
+var _ENV_JUDGE_LEGACY = "POETIC_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: POETIC_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 classifyJudgeFieldValue(value, cwd) {
+  if (value === "off") {
+    return { kind: "off" };
+  }
+  if (value.startsWith("experimental:")) {
+    return { kind: "experimental", value };
+  }
+  if (value === "ai" || value === "multi-lens" || value === "multi-agent") {
+    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
+};
+var binaryCheckCache = /* @__PURE__ */ new Map();
+var BINARY_CACHE_TTL_MS = 5 * 60 * 1e3;
+function isBinaryAvailable(binary) {
+  const now = Date.now();
+  const cached = binaryCheckCache.get(binary);
+  if (cached && now < cached.expiresAt) {
+    return cached.available;
+  }
+  let available = false;
+  try {
+    if (platform() === "win32") {
+      execFileSync("where", [binary], { stdio: "ignore" });
+    } else {
+      execFileSync("which", [binary], { stdio: "ignore" });
+    }
+    available = true;
+  } catch {
+    available = false;
+  }
+  binaryCheckCache.set(binary, { available, expiresAt: now + BINARY_CACHE_TTL_MS });
+  return available;
+}
+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}`
+    );
+  }
+  const results = await Promise.all(
+    providers.map(async (provider) => {
+      const auth = provider.auth;
+      if (!auth) return null;
+      const skipEnvVar = auth.skip_env_var;
+      if (skipEnvVar && process.env[skipEnvVar]) {
+        return {
+          providerId: provider.id,
+          available: true,
+          authMethod: "skip_env",
+          discoverySource: "skip_env"
+        };
+      }
+      const envVars = auth.env_vars ?? [];
+      const hasEnvVar = envVars.some((v) => !!process.env[v]);
+      if (hasEnvVar) {
+        return {
+          providerId: provider.id,
+          available: true,
+          authMethod: "env_var",
+          discoverySource: "env_var"
+        };
+      }
+      const binary = provider.cli?.binary;
+      if (!binary || !isBinaryAvailable(binary)) {
+        return {
+          providerId: provider.id,
+          available: false,
+          authMethod: "cli_check",
+          discoverySource: "cli_check"
+        };
+      }
+      return {
+        providerId: provider.id,
+        available: true,
+        authMethod: "cli_check",
+        discoverySource: "cli_check"
+      };
+    })
+  );
+  return results.filter((result) => result !== null);
+}
+function deriveDefaultVariants(discoveryResults, preferredProviderId, providerOrder = []) {
+  const available = discoveryResults.filter((r) => r.available);
+  if (available.length === 0) return [];
+  const sorted = [...available];
+  const orderedProviders = [
+    ...preferredProviderId ? [preferredProviderId] : [],
+    ...providerOrder.filter((provider) => provider !== preferredProviderId)
+  ];
+  if (orderedProviders.length > 0) {
+    sorted.sort((a, b) => {
+      const aIndex = orderedProviders.indexOf(a.providerId);
+      const bIndex = orderedProviders.indexOf(b.providerId);
+      if (aIndex === -1 && bIndex === -1) return 0;
+      if (aIndex === -1) return 1;
+      if (bIndex === -1) return -1;
+      return aIndex - bIndex;
+    });
+  } else if (preferredProviderId) {
+    const idx = sorted.findIndex((r) => r.providerId === preferredProviderId);
+    if (idx > 0) {
+      const spliced = sorted.splice(idx, 1);
+      const preferred = spliced[0];
+      if (preferred) sorted.unshift(preferred);
+    }
+  }
+  if (sorted.length >= 2) {
+    const first2 = sorted[0];
+    const second = sorted[1];
+    return [`${first2.providerId}:conservative`, `${second.providerId}:innovative`];
+  }
+  const first = sorted[0];
+  return [`${first.providerId}:conservative`];
+}
+function loadCompeteConfigLayer(baseCandidates) {
+  for (const baseCandidate of baseCandidates) {
+    const selected = selectedPoeticConfigCandidate(baseCandidate);
+    const read = readCanonicalPoeticConfig(selected);
+    if (read.status === "missing") continue;
+    const config = consumePoeticConfigRead(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, ".poetic", "config", "poetic.config.jsonc"),
+    // Explicit legacy project-root location. It is consulted only when the
+    // canonical .poetic/config layer is absent, never when that layer is invalid.
+    resolve(projectRoot, "poetic.config.jsonc")
+  ]);
+}
+function normalizeJudgeRunToken(value) {
+  if (!value) return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "ai") return "ai";
+  if (normalized === "multi-lens" || normalized === "hybrid") return "multi-lens";
+  if (normalized === "multi-agent" || normalized === "agentic") return "multi-agent";
+  return null;
+}
+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 readEnvLayer() {
+  const result = {};
+  const completionModeRaw = process.env.POETIC_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, `POETIC_JUDGE_RUN=${v} POETIC_JUDGE_PRIMARY=${v}`);
+      }
+    }
+  }
+  const judgeOff = result.judge === "off";
+  const judgeRunRaw = process.env.POETIC_JUDGE_RUN ?? process.env.POETIC_AI_JUDGE_RUN;
+  const judgeRun = normalizeJudgeRunList(judgeRunRaw);
+  if (judgeRun && !judgeOff) {
+    result.judge = "ai";
+    result.judgeRun = judgeRun;
+  } else if (judgeRun && judgeOff) {
+    console.warn(`Warning: POETIC_JUDGE_RUN=${judgeRunRaw} ignored because POETIC_JUDGE_TYPE=off.`);
+  }
+  const judgePrimaryRaw = process.env.POETIC_JUDGE_PRIMARY ?? process.env.POETIC_AI_JUDGE_PRIMARY;
+  const judgePrimary = normalizeJudgeRunToken(judgePrimaryRaw);
+  if (judgePrimary && !judgeOff) {
+    result.judge = "ai";
+    result.judgePrimary = judgePrimary;
+  } else if (judgePrimary && judgeOff) {
+    console.warn(
+      `Warning: POETIC_JUDGE_PRIMARY=${judgePrimaryRaw} ignored because POETIC_JUDGE_TYPE=off.`
+    );
+  }
+  const synthesisStrategyRaw = process.env.POETIC_SYNTHESIS_STRATEGY;
+  const normalizedSynthesisStrategy = synthesisStrategyRaw?.trim();
+  const hasExplicitSynthesisStrategy = Boolean(
+    normalizedSynthesisStrategy && isValidSynthesisStrategy(normalizedSynthesisStrategy)
+  );
+  if (hasExplicitSynthesisStrategy && normalizedSynthesisStrategy) {
+    result.synthesisStrategy = normalizedSynthesisStrategy;
+  }
+  const aiFirstRaw = process.env.POETIC_SYNTHESIS_AI_FIRST;
+  if (aiFirstRaw?.trim()) {
+    const normalized = aiFirstRaw.trim().toLowerCase();
+    if (normalized === "1" || normalized === "true") {
+      if (hasExplicitSynthesisStrategy) {
+        console.warn(
+          "Warning: POETIC_SYNTHESIS_AI_FIRST ignored because POETIC_SYNTHESIS_STRATEGY is set."
+        );
+      } else {
+        result.synthesisStrategy = "agentic-synthesis";
+      }
+    }
+  }
+  const timeoutMsRaw = process.env.POETIC_TIMEOUT_MS;
+  if (timeoutMsRaw?.trim()) {
+    const ms = parseInt(timeoutMsRaw.trim(), 10);
+    if (!Number.isNaN(ms) && ms > 0) {
+      result.timeout = Math.ceil(ms / 6e4);
+    }
+  }
+  const matrixEscalationPatch = readMatrixEscalationThresholdPatchFromEnv();
+  if (Object.keys(matrixEscalationPatch).length > 0) {
+    result.matrixEscalationPatch = matrixEscalationPatch;
+  }
+  const preferredProviderRaw = process.env.POETIC_DEFAULT_PROVIDER;
+  if (preferredProviderRaw?.trim()) {
+    result.preferredProvider = preferredProviderRaw.trim();
+    result.preferredProviderSource = "env";
+  }
+  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);
+}
+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 resolvedProviderOrder = [];
+  let resolvedCompletionMode = BUILT_IN.completionMode;
+  let resolvedSynthesisStrategy = BUILT_IN.synthesisStrategy;
+  let resolvedTimeout = BUILT_IN.timeout;
+  let resolvedRequireMinVariants = BUILT_IN.requireMinVariants;
+  let resolvedMatrixEscalation = BUILT_IN.matrixEscalation;
+  let resolvedVariants = null;
+  let sourceJudge = "built-in";
+  let sourceJudgeRun = "built-in";
+  let sourceJudgePrimary = "built-in";
+  let sourceProviderOrder;
+  let sourceCompletionMode = "built-in";
+  let sourceSynthesisStrategy = "built-in";
+  let sourceTimeout = "built-in";
+  let sourceRequireMinVariants = "built-in";
+  let sourceMatrixEscalation = "built-in";
+  let sourceVariants = "built-in";
+  const userLayer = loadUserCompeteConfigLayer(projectRoot);
+  const userConfig = userLayer?.compete ?? null;
+  const userMatrixEscalationConfig = userLayer?.matrix ?? null;
+  if (userConfig) {
+    if (userConfig.variants && Array.isArray(userConfig.variants) && userConfig.variants.length > 0) {
+      resolvedVariants = userConfig.variants;
+      sourceVariants = "user";
+    }
+    if (Array.isArray(userConfig.providerOrder) && userConfig.providerOrder.length > 0) {
+      resolvedProviderOrder = userConfig.providerOrder.filter(
+        (provider) => typeof provider === "string" && provider.trim().length > 0
+      );
+      if (resolvedProviderOrder.length > 0) sourceProviderOrder = "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 userJudgeRun = normalizeJudgeRunList(userConfig.judgeRun);
+    if (userJudgeRun) {
+      resolvedJudge = "ai";
+      resolvedJudgeRun = userJudgeRun;
+      sourceJudge = "user";
+      sourceJudgeRun = "user";
+    }
+    const userJudgePrimary = normalizeJudgeRunToken(userConfig.judgePrimary);
+    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 userMatrixPatch = userConfig?.matrixEscalation ?? userMatrixEscalationConfig?.matrixEscalation;
+  if (userMatrixPatch) {
+    resolvedMatrixEscalation = normalizeMatrixEscalationThresholds(userMatrixPatch);
+    sourceMatrixEscalation = "user";
+  }
+  const repoLayer = loadRepoCompeteConfigLayer(projectRoot);
+  const repoConfig = repoLayer?.compete ?? null;
+  const repoMatrixEscalationConfig = repoLayer?.matrix ?? null;
+  if (repoConfig) {
+    if (repoConfig.variants && Array.isArray(repoConfig.variants) && repoConfig.variants.length > 0) {
+      resolvedVariants = repoConfig.variants;
+      sourceVariants = "repo";
+    }
+    if (Array.isArray(repoConfig.providerOrder) && repoConfig.providerOrder.length > 0) {
+      resolvedProviderOrder = repoConfig.providerOrder.filter(
+        (provider) => typeof provider === "string" && provider.trim().length > 0
+      );
+      if (resolvedProviderOrder.length > 0) sourceProviderOrder = "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 repoJudgeRun = normalizeJudgeRunList(repoConfig.judgeRun);
+    if (repoJudgeRun) {
+      resolvedJudge = "ai";
+      resolvedJudgeRun = repoJudgeRun;
+      sourceJudge = "repo";
+      sourceJudgeRun = "repo";
+    }
+    const repoJudgePrimary = normalizeJudgeRunToken(repoConfig.judgePrimary);
+    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 repoMatrixPatch = repoConfig?.matrixEscalation ?? repoMatrixEscalationConfig?.matrixEscalation;
+  if (repoMatrixPatch) {
+    resolvedMatrixEscalation = normalizeMatrixEscalationThresholds(repoMatrixPatch);
+    sourceMatrixEscalation = "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";
+  }
+  if (envLayer.matrixEscalationPatch !== void 0) {
+    resolvedMatrixEscalation = normalizeMatrixEscalationThresholds(
+      envLayer.matrixEscalationPatch,
+      resolvedMatrixEscalation
+    );
+    sourceMatrixEscalation = "env";
+  }
+  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 allDiscovered = await discoverAvailableProviders();
+    let preferredProvider = envLayer.preferredProvider;
+    let preferredProviderSource = envLayer.preferredProviderSource;
+    if (!preferredProvider) {
+      const defaultProvider = resolveDefaultProvider(void 0, projectRoot);
+      if (defaultProvider.source !== "registry") {
+        preferredProvider = defaultProvider.value;
+        if (defaultProvider.source === "project") preferredProviderSource = "repo";
+        else if (defaultProvider.source === "user-config") preferredProviderSource = "user";
+        else if (defaultProvider.source === "env") preferredProviderSource = "env";
+      }
+    }
+    const defaults = deriveDefaultVariants(allDiscovered, preferredProvider, resolvedProviderOrder);
+    if (defaults.length === 0) {
+      throw new Error(
+        'No available providers found. Run "poetic config resolved" to check provider setup.\nInstall at least one provider CLI, then retry.'
+      );
+    }
+    resolvedVariants = defaults;
+    sourceVariants = sourceProviderOrder ?? preferredProviderSource ?? "built-in";
+    if (resolvedVariants.length === 1) {
+      console.warn(
+        "Competition degraded: only 1 provider found. Install another provider for multi-agent comparison."
+      );
+    }
+  }
+  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 parts = [
+    `${options.fusionRun === true ? "poetic fusion" : "poetic compete"} ${JSON.stringify(task)}`
+  ];
+  for (const variant of config.variants) {
+    parts.push(`--variant ${variant}`);
+  }
+  if (config.variantOpts && config.variantOpts.length > 0) {
+    for (const opt of config.variantOpts) {
+      parts.push(`--variant-opt ${opt}`);
+    }
+  }
+  if (options.fusionRun !== true && config.judge !== BUILT_IN.judge) {
+    parts.push(`--judge ${config.judge}`);
+  }
+  const judgeRun = options.fusionRun === true || config.judge === "off" ? null : normalizeJudgeRunForDisplay(options.aiJudgeRun ?? config.judgeRun);
+  const judgePrimary = options.fusionRun === true || config.judge === "off" ? void 0 : options.aiJudgePrimary ?? config.judgePrimary;
+  if (judgeRun) {
+    parts.push(`--judge-run ${judgeRun}`);
+  }
+  if (judgePrimary) {
+    parts.push(`--judge-primary ${judgePrimary}`);
+  }
+  if (config.completionMode !== BUILT_IN.completionMode) {
+    parts.push(`--completion-mode ${config.completionMode}`);
+  }
+  if (config.synthesisStrategy !== BUILT_IN.synthesisStrategy) {
+    parts.push(`--synthesis-strategy ${config.synthesisStrategy}`);
+  }
+  if (config.timeout !== BUILT_IN.timeout) {
+    parts.push(`--timeout ${config.timeout}`);
+  }
+  if (config.requireMinVariants !== BUILT_IN.requireMinVariants) {
+    parts.push(`--require-min-variants ${config.requireMinVariants}`);
+  }
+  return parts.join(" \\\n    ");
+}
+function formatTimeoutSourceLabel(minutes, source) {
+  return `${minutes}m [${source}]`;
+}
+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;
+}
+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}`);
+    }
+  }
+  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(`  ${buildReplayFlags(task, config, options)}`);
+  return lines.join("\n");
+}
+
+export {
+  readJudgeTypeEnv,
+  _resetJudgeWarningGuard,
+  discoverAvailableProviders,
+  computeSchemaHash,
+  resolveCompeteConfig,
+  buildReplayFlags,
+  formatResolvedPlan
+};
+//# sourceMappingURL=chunk-4XICK3HN.js.map