@poetic-ai/poetic 1.42.0

package/dist/chunk-XPU2XADL.js

@@ -0,0 +1,2175 @@
+import {
+  assertProviderReady
+} from "./chunk-AURFMVCD.js";
+import {
+  getActiveProfilePath,
+  loadActiveProfileStrict,
+  normalizeLegacyIntoCanonical,
+  profileToPoeticConfig,
+  readProviderModelFromEnv
+} from "./chunk-SZ7DL357.js";
+import {
+  PoeticConfigReadError,
+  poeticConfigCandidates,
+  readCanonicalPoeticConfig,
+  selectedPoeticConfigCandidate
+} from "./chunk-G36W2T2S.js";
+import {
+  ENABLED_PROVIDER_IDS
+} from "./chunk-2VSQMRCB.js";
+import {
+  InvalidExplicitConfigError,
+  ProviderRegistry,
+  combineCacheFingerprints,
+  fingerprintEnvironment,
+  fingerprintFile,
+  fingerprintFiles
+} from "./chunk-AT4TNPWW.js";
+import {
+  getConfigPaths,
+  resolveProvidersConfigPath
+} from "./chunk-L6OM4A22.js";
+import {
+  getUserConfigDir,
+  getUserPreferencesPath
+} from "./chunk-UUH2RVKS.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/core/config/resolution-engine.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/core/config/judge-coherence.ts
+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 judgeRoleForTier(judgeType) {
+  return judgeType === "multi-lens" ? "quality" : "judge_primary";
+}
+function coherentJudgeModelForProvider(provider, judgeType, registryOverride) {
+  const primaryRole = judgeRoleForTier(judgeType);
+  const roleCandidates = primaryRole === "judge_primary" ? ["judge_primary", "quality"] : [primaryRole];
+  try {
+    for (const candidate of roleCandidates) {
+      const roleModel = ProviderRegistry.getModelForRole(provider, candidate, 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)) {
+      owners.push(provider.id);
+    }
+  }
+  return owners.length === 1 ? owners[0] : void 0;
+}
+function reconcileJudgePair(provider, model, judgeType, 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, judgeType, registryOverride);
+  if (coherent) {
+    return { provider: provider.value, model: coherent, changed: "model" };
+  }
+  return { provider: provider.value, model: "auto", changed: "model-cleared" };
+}
+
+// src/core/config/resolution-engine.ts
+var PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+function getConfigPaths2(cwd) {
+  const paths = getConfigPaths(cwd);
+  return {
+    ...paths,
+    projectConfigFile: selectedPoeticConfigCandidate(paths.projectConfigFile),
+    userConfigFile: selectedPoeticConfigCandidate(paths.userConfigFile)
+  };
+}
+var InvalidProviderModelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidProviderModelError";
+  }
+};
+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 colonIdx = trimmed.indexOf(":");
+  if (colonIdx > 0) {
+    const provider = normalizeProviderId(trimmed.slice(0, colonIdx));
+    if (provider.length > 0) {
+      return provider;
+    }
+  }
+  return inferProviderFromRegistryOwnership(trimmed, loadProviderRegistryForCwd(cwd));
+}
+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}`
+    );
+  }
+}
+function resolveJudgeType(cli, cwd = process.cwd()) {
+  const paths = getConfigPaths2(cwd);
+  const allowed = /* @__PURE__ */ new Set(["ai", "multi-lens", "multi-agent"]);
+  const normalizeJudgeType = (value) => {
+    if (!value) return void 0;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "hybrid") return "multi-lens";
+    if (normalized === "agentic") return "multi-agent";
+    return allowed.has(normalized) ? normalized : void 0;
+  };
+  const cliJudgeType = normalizeJudgeType(cli?.judgeType);
+  if (cliJudgeType) {
+    return { value: cliJudgeType, source: "cli", sourcePath: "cli:--judge-type" };
+  }
+  const envType = normalizeJudgeType(process.env.POETIC_JUDGE_TYPE);
+  if (envType) {
+    return {
+      value: envType,
+      source: "env",
+      sourcePath: "env:POETIC_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;
+var activeProfileCache = null;
+function getActiveProfile() {
+  const profilePath = getActiveProfilePath();
+  const fingerprint = combineCacheFingerprints(
+    fingerprintEnvironment(
+      process.env,
+      (name) => ["POETIC_ACTIVE_PROFILE", "POETIC_CONFIG_DIR", "POETIC_PROFILES_DIR"].includes(name)
+    ),
+    fingerprintFiles([getUserPreferencesPath(), ...profilePath ? [profilePath] : []])
+  );
+  if (activeProfileCache === null || activeProfileCache.fingerprint !== fingerprint) {
+    let profile;
+    try {
+      profile = loadActiveProfileStrict();
+    } catch (error) {
+      throw new PoeticConfigReadError(
+        profilePath ?? "active profile",
+        "unreadable",
+        [{ message: error instanceof Error ? error.message : String(error) }],
+        error
+      );
+    }
+    const value = profile ? { ...profile, ...profileToPoeticConfig(profile) } : null;
+    activeProfileCache = { value, fingerprint };
+  }
+  return activeProfileCache.value ?? null;
+}
+function warnIfLegacyConfigExists(cwd = process.cwd()) {
+  if (legacyWarningShown) return;
+  legacyWarningShown = true;
+  const legacyPaths = /* @__PURE__ */ new Set([
+    join(homedir(), ".config", "poetic", "defaults.yaml"),
+    join(cwd, "poetic.json"),
+    join(cwd, ".poetic", "config", "poetic.json")
+  ]);
+  if (process.env.XDG_CONFIG_HOME?.trim()) {
+    legacyPaths.add(join(process.env.XDG_CONFIG_HOME.trim(), "poetic", "defaults.yaml"));
+  }
+  legacyPaths.add(join(getUserConfigDir(), "defaults.yaml"));
+  if (process.env.POETIC_DEFAULTS_PATH?.trim()) {
+    legacyPaths.add(process.env.POETIC_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 poetic.config.jsonc file.`,
+            path: p,
+            operation: "warnIfLegacyConfigExists"
+          }
+        }
+      );
+    }
+  }
+}
+function clearConfigCaches() {
+  unifiedConfigCache.clear();
+  warnedKeys.clear();
+  legacyWarningShown = false;
+  activeProfileCache = null;
+  ProviderRegistry.reload();
+}
+function normalizeLoadedPoeticConfig(configData) {
+  return normalizeLegacyIntoCanonical(configData);
+}
+function loadPoeticConfigFile(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 = readCanonicalPoeticConfig(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 = normalizeLoadedPoeticConfig(
+    result.config
+  );
+  unifiedConfigCache.set(configPath, {
+    value: normalizedConfig,
+    error: null,
+    fingerprint
+  });
+  return normalizedConfig;
+}
+function loadPoeticConfigFromCandidates(configPath) {
+  for (const candidate of poeticConfigCandidates(configPath)) {
+    const config = loadPoeticConfigFile(candidate);
+    if (config) return config;
+  }
+  return null;
+}
+function loadUserConfig(cwd = process.cwd()) {
+  const { userConfigFile } = getConfigPaths2(cwd);
+  return loadPoeticConfigFromCandidates(userConfigFile);
+}
+function loadProjectConfig(cwd = process.cwd()) {
+  const { projectConfigFile } = getConfigPaths2(cwd);
+  return loadPoeticConfigFromCandidates(projectConfigFile);
+}
+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
+  };
+}
+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 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 = `POETIC_${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 = 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
+  };
+}
+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 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 paths = getConfigPaths2(cwd);
+  if (cli?.provider) {
+    return assertDefaultProviderEnabled({ value: cli.provider, source: "cli" }, cwd);
+  }
+  const envProvider = process.env.POETIC_DEFAULT_PROVIDER;
+  if (envProvider) {
+    const normalized = envProvider.toLowerCase().trim();
+    if (PROVIDER_ID_PATTERN.test(normalized)) {
+      return assertDefaultProviderEnabled(
+        {
+          value: normalized,
+          source: "env",
+          sourcePath: "env:POETIC_DEFAULT_PROVIDER"
+        },
+        cwd
+      );
+    }
+    throw new InvalidExplicitConfigError(
+      "Invalid POETIC_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)) {
+      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 projectConfig = loadProjectConfig(cwd);
+  if (projectConfig?.defaults?.provider) {
+    return assertDefaultProviderEnabled(
+      {
+        value: projectConfig.defaults.provider,
+        source: "project",
+        sourcePath: `${paths.projectConfigFile}#defaults.provider`
+      },
+      cwd
+    );
+  }
+  const userConfig = loadUserConfig(cwd);
+  if (userConfig?.defaults?.provider) {
+    return assertDefaultProviderEnabled(
+      {
+        value: userConfig.defaults.provider,
+        source: "user-config",
+        sourcePath: `${paths.userConfigFile}#defaults.provider`
+      },
+      cwd
+    );
+  }
+  warnIfLegacyConfigExists(cwd);
+  const registryPath = resolveProvidersConfigPath({ cwd });
+  const registry = loadProviderRegistryForCwd(cwd);
+  const enabled = Object.values(registry.providers).filter((p) => p.enabled).sort((a, b) => a.order - b.order);
+  const first = enabled[0]?.id;
+  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.`
+  );
+}
+var BUILT_IN_JUDGE_PLAN_PROVIDERS = /* @__PURE__ */ new Set(["claude", "codex"]);
+var JUDGE_DEFAULT_PROVIDER = "claude";
+function resolveDefaultJudgeProvider(cli, cwd = process.cwd()) {
+  const resolved = resolveDefaultProvider(cli, cwd);
+  if (BUILT_IN_JUDGE_PLAN_PROVIDERS.has(resolved.value)) {
+    return resolved;
+  }
+  return {
+    value: JUDGE_DEFAULT_PROVIDER,
+    source: "fallback",
+    sourcePath: "judge-default:built-in-plan"
+  };
+}
+async function resolveReadyDefaultProvider(cli, cwd = process.cwd()) {
+  const provider = resolveDefaultProvider(cli, cwd);
+  const readiness = await assertProviderReady(provider.value);
+  return { provider, readiness };
+}
+function resolveDefaultStrategy(cli, cwd = process.cwd()) {
+  const paths = getConfigPaths2(cwd);
+  if (cli?.strategy) {
+    return { value: cli.strategy, source: "cli" };
+  }
+  const envStrategy = process.env.POETIC_DEFAULT_STRATEGY;
+  if (envStrategy) {
+    return {
+      value: envStrategy.toLowerCase(),
+      source: "env",
+      sourcePath: "env:POETIC_DEFAULT_STRATEGY"
+    };
+  }
+  const activeProfile = getActiveProfile();
+  if (activeProfile?.defaults?.strategy) {
+    return {
+      value: activeProfile.defaults.strategy.toLowerCase(),
+      source: "profile",
+      sourcePath: `profile:${activeProfile.name}#defaults.strategy`
+    };
+  }
+  const projectConfig = loadProjectConfig(cwd);
+  if (projectConfig?.defaults?.strategy) {
+    return {
+      value: projectConfig.defaults.strategy,
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#defaults.strategy`
+    };
+  }
+  const userConfig = loadUserConfig(cwd);
+  if (userConfig?.defaults?.strategy) {
+    return {
+      value: userConfig.defaults.strategy,
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#defaults.strategy`
+    };
+  }
+  warnIfLegacyConfigExists(cwd);
+  return { value: "conservative", source: "fallback" };
+}
+function resolveProviderModel(provider, cli, cwd = process.cwd()) {
+  const paths = getConfigPaths2(cwd);
+  const configuredModel = (value, source, sourcePath) => {
+    validateModelForProvider(provider, value, sourcePath, cwd);
+    return { value, source, sourcePath };
+  };
+  let defaultProviderCache;
+  const ownsUnscopedModel = () => {
+    if (defaultProviderCache === void 0) {
+      defaultProviderCache = resolveDefaultProvider(cli, cwd).value;
+    }
+    return defaultProviderCache === provider;
+  };
+  if (cli?.model) {
+    if (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) {
+    return configuredModel(
+      profileProviderModel,
+      "profile",
+      `profile:${activeProfile.name}#defaults.providers.${provider}.model`
+    );
+  }
+  if (activeProfile?.defaults?.model && ownsUnscopedModel()) {
+    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()) {
+    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()) {
+    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) {
+    emitWarning(
+      "CFG-008",
+      {
+        taskId: "resolution-engine",
+        subsystem: "config",
+        executionPhase: "setup"
+      },
+      {
+        severity: "WARN" /* WARN */,
+        metadata: {
+          provider,
+          error: error instanceof Error ? error.message : String(error),
+          operation: "resolveProviderModel"
+        }
+      }
+    );
+    return { value: "auto", source: "fallback" };
+  }
+}
+var JUDGE_TYPE_TO_CONFIG_KEY = {
+  ai: "ai",
+  "multi-lens": "multiLens",
+  "multi-agent": "multiAgent"
+};
+function judgeTierConfigOf(config, judgeType) {
+  if (!config?.judge || !judgeType) return void 0;
+  return config.judge[JUDGE_TYPE_TO_CONFIG_KEY[judgeType]];
+}
+function resolveJudgeProvider(cli, cwd = process.cwd(), judgeType) {
+  const paths = getConfigPaths2(cwd);
+  if (cli?.judgeProvider) {
+    return { value: cli.judgeProvider, source: "cli", specificity: JUDGE_SPECIFICITY.cli };
+  }
+  const envProvider = process.env.POETIC_JUDGE_PROVIDER;
+  if (envProvider) {
+    return {
+      value: envProvider.toLowerCase(),
+      source: "env",
+      sourcePath: "env:POETIC_JUDGE_PROVIDER",
+      specificity: JUDGE_SPECIFICITY.env
+    };
+  }
+  const activeProfile = getActiveProfile();
+  const projectConfig = loadProjectConfig(cwd);
+  const userConfig = loadUserConfig(cwd);
+  const tierLabel = judgeType ? JUDGE_TYPE_TO_CONFIG_KEY[judgeType] : void 0;
+  const profileTierProvider = judgeTierConfigOf(
+    activeProfile,
+    judgeType
+  )?.provider;
+  if (activeProfile && profileTierProvider) {
+    return {
+      value: normalizeProviderId(profileTierProvider),
+      source: "profile",
+      sourcePath: `profile:${activeProfile.name}#judge.${tierLabel}.provider`,
+      specificity: JUDGE_SPECIFICITY.perJudge
+    };
+  }
+  if (activeProfile?.judge?.provider) {
+    return {
+      value: normalizeProviderId(activeProfile.judge.provider),
+      source: "profile",
+      sourcePath: `profile:${activeProfile.name}#judge.provider`,
+      specificity: JUDGE_SPECIFICITY.allJudge
+    };
+  }
+  const projectTierProvider = judgeTierConfigOf(projectConfig, judgeType)?.provider;
+  if (projectTierProvider) {
+    return {
+      value: normalizeProviderId(projectTierProvider),
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#judge.${tierLabel}.provider`,
+      specificity: JUDGE_SPECIFICITY.perJudge
+    };
+  }
+  const userTierProvider = judgeTierConfigOf(userConfig, judgeType)?.provider;
+  if (userTierProvider) {
+    return {
+      value: normalizeProviderId(userTierProvider),
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#judge.${tierLabel}.provider`,
+      specificity: JUDGE_SPECIFICITY.perJudge
+    };
+  }
+  if (projectConfig?.judge?.provider) {
+    return {
+      value: normalizeProviderId(projectConfig.judge.provider),
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#judge.provider`,
+      specificity: JUDGE_SPECIFICITY.allJudge
+    };
+  }
+  if (userConfig?.judge?.provider) {
+    return {
+      value: normalizeProviderId(userConfig.judge.provider),
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#judge.provider`,
+      specificity: JUDGE_SPECIFICITY.allJudge
+    };
+  }
+  if (activeProfile?.defaults?.judge?.provider) {
+    return {
+      value: normalizeProviderId(activeProfile.defaults.judge.provider),
+      source: "profile",
+      sourcePath: `profile:${activeProfile.name}#defaults.judge.provider`,
+      specificity: JUDGE_SPECIFICITY.legacyDefaults
+    };
+  }
+  if (projectConfig?.defaults?.judge?.provider) {
+    return {
+      value: normalizeProviderId(projectConfig.defaults.judge.provider),
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#defaults.judge.provider`,
+      specificity: JUDGE_SPECIFICITY.legacyDefaults
+    };
+  }
+  if (userConfig?.defaults?.judge?.provider) {
+    return {
+      value: normalizeProviderId(userConfig.defaults.judge.provider),
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#defaults.judge.provider`,
+      specificity: JUDGE_SPECIFICITY.legacyDefaults
+    };
+  }
+  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",
+    specificity: JUDGE_SPECIFICITY.derived
+  };
+}
+function resolveJudgeModel(cli, cwd = process.cwd(), judgeType) {
+  const paths = getConfigPaths2(cwd);
+  if (cli?.judgeModel) {
+    return {
+      value: cli.judgeModel,
+      source: "cli",
+      sourcePath: "cli:--judge-model",
+      specificity: JUDGE_SPECIFICITY.cli
+    };
+  }
+  const envJudgeModel = process.env.POETIC_JUDGE_MODEL;
+  if (envJudgeModel) {
+    return {
+      value: envJudgeModel,
+      source: "env",
+      sourcePath: "env:POETIC_JUDGE_MODEL",
+      specificity: JUDGE_SPECIFICITY.env
+    };
+  }
+  const activeProfile = getActiveProfile();
+  const projectConfig = loadProjectConfig(cwd);
+  const userConfig = loadUserConfig(cwd);
+  const tierLabel = judgeType ? JUDGE_TYPE_TO_CONFIG_KEY[judgeType] : void 0;
+  const profileTierModel = judgeTierConfigOf(
+    activeProfile,
+    judgeType
+  )?.model;
+  if (activeProfile && profileTierModel) {
+    return {
+      value: profileTierModel,
+      source: "profile",
+      sourcePath: `profile:${activeProfile.name}#judge.${tierLabel}.model`,
+      specificity: JUDGE_SPECIFICITY.perJudge
+    };
+  }
+  if (activeProfile?.judge?.model) {
+    return {
+      value: activeProfile.judge.model,
+      source: "profile",
+      sourcePath: `profile:${activeProfile.name}#judge.model`,
+      specificity: JUDGE_SPECIFICITY.allJudge
+    };
+  }
+  const projectTierModel = judgeTierConfigOf(projectConfig, judgeType)?.model;
+  if (projectTierModel) {
+    return {
+      value: projectTierModel,
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#judge.${tierLabel}.model`,
+      specificity: JUDGE_SPECIFICITY.perJudge
+    };
+  }
+  const userTierModel = judgeTierConfigOf(userConfig, judgeType)?.model;
+  if (userTierModel) {
+    return {
+      value: userTierModel,
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#judge.${tierLabel}.model`,
+      specificity: JUDGE_SPECIFICITY.perJudge
+    };
+  }
+  if (projectConfig?.judge?.model) {
+    return {
+      value: projectConfig.judge.model,
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#judge.model`,
+      specificity: JUDGE_SPECIFICITY.allJudge
+    };
+  }
+  if (userConfig?.judge?.model) {
+    return {
+      value: userConfig.judge.model,
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#judge.model`,
+      specificity: JUDGE_SPECIFICITY.allJudge
+    };
+  }
+  if (activeProfile?.defaults?.judge?.model) {
+    return {
+      value: activeProfile.defaults.judge.model,
+      source: "profile",
+      sourcePath: `profile:${activeProfile.name}#defaults.judge.model`,
+      specificity: JUDGE_SPECIFICITY.legacyDefaults
+    };
+  }
+  if (projectConfig?.defaults?.judge?.model) {
+    return {
+      value: projectConfig.defaults.judge.model,
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#defaults.judge.model`,
+      specificity: JUDGE_SPECIFICITY.legacyDefaults
+    };
+  }
+  if (userConfig?.defaults?.judge?.model) {
+    return {
+      value: userConfig.defaults.judge.model,
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#defaults.judge.model`,
+      specificity: JUDGE_SPECIFICITY.legacyDefaults
+    };
+  }
+  warnIfLegacyConfigExists(cwd);
+  const judgeProvider = resolveJudgeProvider(cli, cwd, judgeType);
+  const roleModel = coherentJudgeModelForProvider(judgeProvider.value, judgeType);
+  if (roleModel) {
+    return {
+      value: roleModel,
+      source: "registry",
+      sourcePath: `providers.yaml#providers.${judgeProvider.value}.models (judge role)`,
+      specificity: JUDGE_SPECIFICITY.derived
+    };
+  }
+  return { value: "auto", source: "fallback", specificity: JUDGE_SPECIFICITY.derived };
+}
+function resolveSynthesisModel(cli, cwd = process.cwd()) {
+  const paths = getConfigPaths2(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.POETIC_SYNTHESIS_MODEL;
+  if (envSynthesisModel) {
+    return configuredModel(envSynthesisModel, "env", "env:POETIC_SYNTHESIS_MODEL");
+  }
+  const activeProfile = getActiveProfile();
+  if (activeProfile?.defaults?.synthesis?.model) {
+    return configuredModel(
+      activeProfile.defaults.synthesis.model,
+      "profile",
+      `profile:${activeProfile.name}#defaults.synthesis.model`
+    );
+  }
+  const profileProviderModelSynth = activeProfile?.defaults?.providers?.[provider]?.model;
+  if (activeProfile && profileProviderModelSynth) {
+    return configuredModel(
+      profileProviderModelSynth,
+      "profile",
+      `profile:${activeProfile.name}#defaults.providers.${provider}.model`
+    );
+  }
+  if (activeProfile?.defaults?.model) {
+    return configuredModel(
+      activeProfile.defaults.model,
+      "profile",
+      `profile:${activeProfile.name}#defaults.model`
+    );
+  }
+  const projectConfig = loadProjectConfig(cwd);
+  if (projectConfig?.defaults?.synthesis?.model) {
+    return configuredModel(
+      projectConfig.defaults.synthesis.model,
+      "project",
+      `${paths.projectConfigFile}#defaults.synthesis.model`
+    );
+  }
+  const projectProviderModel = projectConfig?.defaults?.providers?.[provider]?.model;
+  if (projectProviderModel) {
+    return configuredModel(
+      projectProviderModel,
+      "project",
+      `${paths.projectConfigFile}#defaults.providers.${provider}.model`
+    );
+  }
+  if (projectConfig?.defaults?.model) {
+    return configuredModel(
+      projectConfig.defaults.model,
+      "project",
+      `${paths.projectConfigFile}#defaults.model`
+    );
+  }
+  const userConfig = loadUserConfig(cwd);
+  if (userConfig?.defaults?.synthesis?.model) {
+    return configuredModel(
+      userConfig.defaults.synthesis.model,
+      "user-config",
+      `${paths.userConfigFile}#defaults.synthesis.model`
+    );
+  }
+  const userProviderModel = userConfig?.defaults?.providers?.[provider]?.model;
+  if (userProviderModel) {
+    return configuredModel(
+      userProviderModel,
+      "user-config",
+      `${paths.userConfigFile}#defaults.providers.${provider}.model`
+    );
+  }
+  if (userConfig?.defaults?.model) {
+    return configuredModel(
+      userConfig.defaults.model,
+      "user-config",
+      `${paths.userConfigFile}#defaults.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 resolveSynthesisModelForConfig(cli, cwd, options) {
+  if (options?.strictSynthesisModel !== false) {
+    return resolveSynthesisModel(cli, cwd);
+  }
+  try {
+    return resolveSynthesisModel(cli, cwd);
+  } catch (error) {
+    if (!(error instanceof InvalidProviderModelError)) {
+      throw error;
+    }
+    return {
+      value: "invalid",
+      source: "fallback",
+      sourcePath: `resolution-error:${error.message}`
+    };
+  }
+}
+function resolveSynthesisProvider(cli, cwd = process.cwd()) {
+  const paths = getConfigPaths2(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.POETIC_SYNTHESIS_PROVIDER;
+  if (envProvider) {
+    return {
+      value: normalizeProviderId(envProvider),
+      source: "env",
+      sourcePath: "env:POETIC_SYNTHESIS_PROVIDER"
+    };
+  }
+  const envModelProvider = inferProviderFromModel(process.env.POETIC_SYNTHESIS_MODEL, cwd);
+  if (envModelProvider) {
+    return {
+      value: envModelProvider,
+      source: "env",
+      sourcePath: "env:POETIC_SYNTHESIS_MODEL"
+    };
+  }
+  const activeProfile = getActiveProfile();
+  if (activeProfile?.defaults?.synthesis?.provider) {
+    return {
+      value: normalizeProviderId(activeProfile.defaults.synthesis.provider),
+      source: "profile",
+      sourcePath: `profile:${activeProfile.name}#defaults.synthesis.provider`
+    };
+  }
+  const profileSynthModelProvider = inferProviderFromModel(
+    activeProfile?.defaults?.synthesis?.model,
+    cwd
+  );
+  if (activeProfile && profileSynthModelProvider) {
+    return {
+      value: profileSynthModelProvider,
+      source: "profile",
+      sourcePath: `profile:${activeProfile.name}#defaults.synthesis.model`
+    };
+  }
+  const projectConfig = loadProjectConfig(cwd);
+  if (projectConfig?.defaults?.synthesis?.provider) {
+    return {
+      value: normalizeProviderId(projectConfig.defaults.synthesis.provider),
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#defaults.synthesis.provider`
+    };
+  }
+  const projectSynthesisModelProvider = inferProviderFromModel(
+    projectConfig?.defaults?.synthesis?.model,
+    cwd
+  );
+  if (projectSynthesisModelProvider) {
+    return {
+      value: projectSynthesisModelProvider,
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#defaults.synthesis.model`
+    };
+  }
+  const projectDefaultModelProvider = inferProviderFromModel(projectConfig?.defaults?.model, cwd);
+  if (projectDefaultModelProvider) {
+    return {
+      value: projectDefaultModelProvider,
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#defaults.model`
+    };
+  }
+  const userConfig = loadUserConfig(cwd);
+  if (userConfig?.defaults?.synthesis?.provider) {
+    return {
+      value: normalizeProviderId(userConfig.defaults.synthesis.provider),
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#defaults.synthesis.provider`
+    };
+  }
+  const userSynthesisModelProvider = inferProviderFromModel(
+    userConfig?.defaults?.synthesis?.model,
+    cwd
+  );
+  if (userSynthesisModelProvider) {
+    return {
+      value: userSynthesisModelProvider,
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#defaults.synthesis.model`
+    };
+  }
+  const userDefaultModelProvider = inferProviderFromModel(userConfig?.defaults?.model, cwd);
+  if (userDefaultModelProvider) {
+    return {
+      value: userDefaultModelProvider,
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#defaults.model`
+    };
+  }
+  warnIfLegacyConfigExists(cwd);
+  const defaultProvider = resolveDefaultProvider(cli, cwd);
+  return {
+    value: defaultProvider.value,
+    source: "fallback",
+    sourcePath: "synthesis-provider:default-fallback"
+  };
+}
+function resolveSplitterModel(cli, cwd = process.cwd()) {
+  const paths = getConfigPaths2(cwd);
+  if (cli?.splitterModel) {
+    return {
+      value: cli.splitterModel,
+      source: "cli",
+      sourcePath: "cli:--splitter-model"
+    };
+  }
+  const envSplitterModel = process.env.POETIC_SPLITTER_MODEL;
+  if (envSplitterModel) {
+    return {
+      value: envSplitterModel,
+      source: "env",
+      sourcePath: "env:POETIC_SPLITTER_MODEL"
+    };
+  }
+  const projectConfig = loadProjectConfig(cwd);
+  if (projectConfig?.defaults?.splitter?.model) {
+    return {
+      value: projectConfig.defaults.splitter.model,
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#defaults.splitter.model`
+    };
+  }
+  const userConfig = loadUserConfig(cwd);
+  if (userConfig?.defaults?.splitter?.model) {
+    return {
+      value: userConfig.defaults.splitter.model,
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#defaults.splitter.model`
+    };
+  }
+  warnIfLegacyConfigExists(cwd);
+  try {
+    const providerId = resolveDefaultProvider(cli, cwd).value;
+    const model = ProviderRegistry.getProviderConfig(providerId, loadProviderRegistryForCwd(cwd)).models.default;
+    return {
+      value: model,
+      source: "registry",
+      sourcePath: `providers.yaml#providers.${providerId}.models.default`
+    };
+  } catch {
+    return { value: "auto", source: "fallback" };
+  }
+}
+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) {
+  const type = resolveJudgeType(cli, cwd);
+  const provider = resolveJudgeProvider(cli, cwd, judgeType);
+  const model = resolveJudgeModel(cli, cwd, judgeType);
+  const reconciled = reconcileJudgePair(
+    { value: provider.value, specificity: provider.specificity },
+    model.value ? { value: model.value, specificity: model.specificity } : void 0,
+    judgeType
+  );
+  if (reconciled.changed === "provider") {
+    return {
+      type,
+      provider: {
+        value: reconciled.provider,
+        source: model.source,
+        sourcePath: `${model.sourcePath ?? "judge.model"} (provider inferred from model)`
+      },
+      model
+    };
+  }
+  if (reconciled.changed === "model" || reconciled.changed === "model-cleared") {
+    return {
+      type,
+      provider,
+      model: {
+        value: reconciled.model ?? "auto",
+        source: "registry",
+        sourcePath: `providers.yaml#providers.${provider.value}.models (judge role, reconciled)`
+      }
+    };
+  }
+  return { type, provider, model };
+}
+function resolveConfig(cli, cwd = process.cwd(), options) {
+  const defaultProvider = resolveDefaultProvider(cli, cwd);
+  const registry = loadProviderRegistryForCwd(cwd);
+  const providers = ProviderRegistry.getEnabledProviders(registry).map((provider) => provider.id);
+  const providerModels = {};
+  for (const provider of providers) {
+    providerModels[provider] = resolveProviderModel(provider, cli, cwd);
+  }
+  return {
+    defaultProvider,
+    defaultStrategy: resolveDefaultStrategy(cli, cwd),
+    defaultModel: resolveProviderModel(defaultProvider.value, cli, cwd),
+    decompositionRoutingPolicy: resolveDecompositionRoutingPolicy(cli, cwd),
+    planExecute: resolvePlanExecuteConfig(cli, cwd),
+    providerExecutionTransport: resolveProviderExecutionTransportConfig(cli, cwd),
+    judge: resolveJudgeConfig(cli, cwd),
+    synthesisModel: resolveSynthesisModelForConfig(cli, cwd, options),
+    splitterModel: resolveSplitterModel(cli, cwd),
+    providerModels
+  };
+}
+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 `POETIC_${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.POETIC_PROVIDER_EXECUTION_TRANSPORT;
+  const canonicalRaw = env.POETIC_EXECUTION_TRANSPORT;
+  const legacyValue = normalizeExecutionTransportMode(legacyRaw);
+  const canonicalValue = normalizeExecutionTransportMode(canonicalRaw);
+  if (legacyRaw?.trim() && !legacyValue) {
+    throw new InvalidExplicitConfigError(
+      "Invalid POETIC_PROVIDER_EXECUTION_TRANSPORT: expected auto, headless, tmux-exec, or interactive"
+    );
+  }
+  if (canonicalRaw?.trim() && !canonicalValue) {
+    throw new InvalidExplicitConfigError(
+      "Invalid POETIC_EXECUTION_TRANSPORT: expected auto, headless, tmux-exec, or interactive"
+    );
+  }
+  const genericValue = legacyValue ?? canonicalValue;
+  if (genericValue) {
+    return {
+      value: genericValue,
+      source: "env",
+      sourcePath: env.POETIC_PROVIDER_EXECUTION_TRANSPORT ? "env:POETIC_PROVIDER_EXECUTION_TRANSPORT" : "env:POETIC_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 resolveDecompositionRoutingPolicy(cli, cwd = process.cwd()) {
+  const paths = getConfigPaths2(cwd);
+  if (cli?.routingPolicy) {
+    return {
+      value: cli.routingPolicy,
+      source: "cli",
+      sourcePath: "cli:--routing-policy"
+    };
+  }
+  const envStageValue = process.env.POETIC_DECOMPOSE_ROUTING_POLICY?.trim().toLowerCase();
+  if (envStageValue === "strict" || envStageValue === "reroute") {
+    return {
+      value: envStageValue,
+      source: "env",
+      sourcePath: "env:POETIC_DECOMPOSE_ROUTING_POLICY"
+    };
+  }
+  const envGlobalValue = process.env.POETIC_ROUTING_POLICY?.trim().toLowerCase();
+  if (envGlobalValue === "strict" || envGlobalValue === "reroute") {
+    return {
+      value: envGlobalValue,
+      source: "env",
+      sourcePath: "env:POETIC_ROUTING_POLICY"
+    };
+  }
+  const activeProfile = getActiveProfile();
+  const profileRoutingPolicy = activeProfile?.defaults?.routingPolicy?.trim().toLowerCase();
+  if (activeProfile && (profileRoutingPolicy === "strict" || profileRoutingPolicy === "reroute")) {
+    return {
+      value: profileRoutingPolicy,
+      source: "profile",
+      sourcePath: `profile:${activeProfile.name}#defaults.routingPolicy`
+    };
+  }
+  const projectConfig = loadProjectConfig(cwd);
+  const projectStageValue = projectConfig?.defaults?.intent?.decomposition?.routingPolicy;
+  if (projectStageValue) {
+    return {
+      value: projectStageValue,
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#defaults.intent.decomposition.routingPolicy`
+    };
+  }
+  const projectGlobalValue = projectConfig?.defaults?.routingPolicy;
+  if (projectGlobalValue) {
+    return {
+      value: projectGlobalValue,
+      source: "project",
+      sourcePath: `${paths.projectConfigFile}#defaults.routingPolicy`
+    };
+  }
+  const userConfig = loadUserConfig(cwd);
+  const userStageValue = userConfig?.defaults?.intent?.decomposition?.routingPolicy;
+  if (userStageValue) {
+    return {
+      value: userStageValue,
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#defaults.intent.decomposition.routingPolicy`
+    };
+  }
+  const userGlobalValue = userConfig?.defaults?.routingPolicy;
+  if (userGlobalValue) {
+    return {
+      value: userGlobalValue,
+      source: "user-config",
+      sourcePath: `${paths.userConfigFile}#defaults.routingPolicy`
+    };
+  }
+  return { value: "reroute", source: "fallback" };
+}
+function getPurposeProviderOrder(defaults, purpose) {
+  if (!defaults) return void 0;
+  switch (purpose) {
+    case "judge":
+      return defaults.judge?.providerOrder;
+    case "synthesis":
+      return defaults.synthesis?.providerOrder;
+    case "decomposition":
+      return defaults.intent?.decomposition?.providerOrder;
+    case "global":
+    case "splitter":
+    case "flywheel":
+    case "orchestration":
+      return void 0;
+  }
+}
+function getPurposeSingleModel(defaults, purpose) {
+  if (!defaults) return void 0;
+  switch (purpose) {
+    case "judge":
+      return defaults.judge?.model;
+    case "synthesis":
+      return defaults.synthesis?.model;
+    case "decomposition":
+    case "splitter":
+    case "flywheel":
+    case "orchestration":
+    case "global":
+      return 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) {
+      emitWarning(
+        "CFG-008",
+        {
+          taskId: "resolution-engine",
+          subsystem: "config",
+          executionPhase: "setup"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            provider: rawProvider,
+            source: sourceLabel,
+            operation: "resolveCandidates",
+            message: `Skipping unknown provider '${rawProvider}' from ${sourceLabel}`
+          }
+        }
+      );
+      continue;
+    }
+    if (!providerConfig.enabled) {
+      emitWarning(
+        "CFG-008",
+        {
+          taskId: "resolution-engine",
+          subsystem: "config",
+          executionPhase: "setup"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            provider: providerConfig.id,
+            source: sourceLabel,
+            operation: "resolveCandidates",
+            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 buildValidatedModelList(provider, candidates, sourceLabel, registryOverride) {
+  const valid = [];
+  for (const model of candidates) {
+    try {
+      ProviderRegistry.resolveModel(provider, model, registryOverride);
+      valid.push(model);
+    } catch {
+      emitWarning(
+        "CFG-008",
+        {
+          taskId: "resolution-engine",
+          subsystem: "config",
+          executionPhase: "setup"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            provider,
+            model,
+            source: sourceLabel,
+            operation: "resolveCandidates",
+            message: `Skipping invalid model '${model}' for provider '${provider}' from ${sourceLabel}`
+          }
+        }
+      );
+    }
+  }
+  return valid;
+}
+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) {
+  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();
+  let providerOrder;
+  let providerOrderSource = "registry";
+  let providerOrderSourcePath = "providers.yaml#providers.*.order";
+  if (!providerOrder && candidateActiveProfile) {
+    const profilePurposeOrder = getPurposeProviderOrder(
+      candidateActiveProfile.defaults,
+      purpose
+    );
+    if (profilePurposeOrder && profilePurposeOrder.length > 0) {
+      providerOrder = profilePurposeOrder;
+      providerOrderSource = "profile";
+      const purposeKey = purpose === "decomposition" ? "defaults.intent.decomposition.providerOrder" : `defaults.${purpose}.providerOrder`;
+      providerOrderSourcePath = `profile:${candidateActiveProfile.name}#${purposeKey}`;
+    }
+  }
+  if (!providerOrder && candidateActiveProfile?.defaults?.providerOrder?.length) {
+    providerOrder = candidateActiveProfile.defaults.providerOrder;
+    providerOrderSource = "profile";
+    providerOrderSourcePath = `profile:${candidateActiveProfile.name}#defaults.providerOrder`;
+  }
+  if (!providerOrder) {
+    const projectPurposeOrder = getPurposeProviderOrder(projectConfig?.defaults, purpose);
+    if (projectPurposeOrder && projectPurposeOrder.length > 0) {
+      providerOrder = projectPurposeOrder;
+      providerOrderSource = "project";
+      const purposeKey = purpose === "decomposition" ? "defaults.intent.decomposition.providerOrder" : `defaults.${purpose}.providerOrder`;
+      providerOrderSourcePath = `${paths.projectConfigFile}#${purposeKey}`;
+    }
+  }
+  if (!providerOrder && projectConfig?.defaults?.providerOrder?.length) {
+    providerOrder = projectConfig.defaults.providerOrder;
+    providerOrderSource = "project";
+    providerOrderSourcePath = `${paths.projectConfigFile}#defaults.providerOrder`;
+  }
+  if (!providerOrder) {
+    const userPurposeOrder = getPurposeProviderOrder(userConfig?.defaults, purpose);
+    if (userPurposeOrder && userPurposeOrder.length > 0) {
+      providerOrder = userPurposeOrder;
+      providerOrderSource = "user-config";
+      const purposeKey = purpose === "decomposition" ? "defaults.intent.decomposition.providerOrder" : `defaults.${purpose}.providerOrder`;
+      providerOrderSourcePath = `${paths.userConfigFile}#${purposeKey}`;
+    }
+  }
+  if (!providerOrder && userConfig?.defaults?.providerOrder?.length) {
+    providerOrder = userConfig.defaults.providerOrder;
+    providerOrderSource = "user-config";
+    providerOrderSourcePath = `${paths.userConfigFile}#defaults.providerOrder`;
+  }
+  if (!providerOrder || providerOrder.length === 0) {
+    providerOrder = ProviderRegistry.getEnabledProviders(registry).map((p) => p.id);
+    providerOrderSource = "registry";
+    providerOrderSourcePath = "providers.yaml#providers.*.order";
+  }
+  providerOrder = filterRunnableProviderOrder(
+    providerOrder,
+    `${providerOrderSource}:${providerOrderSourcePath}`,
+    cwd
+  );
+  if (scalarConfigured && preserveFallbackChain) {
+    providerOrder = [
+      scalarProvider.value,
+      ...providerOrder.filter((provider) => provider !== scalarProvider.value)
+    ];
+  }
+  const candidates = [];
+  let index = 0;
+  for (const provider of providerOrder) {
+    const modelCandidates = [];
+    const preferredProviderSelected = scalarConfigured && preserveFallbackChain && provider === scalarProvider.value;
+    const resolvedProviderSource = preferredProviderSelected ? scalarProvider.source : providerOrderSource;
+    const resolvedProviderSourcePath = preferredProviderSelected ? scalarProvider.sourcePath ?? "resolution-engine:preferred-provider" : providerOrderSourcePath;
+    const providerSourceLabel = `${resolvedProviderSource}:${resolvedProviderSourcePath}`;
+    const addModelCandidate = (model, source, sourcePath) => {
+      if (!model || model.trim().length === 0) return;
+      if (modelCandidates.some((entry) => entry.model === model)) return;
+      modelCandidates.push({ model, source, sourcePath });
+    };
+    const envModel = getProviderEnvModel(provider);
+    if (envModel) {
+      addModelCandidate(envModel.value, envModel.source, envModel.sourcePath);
+    }
+    if (purpose === "judge") {
+      const judgeProvider = resolveJudgeProvider(cli, cwd);
+      const judgeModel = resolveJudgeModel(cli, cwd);
+      if (judgeProvider.value === provider) {
+        addModelCandidate(
+          judgeModel.value,
+          judgeModel.source,
+          judgeModel.sourcePath ?? "resolution-engine:judge-model"
+        );
+      }
+    } else if (purpose === "synthesis") {
+      const synthesisProvider = resolveSynthesisProvider(cli, cwd);
+      const synthesisModel = resolveSynthesisModel(cli, cwd);
+      if (synthesisProvider.value === provider) {
+        addModelCandidate(
+          synthesisModel.value,
+          synthesisModel.source,
+          synthesisModel.sourcePath ?? "resolution-engine:synthesis-model"
+        );
+      }
+    } else {
+      const projectPurposeModel = getPurposeSingleModel(projectConfig?.defaults, purpose);
+      const userPurposeModel = getPurposeSingleModel(userConfig?.defaults, purpose);
+      addModelCandidate(
+        projectPurposeModel,
+        "project",
+        `${paths.projectConfigFile}#defaults.intent.decomposition.model`
+      );
+      addModelCandidate(
+        userPurposeModel,
+        "user-config",
+        `${paths.userConfigFile}#defaults.intent.decomposition.model`
+      );
+    }
+    const profileModelOrder = candidateActiveProfile?.defaults?.providers?.[provider]?.modelOrder;
+    const projectModelOrder = projectConfig?.defaults?.providers?.[provider]?.modelOrder;
+    const userModelOrder = userConfig?.defaults?.providers?.[provider]?.modelOrder;
+    const modelOrder = profileModelOrder ?? projectModelOrder ?? userModelOrder;
+    if (modelOrder && modelOrder.length > 0) {
+      const orderSource = profileModelOrder ? "profile" : projectModelOrder ? "project" : "user-config";
+      const orderSourcePath = profileModelOrder ? `profile:${candidateActiveProfile.name}#defaults.providers.${provider}.modelOrder` : `${projectModelOrder ? paths.projectConfigFile : paths.userConfigFile}#defaults.providers.${provider}.modelOrder`;
+      for (const m of modelOrder) {
+        addModelCandidate(m, orderSource, orderSourcePath);
+      }
+    }
+    const profileProviderModel = candidateActiveProfile?.defaults?.providers?.[provider]?.model;
+    if (candidateActiveProfile && profileProviderModel) {
+      addModelCandidate(
+        profileProviderModel,
+        "profile",
+        `profile:${candidateActiveProfile.name}#defaults.providers.${provider}.model`
+      );
+    }
+    const projectProviderModel = projectConfig?.defaults?.providers?.[provider]?.model;
+    const userProviderModel = userConfig?.defaults?.providers?.[provider]?.model;
+    addModelCandidate(
+      projectProviderModel,
+      "project",
+      `${paths.projectConfigFile}#defaults.providers.${provider}.model`
+    );
+    addModelCandidate(
+      userProviderModel,
+      "user-config",
+      `${paths.userConfigFile}#defaults.providers.${provider}.model`
+    );
+    if (candidateActiveProfile?.defaults?.model) {
+      addModelCandidate(
+        candidateActiveProfile.defaults.model,
+        "profile",
+        `profile:${candidateActiveProfile.name}#defaults.model`
+      );
+    }
+    addModelCandidate(
+      projectConfig?.defaults?.model,
+      "project",
+      `${paths.projectConfigFile}#defaults.model`
+    );
+    addModelCandidate(
+      userConfig?.defaults?.model,
+      "user-config",
+      `${paths.userConfigFile}#defaults.model`
+    );
+    const validConfigModels = [];
+    for (const entry of modelCandidates) {
+      const valid = buildValidatedModelList(
+        provider,
+        [entry.model],
+        `${entry.source}:${entry.sourcePath}`,
+        registry
+      );
+      if (valid.length > 0) {
+        validConfigModels.push(entry);
+      }
+    }
+    if (validConfigModels.length > 0) {
+      for (const entry of validConfigModels) {
+        candidates.push(
+          buildCandidate({
+            provider,
+            model: entry.model,
+            purpose,
+            index: index++,
+            providerSource: resolvedProviderSource,
+            providerSourcePath: resolvedProviderSourcePath,
+            modelSource: entry.source,
+            modelSourcePath: entry.sourcePath
+          })
+        );
+      }
+      continue;
+    }
+    try {
+      const registryModel = ProviderRegistry.getProviderConfig(provider, registry).models.default;
+      const validatedModel = ProviderRegistry.resolveModel(provider, registryModel, registry);
+      candidates.push(
+        buildCandidate({
+          provider,
+          model: validatedModel,
+          purpose,
+          index: index++,
+          providerSource: resolvedProviderSource,
+          providerSourcePath: resolvedProviderSourcePath,
+          modelSource: "registry",
+          modelSourcePath: `providers.yaml#providers.${provider}.models.default`
+        })
+      );
+    } catch {
+      emitWarning(
+        "CFG-008",
+        {
+          taskId: "resolution-engine",
+          subsystem: "config",
+          executionPhase: "setup"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            provider,
+            operation: "resolveCandidates",
+            message: `Provider '${provider}' from ${providerSourceLabel} is not in the registry; skipping`
+          }
+        }
+      );
+    }
+  }
+  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 = 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;
+}
+function getConfigSummary(cli, cwd = process.cwd()) {
+  const config = resolveConfig(cli, cwd);
+  const lines = [
+    "Poetic Configuration:",
+    `  Default Provider: ${formatResolvedValue(config.defaultProvider)}`,
+    `  Default Strategy: ${formatResolvedValue(config.defaultStrategy)}`,
+    `  Default Model: ${formatResolvedValue(config.defaultModel)}`,
+    `  Decomposition Routing Policy: ${formatResolvedValue(config.decompositionRoutingPolicy)}`,
+    `  planExecute.blockerMode: ${formatResolvedValue(config.planExecute.blockerMode)}`,
+    `  Synthesis Model: ${formatResolvedValue(config.synthesisModel)}`,
+    `  Splitter Model: ${formatResolvedValue(config.splitterModel)}`,
+    "",
+    "Judge Configuration:",
+    `  Type: ${formatResolvedValue(config.judge.type)}`,
+    `  Provider: ${formatResolvedValue(config.judge.provider)}`,
+    `  Model: ${formatResolvedValue(config.judge.model)}`,
+    "",
+    "Provider Models:"
+  ];
+  for (const [provider, model] of Object.entries(config.providerModels)) {
+    lines.push(`  ${provider}: ${formatResolvedValue(model)}`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  JUDGE_SPECIFICITY,
+  coherentJudgeModelForProvider,
+  reconcileJudgePair,
+  InvalidProviderModelError,
+  resolveJudgeType,
+  clearConfigCaches,
+  loadPoeticConfigFile,
+  resolveAskConfig,
+  resolveProgressNarrationConfig,
+  loadProviderRegistryForCwd,
+  checkDefaultProviderEnablement,
+  DefaultProviderUnusableError,
+  assertDefaultProviderEnabled,
+  resolveDefaultProvider,
+  resolveDefaultJudgeProvider,
+  resolveReadyDefaultProvider,
+  resolveDefaultStrategy,
+  resolveProviderModel,
+  resolveJudgeProvider,
+  resolveJudgeModel,
+  resolveSynthesisModel,
+  resolveSynthesisProvider,
+  resolveSplitterModel,
+  resolveIntentDecompositionHints,
+  resolveIntentNonGoals,
+  resolveIntentDisableRepoContext,
+  resolveJudgeConfig,
+  resolveConfig,
+  resolvePlanExecuteConfig,
+  resolvePlanExecuteBlockerMode,
+  resolveConfiguredProviderExecutionTransport,
+  resolveProviderExecutionTransport,
+  resolveProviderExecutionTransportConfig,
+  resolveDecompositionRoutingPolicy,
+  resolveCandidates,
+  resolvePreferred,
+  formatResolvedValue,
+  getConfigSummary
+};
+//# sourceMappingURL=chunk-XPU2XADL.js.map